MessagesDelete::_checkDeletePermissions() - Code Metrics - elkarte/Elkarte - Measure and Improve Code Quality continuously with Scrutinizer

MessagesDelete::_checkDeletePermissions() F
last analyzed 2026-01-24 21:07 UTC

↳ Parent: MessagesDelete
Complexity

Conditions	54
Paths	1498
Size

Total Lines	148
Code Lines	67
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2970
Importance

Changes
Metric	Value
cc	54
eloc	67
nc	1498
nop	2
dl	0
loc	148
ccs	0
cts	82
cp	0
crap	2970
rs	0
c	0
b	0
f	0
How to fix Long Method Complexity

<?php

/**
 * This class takes care of deleting and restoring messages in boards
 * that means posts and topics
 *
 * @package   ElkArte Forum
 * @copyright ElkArte Forum contributors
 * @license   BSD http://opensource.org/licenses/BSD-3-Clause (see accompanying LICENSE.txt file)
 *
 * This file contains code covered by:
 * copyright: 2011 Simple Machines (http://www.simplemachines.org)
 *
 * @version 2.0 Beta 1
 *
 */

namespace ElkArte;

use ElkArte\Exceptions\Exception;

/**
 * Class MessagesDelete
 *
 * Methods for deleting and restoring messages in boards
 */
class MessagesDelete
{
	/** @var User The current user deleting something */
	protected $user;

	/** @var int[] Id of the messages not found. */
	private $_unfound_messages = [];

	/** @var int[] Id of the topics that should be restored */
	private $_topics_to_restore = [];

	/** @var int The board id of the recycle board */
	private $_recycle_board;

	/**
	 * Initialize the class! :P
	 *
	 * @param int|bool $recycle_enabled if the recycling is enabled.
	 * @param int|null $recycle_board the id of the recycle board (if any)
	 * @param User $user the user::info making the request
	 */
	public function __construct($recycle_enabled, $recycle_board, $user = null)
	{
		$this->_recycle_board = $recycle_enabled ? (int) $recycle_board : null;

		$this->user = $user ?? User::$info;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
	}

	/**
	 * Restores a bunch of messages in the recycle bin to the appropriate board.
	 * If any "first message" is within the array, it is added to the list of
	 * topics to restore (see MessagesDelete::restoreTopics)
	 *
	 * @param int[] $msgs_id Messages to restore
	 *
	 * @return array|void
	 */
	public function restoreMessages($msgs_id): ?array
	{
		$msgs = [];
		foreach ($msgs_id as $msg)
		{
			if (!empty($msg))
			{
				$msgs[] = $msg;
			}
		}

		if (empty($msgs))
		{
			return null;
		}

		$db = database();

		// Get the id_previous_board and id_previous_topic.
		$actioned_messages = [];
		$previous_topics = [];
		$db->fetchQuery('
			SELECT 
				m.id_topic, m.id_msg, m.id_board, m.subject, m.id_member, t.id_previous_board, t.id_previous_topic,
				t.id_first_msg, b.count_posts, COALESCE(pt.id_board, 0) AS possible_prev_board
			FROM {db_prefix}messages AS m
				INNER JOIN {db_prefix}topics AS t ON (t.id_topic = m.id_topic)
				INNER JOIN {db_prefix}boards AS b ON (b.id_board = m.id_board)
				LEFT JOIN {db_prefix}topics AS pt ON (pt.id_topic = t.id_previous_topic)
			WHERE m.id_msg IN ({array_int:messages})',
			[
				'messages' => $msgs,
			]
		)->fetch_callback(
			function ($row) use (&$actioned_messages, &$previous_topics) {
				// Restoring the first post means topic.
				if ((int) $row['id_msg'] === (int) $row['id_first_msg'] && (int) $row['id_previous_topic'] === (int) $row['id_topic'])
				{
					$this->_topics_to_restore[] = $row['id_topic'];
					return;
				}

				// Don't know where it's going?
				if (empty($row['id_previous_topic']))
				{
					$this->_unfound_messages[$row['id_msg']] = $row['subject'];
					return;
				}

				$previous_topics[] = $row['id_previous_topic'];
				if (empty($actioned_messages[$row['id_previous_topic']]))
				{
					$actioned_messages[$row['id_previous_topic']] = [
						'msgs' => [],
						'count_posts' => (int) $row['count_posts'],
						'subject' => $row['subject'],
						'previous_board' => $row['id_previous_board'],
						'possible_prev_board' => $row['possible_prev_board'],
						'current_topic' => (int) $row['id_topic'],
						'current_board' => (int) $row['id_board'],
						'members' => [],
					];
				}

				$actioned_messages[$row['id_previous_topic']]['msgs'][$row['id_msg']] = $row['subject'];
				if ($row['id_member'])
				{
					$actioned_messages[$row['id_previous_topic']]['members'][] = (int) $row['id_member'];
				}
			}
		);

		// Check for topics we are going to fully restore.
		foreach (array_keys($actioned_messages) as $topic)
		{
			if (in_array($topic, $this->_topics_to_restore))
			{
				unset($actioned_messages[$topic]);
			}
		}

		// Load any previous topics to check they exist.
		if (!empty($previous_topics))
		{
			$db->fetchQuery('
				SELECT 
					t.id_topic, t.id_board, m.subject
				FROM {db_prefix}topics AS t
					INNER JOIN {db_prefix}messages AS m ON (m.id_msg = t.id_first_msg)
				WHERE t.id_topic IN ({array_int:previous_topics})',
				[
					'previous_topics' => $previous_topics,
				]
			)->fetch_callback(
				static function ($row) use (&$previous_topics) {
					$previous_topics[$row['id_topic']] = [
						'board' => $row['id_board'],
						'subject' => $row['subject'],
					];
				}
			);
		}

		// Restore each topic.
		$messages = [];
		foreach ($actioned_messages as $topic => $data)
		{
			// If we have topics, we are going to restore the whole lot ignore them.
			if (in_array($topic, $this->_topics_to_restore))
			{
				unset($actioned_messages[$topic]);
				continue;
			}

			// Move the posts back then!
			if (isset($previous_topics[$topic]))
			{
				$this->_mergePosts(array_keys($data['msgs']), $data['current_topic'], $topic);

				// Log em.
				logAction('restore_posts', ['topic' => $topic, 'subject' => $previous_topics[$topic]['subject'], 'board' => empty($data['previous_board']) ? $data['possible_prev_board'] : $data['previous_board']]);
				foreach (array_keys($data['msgs']) as $m)
				{
					$messages[] = $m;
				}
			}
			else
			{
				foreach ($data['msgs'] as $id => $subject)
				{
					$this->_unfound_messages[$id] = $subject;
				}
			}
		}

		// Put the icons back.
		if (!empty($messages))
		{
			$db->query('', '
				UPDATE {db_prefix}messages
				SET icon = {string:icon}
				WHERE id_msg IN ({array_int:messages})',
				[
					'icon' => 'xx',
					'messages' => $messages,
				]
			);
		}

		return $actioned_messages;
	}

	/**
	 * Take a load of messages from one place and stick them in a topic
	 *
	 * @param int[] $msgs
	 * @param int $from_topic
	 * @param int $target_topic
	 */
	private function _mergePosts($msgs, $from_topic, $target_topic): void
	{
		$db = database();

		// @todo This really needs to be rewritten to take a load of messages from ANY topic, it's also inefficient.

		// Is it an array?
		if (!is_array($msgs))

		{
			$msgs = [$msgs];
		}

		// Let's make sure they are int.
		$msgs = array_map(static fn($value) => (int) $value, $msgs);

		// Get the source information.
		$request = $db->query('', '
			SELECT 
				t.id_board, t.id_first_msg, t.num_replies, t.unapproved_posts
			FROM {db_prefix}topics AS t
				INNER JOIN {db_prefix}boards AS b ON (b.id_board = t.id_board)
			WHERE t.id_topic = {int:from_topic}',
			[
				'from_topic' => $from_topic,
			]
		);
		[$from_board, $from_first_msg, $from_replies, $from_unapproved_posts] = $request->fetch_row();
		$request->free_result();

		// Get some target topic and board stats.
		$request = $db->query('', '
			SELECT 
				t.id_board, t.id_first_msg, t.num_replies, t.unapproved_posts, b.count_posts
			FROM {db_prefix}topics AS t
				INNER JOIN {db_prefix}boards AS b ON (b.id_board = t.id_board)
			WHERE t.id_topic = {int:target_topic}',
			[
				'target_topic' => $target_topic,
			]
		);
		[$target_board, $target_first_msg, $target_replies, $target_unapproved_posts, $count_posts] = $request->fetch_row();
		$request->free_result();

		// Let's see if the board that we are returning to has post-count enabled.
		if (empty($count_posts))
		{
			// Let's get the members that need their post-count restored.
			require_once(SUBSDIR . '/Members.subs.php');
			$db->fetchQuery('
				SELECT id_member
				FROM {db_prefix}messages
				WHERE id_msg IN ({array_int:messages})
					AND approved = {int:is_approved}',
				[
					'messages' => $msgs,
					'is_approved' => 1,
				]
			)->fetch_callback(
				static function ($row) {
					updateMemberData($row['id_member'], ['posts' => '+']);
				}
			);
		}

		// Time to move the messages.
		$db->query('', '
			UPDATE {db_prefix}messages
			SET
				id_topic = {int:target_topic},
				id_board = {int:target_board},
				icon = {string:icon}
			WHERE id_msg IN({array_int:msgs})',
			[
				'target_topic' => $target_topic,
				'target_board' => $target_board,
				'icon' => $target_board == $this->_recycle_board ? 'recycled' : 'xx',
				'msgs' => $msgs,
			]
		);

		// Fix the id_first_msg and id_last_msg for the target topic.
		$target_topic_data = [
			'num_replies' => 0,
			'unapproved_posts' => 0,
			'id_first_msg' => 9999999999,
		];
		$db->fetchQuery('
			SELECT 
				MIN(id_msg) AS id_first_msg, MAX(id_msg) AS id_last_msg, COUNT(*) AS message_count, approved
			FROM {db_prefix}messages
			WHERE id_topic = {int:target_topic}
			GROUP BY id_topic, approved
			ORDER BY approved ASC
			LIMIT 2',
			[
				'target_topic' => $target_topic,
			]
		)->fetch_callback(
			static function ($row) use (&$target_topic_data) {
				if ($row['id_first_msg'] < $target_topic_data['id_first_msg'])
				{
					$target_topic_data['id_first_msg'] = $row['id_first_msg'];
				}

				$target_topic_data['id_last_msg'] = $row['id_last_msg'];
				if (!$row['approved'])
				{
					$target_topic_data['unapproved_posts'] = $row['message_count'];
				}
				else
				{
					$target_topic_data['num_replies'] = max(0, $row['message_count'] - 1);
				}
			}
		);

		// We have a new post-count for the board.
		require_once(SUBSDIR . '/Boards.subs.php');
		incrementBoard($target_board, [
			'num_posts' => $target_topic_data['num_replies'] - $target_replies, // Let's keep in mind that the first message in a topic counts towards num_replies in a board.
			'unapproved_posts' => $target_topic_data['unapproved_posts'] - $target_unapproved_posts,
		]);

		// In some cases we merged the only post in a topic, so the topic data is left behind in the topic table.
		$request = $db->query('', '
			SELECT 
				id_topic
			FROM {db_prefix}messages
			WHERE id_topic = {int:from_topic}',
			[
				'from_topic' => $from_topic,
			]
		);

		// Remove the topic if it doesn't have any messages.
		$topic_exists = true;
		if ($request->num_rows() === 0)
		{
			require_once(SUBSDIR . '/Topic.subs.php');
			removeTopics($from_topic, false, true);
			$topic_exists = false;
		}

		$request->free_result();

		// Recycled topic.
		if ($topic_exists)
		{
			// Fix the id_first_msg and id_last_msg for the source topic.
			$source_topic_data = [
				'num_replies' => 0,
				'unapproved_posts' => 0,
				'id_first_msg' => 9999999999,
			];

			$db->fetchQuery('
				SELECT 
					MIN(id_msg) AS id_first_msg, MAX(id_msg) AS id_last_msg, COUNT(*) AS message_count, approved, subject
				FROM {db_prefix}messages
				WHERE id_topic = {int:from_topic}
				GROUP BY id_topic, approved
				ORDER BY approved ASC
				LIMIT 2',
				[
					'from_topic' => $from_topic,
				]
			)->fetch_callback(
				static function ($row) use (&$source_topic_data) {
					if ($row['id_first_msg'] < $source_topic_data['id_first_msg'])
					{
						$source_topic_data['id_first_msg'] = $row['id_first_msg'];
					}

					$source_topic_data['id_last_msg'] = $row['id_last_msg'];
					if (!$row['approved'])
					{
						$source_topic_data['unapproved_posts'] = $row['message_count'];
					}
					else
					{
						$source_topic_data['num_replies'] = max(0, $row['message_count'] - 1);
					}
				}
			);

			// Update the topic details for the source topic.
			setTopicAttribute($from_topic, [
				'id_first_msg' => $source_topic_data['id_first_msg'],
				'id_last_msg' => $source_topic_data['id_last_msg'],
				'num_replies' => $source_topic_data['num_replies'],
				'unapproved_posts' => $source_topic_data['unapproved_posts'],
			]);

			// We have a new post-count for the source board.
			incrementBoard($target_board, [
				'num_posts' => $source_topic_data['num_replies'] - $from_replies, // Let's keep in mind that the first message in a topic counts towards num_replies in a board.
				'unapproved_posts' => $source_topic_data['unapproved_posts'] - $from_unapproved_posts,
			]);
		}

		// Finally, get around to updating the destination topic, now all indexes etc. on the source are fixed.
		setTopicAttribute($target_topic, [
			'id_first_msg' => $target_topic_data['id_first_msg'],
			'id_last_msg' => $target_topic_data['id_last_msg'],
			'num_replies' => $target_topic_data['num_replies'],
			'unapproved_posts' => $target_topic_data['unapproved_posts'],
		]);

		// Need it to update some stats.
		require_once(SUBSDIR . '/Post.subs.php');
		require_once(SUBSDIR . '/Topic.subs.php');
		require_once(SUBSDIR . '/Messages.subs.php');

		// Update stats.
		updateTopicStats();
		updateMessageStats();

		// Subject cache?
		$cache_updates = [];
		if ($target_first_msg != $target_topic_data['id_first_msg'])
		{
			$cache_updates[] = $target_topic_data['id_first_msg'];
		}

		if (!empty($source_topic_data['id_first_msg']) && $from_first_msg != $source_topic_data['id_first_msg'])
		{
			$cache_updates[] = $source_topic_data['id_first_msg'];
		}

		if (!empty($cache_updates))
		{
			require_once(SUBSDIR . '/Messages.subs.php');
			$db->fetchQuery('
				SELECT 
					id_topic, subject
				FROM {db_prefix}messages
				WHERE id_msg IN ({array_int:first_messages})',
				[
					'first_messages' => $cache_updates,
				]
			)->fetch_callback(
				static function ($row) {
					updateSubjectStats($row['id_topic'], $row['subject']);
				}
			);
		}

		updateLastMessages([$from_board, $target_board]);
	}

	/**
	 * Prepares topics to be restored from the recycle bin to the appropriate board
	 *
	 * @param int[] $topics_id Topics to restore
	 */
	public function restoreTopics($topics_id): void
	{
		foreach ($topics_id as $topic)
		{
			if (!empty($topic))
			{
				$this->_topics_to_restore[] = $topic;
			}
		}
	}

	/**
	 * Actually restore the topics previously "collected"
	 */
	public function doRestore(): void
	{
		if (empty($this->_topics_to_restore))
		{
			return;
		}

		$db = database();

		require_once(SUBSDIR . '/Boards.subs.php');

		// Let's get the data for these topics.
		$request = $db->fetchQuery('
			SELECT 
				t.id_topic, t.id_previous_board, t.id_board, t.id_first_msg, m.subject
			FROM {db_prefix}topics AS t
				INNER JOIN {db_prefix}messages AS m ON (m.id_msg = t.id_first_msg)
			WHERE t.id_topic IN ({array_int:topics})',
			[
				'topics' => $this->_topics_to_restore,
			]
		);
		while (($row = $request->fetch_assoc()))
		{
			// We can only restore if the previous board is set.
			if (empty($row['id_previous_board']))
			{
				$this->_unfound_messages[$row['id_first_msg']] = $row['subject'];
				continue;
			}

			// Ok, we got here, so me move them from here to there.
			moveTopics($row['id_topic'], $row['id_previous_board']);

			// Let's remove the recycled icon.
			$db->query('', '
				UPDATE {db_prefix}messages
				SET icon = {string:icon}
				WHERE id_topic = {int:id_topic}',
				[
					'icon' => 'xx',
					'id_topic' => $row['id_topic'],
				]
			);

			// Let's see if the board that we are returning to has post-count enabled.
			$board_data = boardInfo($row['id_previous_board']);

			if (empty($board_data['count_posts']))
			{
				require_once(SUBSDIR . '/Members.subs.php');

				// Let's get the members that need their post-count restored.
				$db->fetchQuery('
					SELECT
						id_member, COUNT(id_msg) AS post_count
					FROM {db_prefix}messages
					WHERE id_topic = {int:topic}
						AND approved = {int:is_approved}
					GROUP BY id_member',
					[
						'topic' => $row['id_topic'],
						'is_approved' => 1,
					]
				)->fetch_callback(
					static function ($member) {
						updateMemberData($member['id_member'], ['posts' => 'posts + ' . $member['post_count']]);
					}
				);
			}

			// Log it.
			logAction('restore_topic', ['topic' => $row['id_topic'], 'board' => $row['id_board'], 'board_to' => $row['id_previous_board']]);
		}

		$request->free_result();
	}

	/**
	 * Returns either the list of messages not found, or the number
	 *
	 * @param bool $return_msg If true returns the array of not found messages,
	 *                         if false their number
	 * @return bool|int[]
	 */
	public function unfoundRestoreMessages($return_msg = false)
	{
		if ($return_msg)
		{
			return $this->_unfound_messages;
		}

		return !empty($this->_unfound_messages);
	}

	/**
	 * Remove a message from the forum.
	 *
	 * - If $check_permissions is true, and it is the first and only message in a topic, removes the topic
	 *
	 * @param int $message The ID of the message to be removed
	 * @param bool $decreasePostCount Whether to decrease the post-count or not (default: true)
	 * @param bool $check_permissions Whether to check permissions or not (default: true) (may result in fatal
	 *             errors or login screens)
	 *
	 * @return bool Whether the message was successfully removed or not
	 */
	public function removeMessage($message, $decreasePostCount = true, $check_permissions = true): bool
	{
		global $board, $modSettings;

		$db = database();

		$message = (int) $message;

		if (empty($message))
		{
			return false;
		}

		$row = $db->fetchQuery('
			SELECT
				m.id_msg, m.id_member, m.icon, m.poster_time, m.subject,' . (empty($modSettings['search_custom_index_config']) ? '' : ' m.body,') . '
				m.approved, t.id_topic, t.id_first_msg, t.id_last_msg, t.num_replies, t.id_board,
				t.id_member_started AS id_member_poster,
				b.count_posts
			FROM {db_prefix}messages AS m
				INNER JOIN {db_prefix}topics AS t ON (t.id_topic = m.id_topic)
				INNER JOIN {db_prefix}boards AS b ON (b.id_board = t.id_board)
			WHERE m.id_msg = {int:id_msg}
			LIMIT 1',
			[
				'id_msg' => $message,
			]
		)->fetch_assoc();

		if (empty($row))
		{
			return false;
		}

		if ($check_permissions)
		{
			$check = $this->_checkDeletePermissions($row, $board);
			if ($check === 'topic')
			{
				// This needs to be included for topic functions
				require_once(SUBSDIR . '/Topic.subs.php');
				removeTopics($row['id_topic']);

				return true;
			}

			if ($check === 'exit')
			{
				return false;
			}
		}

		// Deleting a recycled message cannot lower anyone's post-count.
		if ($row['icon'] === 'recycled')
		{
			$decreasePostCount = false;
		}

		// This is the last post, update the last post on the board.
		if ((int) $row['id_last_msg'] === $message)
		{
			// Find the last message, set it, and decrease the post-count.
			$row2 = $db->fetchQuery('
				SELECT 
					id_msg, id_member
				FROM {db_prefix}messages
				WHERE id_topic = {int:id_topic}
					AND id_msg != {int:id_msg}
				ORDER BY ' . ($modSettings['postmod_active'] ? 'approved DESC, ' : '') . 'id_msg DESC
				LIMIT 1',
				[
					'id_topic' => $row['id_topic'],
					'id_msg' => $message,
				]
			)->fetch_assoc();

			$db->query('', '
				UPDATE {db_prefix}topics
				SET
					id_last_msg = {int:id_last_msg},
					id_member_updated = {int:id_member_updated}' . (!$modSettings['postmod_active'] || $row['approved'] ? ',
					num_replies = CASE WHEN num_replies = {int:no_replies} THEN 0 ELSE num_replies - 1 END' : ',
					unapproved_posts = CASE WHEN unapproved_posts = {int:no_unapproved} THEN 0 ELSE unapproved_posts - 1 END') . '
				WHERE id_topic = {int:id_topic}',
				[
					'id_last_msg' => (int) $row2['id_msg'],
					'id_member_updated' => (int) $row2['id_member'],
					'no_replies' => 0,
					'no_unapproved' => 0,
					'id_topic' => (int) $row['id_topic'],
				]
			);
		}
		// Only decrease post-counts.
		else
		{
			$db->query('', '
				UPDATE {db_prefix}topics
				SET ' . ($row['approved'] ? '
					num_replies = CASE WHEN num_replies = {int:no_replies} THEN 0 ELSE num_replies - 1 END' : '
					unapproved_posts = CASE WHEN unapproved_posts = {int:no_unapproved} THEN 0 ELSE unapproved_posts - 1 END') . '
				WHERE id_topic = {int:id_topic}',
				[
					'no_replies' => 0,
					'no_unapproved' => 0,
					'id_topic' => (int) $row['id_topic'],
				]
			);
		}

		// Default recycle to false.
		$recycle = false;

		// If recycle topics have been set, make a copy of this message in the recycle board.
		// Make sure we're not recycling messages that are already on the recycle board.
		if (!empty($this->_recycle_board) && $row['id_board'] != $this->_recycle_board && $row['icon'] !== 'recycled')
		{
			// Check if the recycle board exists, and if so, get the read status.
			$request = $db->query('', '
				SELECT 
					(COALESCE(lb.id_msg, 0) >= b.id_msg_updated) AS is_seen, id_last_msg
				FROM {db_prefix}boards AS b
					LEFT JOIN {db_prefix}log_boards AS lb ON (lb.id_board = b.id_board AND lb.id_member = {int:current_member})
				WHERE b.id_board = {int:recycle_board}',
				[
					'current_member' => $this->user->id,

					'recycle_board' => $this->_recycle_board,
				]
			);

			if ($request->num_rows() === 0)
			{
				throw new Exceptions\Exception('recycle_no_valid_board');
			}

			[$isRead, $last_board_msg] = $request->fetch_row();
			$request->free_result();

			// Is there an existing topic in the recycle board to group this post with?
			$request = $db->query('', '
				SELECT 
					id_topic, id_first_msg, id_last_msg
				FROM {db_prefix}topics
				WHERE id_previous_topic = {int:id_previous_topic}
					AND id_board = {int:recycle_board}',
				[
					'id_previous_topic' => $row['id_topic'],
					'recycle_board' => $this->_recycle_board,
				]
			);
			[$id_recycle_topic, $first_topic_msg, $last_topic_msg] = $request->fetch_row();
			$request->free_result();

			// Insert a new topic in the recycle board if $id_recycle_topic is empty.
			if (empty($id_recycle_topic))
			{
				$insert_res = $db->insert('',
					'{db_prefix}topics',
					[
						'id_board' => 'int', 'id_member_started' => 'int', 'id_member_updated' => 'int', 'id_first_msg' => 'int',
						'id_last_msg' => 'int', 'unapproved_posts' => 'int', 'approved' => 'int', 'id_previous_topic' => 'int',
					],
					[
						$this->_recycle_board, $row['id_member'], $row['id_member'], $message,
						$message, 0, 1, $row['id_topic'],
					],
					['id_topic']
				);
				$topicID = $insert_res->insert_id();
			}
			else
			{
				// Capture the ID of the new topic...
				$topicID = $id_recycle_topic;
			}

			// If the topic creation went successful, move the message.
			if ($topicID > 0)
			{
				$db->query('', '
					UPDATE {db_prefix}messages
					SET
						id_topic = {int:id_topic},
						id_board = {int:recycle_board},
						icon = {string:recycled},
						approved = {int:is_approved}
					WHERE id_msg = {int:id_msg}',
					[
						'id_topic' => $topicID,
						'recycle_board' => $this->_recycle_board,
						'id_msg' => $message,
						'recycled' => 'recycled',
						'is_approved' => 1,
					]
				);

				// Take any reported posts with us...
				$db->query('', '
					UPDATE {db_prefix}log_reported
					SET
						id_topic = {int:id_topic},
						id_board = {int:recycle_board}
					WHERE id_msg = {int:id_msg}
						AND type = {string:msg}',
					[
						'id_topic' => $topicID,
						'recycle_board' => $this->_recycle_board,
						'id_msg' => $message,
						'msg' => 'msg',
					]
				);

				// Mark recycled topic as read.
				if ($this->user->is_guest === false)

				{
					require_once(SUBSDIR . '/Topic.subs.php');
					markTopicsRead([$this->user->id, $topicID, $modSettings['maxMsgID'], 0], true);
				}

				// Mark the recycle board as seen, if it was marked as seen before.
				if (!empty($isRead) && $this->user->is_guest === false)
				{
					require_once(SUBSDIR . '/Boards.subs.php');
					markBoardsRead($this->_recycle_board);
				}

				// Add one topic and post to the recycle bin board.
				$db->query('', '
					UPDATE {db_prefix}boards
					SET
						num_topics = num_topics + {int:num_topics_inc},
						num_posts = num_posts + 1' .
					($message > $last_board_msg ? ', id_last_msg = {int:id_merged_msg}' : '') . '
					WHERE id_board = {int:recycle_board}',
					[
						'num_topics_inc' => empty($id_recycle_topic) ? 1 : 0,
						'recycle_board' => $this->_recycle_board,
						'id_merged_msg' => $message,
					]
				);

				// Let's increase the num_replies, and the first/last message ID as appropriate.
				if (!empty($id_recycle_topic))
				{
					$db->query('', '
						UPDATE {db_prefix}topics
						SET num_replies = num_replies + 1' .
						($message > $last_topic_msg ? ', id_last_msg = {int:id_merged_msg}' : '') .
						($message < $first_topic_msg ? ', id_first_msg = {int:id_merged_msg}' : '') . '
						WHERE id_topic = {int:id_recycle_topic}',
						[
							'id_recycle_topic' => $id_recycle_topic,
							'id_merged_msg' => $message,
						]
					);
				}

				// Update mentions accessibility
				$this->deleteMessageMentions(messagesInTopics($topicID), true);

				// Make sure this message isn't getting deleted later on.
				$recycle = true;

				// Make sure we update the search subject index.
				require_once(SUBSDIR . '/Messages.subs.php');
				updateSubjectStats($topicID, $row['subject']);
			}

			// If it wasn't approved, don't keep it in the queue.
			if (!$row['approved'])
			{
				$db->query('', '
					DELETE FROM {db_prefix}approval_queue
					WHERE id_msg = {int:id_msg}
						AND id_attach = {int:id_attach}',
					[
						'id_msg' => $message,
						'id_attach' => 0,
					]
				);
			}
		}

		$db->query('', '
			UPDATE {db_prefix}boards
			SET ' . ($row['approved'] ? '
				num_posts = CASE WHEN num_posts = {int:no_posts} THEN 0 ELSE num_posts - 1 END' : '
				unapproved_posts = CASE WHEN unapproved_posts = {int:no_unapproved} THEN 0 ELSE unapproved_posts - 1 END') . '
			WHERE id_board = {int:id_board}',
			[
				'no_posts' => 0,
				'no_unapproved' => 0,
				'id_board' => $row['id_board'],
			]
		);

		// If the poster was registered and the board, this message was on increased
		// the member's posts when it was posted, decrease his or her post-count.
		if (!empty($row['id_member']) && $decreasePostCount && empty($row['count_posts']) && $row['approved'])
		{
			require_once(SUBSDIR . '/Members.subs.php');
			updateMemberData($row['id_member'], ['posts' => '-']);
		}

		// Only remove posts if they're not recycled.
		if (!$recycle)
		{
			// Update the like counts
			require_once(SUBSDIR . '/Likes.subs.php');
			decreaseLikeCounts($message);

			// Remove the likes!
			$db->query('', '
				DELETE FROM {db_prefix}message_likes
				WHERE id_msg = {int:id_msg}',
				[
					'id_msg' => $message,
				]
			);

			// Remove the mentions!
			$this->deleteMessageMentions($message);

			// Remove the message!
			$db->query('', '
				DELETE FROM {db_prefix}messages
				WHERE id_msg = {int:id_msg}',
				[
					'id_msg' => $message,
				]
			);

			if (!empty($modSettings['search_custom_index_config']))
			{
				$words = text2words($row['body'], true);
				if (!empty($words))
				{
					$db->query('', '
						DELETE FROM {db_prefix}log_search_words
						WHERE id_word IN ({array_int:word_list})
							AND id_msg = {int:id_msg}',
						[
							'word_list' => $words,
							'id_msg' => $message,
						]
					);
				}
			}

			// Delete attachment(s) if they exist.
			require_once(SUBSDIR . '/ManageAttachments.subs.php');
			$attachmentQuery = [
				'attachment_type' => 0,
				'id_msg' => $message,
			];
			removeAttachments($attachmentQuery);

			// Delete follow-ups too
			require_once(SUBSDIR . '/FollowUps.subs.php');

			// If it is an entire topic
			if ((int) $row['id_first_msg'] === (int) $message)
			{
				$db->query('', '
					DELETE FROM {db_prefix}follow_ups
					WHERE follow_ups IN ({array_int:topics})',
					[
						'topics' => $row['id_topic'],
					]
				);
			}

			// Allow mods to remove message-related data of their own (likes, maybe?)
			call_integration_hook('integrate_remove_message', [$message]);
		}

		// Update the pesky statistics.
		updateMessageStats();
		require_once(SUBSDIR . '/Topic.subs.php');
		updateTopicStats();
		updateSettings(['calendar_updated' => time(),]);

		// And now to update the last message of each board we messed with.
		require_once(SUBSDIR . '/Post.subs.php');
		if ($recycle)
		{
			updateLastMessages([$row['id_board'], $this->_recycle_board]);
		}
		else
		{
			updateLastMessages($row['id_board']);
		}

		// Close any moderation reports for this message.
		require_once(SUBSDIR . '/Moderation.subs.php');
		$updated_reports = updateReportsStatus($message, 'close', 1);
		if ($updated_reports != 0)
		{
			updateSettings(['last_mod_report_action' => time()]);
			recountOpenReports();
		}

		// Add it to the mod log.
		if (!allowedTo('delete_any'))
		{
			return false;
		}

		if (allowedTo('delete_own') && $row['id_member'] == $this->user->id)
		{
			return false;
		}

		logAction('delete', ['topic' => $row['id_topic'], 'subject' => $row['subject'], 'member' => $row['id_member'], 'board' => $row['id_board']]);
		return false;
	}

	/**
	 * When a message is removed, we need to remove associated mentions and updated the member
	 * mention count for anyone was mentioned in that message (like, quote, @, etc.)
	 *
	 * @param int|int[] $messages
	 * @param bool $recycle If recycle board is enabled, sets mentions as in_accessible, otherwise hard delete
	 */
	public function deleteMessageMentions($messages, $recycle = false): void
	{
		$db = database();

		$mentionTypes = ['mentionmem', 'likemsg', 'rlikemsg', 'quotedmem', 'watchedtopic', 'watchedboard'];
		$messages = is_array($messages) ? $messages : [$messages];
		$changeMe = [];

		// Who was mentioned in these messages
		$db->fetchQuery('
			SELECT 
				DISTINCT(id_member) as id_member
			FROM {db_prefix}log_mentions
			WHERE id_target IN ({array_int:messages})
				AND mention_type IN ({array_string:mention_types})',
			[
				'messages' => $messages,
				'mention_types' => $mentionTypes,
			]
		)->fetch_callback(
			function ($row) use (&$changeMe) {
				$changeMe[] = (int) $row['id_member'];
			}
		);

		if ($recycle === true)
		{
			// Set them as not accessible when they are going to the trashcan
			$db->query('', '
				UPDATE {db_prefix}log_mentions
				SET
					is_accessible = 0
				WHERE id_target IN ({array_int:messages})
					AND is_accessible = 1',
				[
					'messages' => $messages,
					'mention_types' => $mentionTypes,
				]
			);
		}
		else
		{
			// This message is really gone, so remove the mentions!
			$db->query('', '
				DELETE FROM {db_prefix}log_mentions
				WHERE id_target IN ({array_int:messages})
					AND mention_type IN ({array_string:mention_types})',
				[
					'messages' => $messages,
					'mention_types' => $mentionTypes,
				]
			);
		}

		// Update the mention count for this group
		require_once(SUBSDIR . '/Mentions.subs.php');
		foreach ($changeMe as $member)
		{
			countUserMentions(false, '', $member);
		}
	}

	/**
	 * Check if the user has the necessary permissions to delete a post.
	 *
	 * @param array $row Details on the message
	 * @param int $board The board ID
	 *
	 * @return bool|string 'topic' if the user has the necessary permissions and this is the only message in a topic
	 *                     'exit' if the user cannot delete an unapproved message,
	 *                      true if they have permission,
	 *                      exception otherwise.
	 * @throws Exception cannot_delete_replies, cannot_delete_own, modify_post_time_passed, cannot_delete_any, delFirstPost
	 */
	protected function _checkDeletePermissions($row, $board)
	{
		global $modSettings;

		$row['id_board'] = (int) $row['id_board'];
		$row['id_member_poster'] = (int) $row['id_member_poster'];
		$row['id_member'] = (int) $row['id_member'];
		$row['id_first_msg'] = (int) $row['id_first_msg'];
		$row['id_msg'] = (int) $row['id_msg'];
		$board = (int) $board;

		if (empty($board) || $row['id_board'] !== $board)
		{
			$delete_any = boardsAllowedTo('delete_any');

			if (!in_array(0, $delete_any) && !in_array($row['id_board'], $delete_any))
			{
				$delete_own = boardsAllowedTo('delete_own');
				$delete_own = in_array(0, $delete_own) || in_array($row['id_board'], $delete_own);
				$delete_own = in_array(0, /** @scrutinizer ignore-type */ $delete_own) || in_array($row['id_board'], $delete_own);
				$delete_replies = boardsAllowedTo('delete_replies');
				$delete_replies = in_array(0, $delete_replies) || in_array($row['id_board'], $delete_replies);

				// Their own checks
				if ($row['id_member'] === $this->user->id)

				{
					if (!$delete_own)
					{
						if ($row['id_member_poster'] === $this->user->id)
						{
							if (!$delete_replies)
							{
								throw new Exceptions\Exception('cannot_delete_replies', 'permission');
							}
						}
						else
						{
							throw new Exceptions\Exception('cannot_delete_own', 'permission');
						}
					}
					elseif (($row['id_member_poster'] !== $this->user->id || !$delete_replies) && !empty($modSettings['edit_disable_time']) && $row['poster_time'] + $modSettings['edit_disable_time'] * 60 < time())
					{
						throw new Exceptions\Exception('modify_post_time_passed', false);
					}
				}
				elseif ($row['id_member_poster'] === $this->user->id)
				{
					if (!$delete_replies)
					{
						throw new Exceptions\Exception('cannot_delete_replies', 'permission');
					}
				}
				else
				{
					throw new Exceptions\Exception('cannot_delete_any', 'permission');
				}
			}

			// Can't delete an unapproved message if you can't see it!
			if ($modSettings['postmod_active'] && !$row['approved'] && $row['id_member'] != $this->user->id && (!in_array(0, $delete_any) && !in_array($row['id_board'], $delete_any)))
			{
				$approve_posts = empty($this->user->mod_cache['ap']) ? boardsAllowedTo('approve_posts') : $this->user->mod_cache['ap'];

				if (!in_array(0, $approve_posts, true) && !in_array($row['id_board'], $approve_posts, true))
				{
					return 'exit';
				}
			}
		}
		else
		{
			// Check permissions to delete this message.
			if ($row['id_member'] === $this->user->id)
			{
				if (!allowedTo('delete_own'))
				{
					if ($row['id_member_poster'] === $this->user->id && !allowedTo('delete_any'))
					{
						isAllowedTo('delete_replies');
					}
					elseif (!allowedTo('delete_any'))
					{
						isAllowedTo('delete_own');
					}
				}
				elseif (!allowedTo('delete_any') && ($row['id_member_poster'] !== $this->user->id || !allowedTo('delete_replies')) && !empty($modSettings['edit_disable_time']) && $row['poster_time'] + $modSettings['edit_disable_time'] * 60 < time())
				{
					throw new Exceptions\Exception('modify_post_time_passed', false);
				}
			}
			elseif ($row['id_member_poster'] === $this->user->id && !allowedTo('delete_any'))
			{
				isAllowedTo('delete_replies');
			}
			else
			{
				isAllowedTo('delete_any');
			}

			if ($modSettings['postmod_active'] && !$row['approved'] && $row['id_member'] !== $this->user->id && !allowedTo('delete_own'))
			{
				isAllowedTo('approve_posts');
			}
		}

		// Delete the *whole* topic, but only if the topic consists of one message.
		if ($row['id_first_msg'] === $row['id_msg'])
		{
			if (empty($board) || $row['id_board'] !== $board)
			{
				$remove_own = false;
				$remove_any = boardsAllowedTo('remove_any');
				$remove_any = in_array(0, $remove_any) || in_array($row['id_board'], $remove_any, true);

				if (!$remove_any)
				{
					$remove_own = boardsAllowedTo('remove_own');
					$remove_own = in_array(0, $remove_own) || in_array($row['id_board'], $remove_own, true);
				}

				if ($row['id_member'] !== $this->user->id && !$remove_any)
				{
					throw new Exceptions\Exception('cannot_remove_any', 'permission');
				}

				if (!$remove_any && !$remove_own)
				{
					throw new Exceptions\Exception('cannot_remove_own', 'permission');
				}
			}
			elseif ($row['id_member'] !== $this->user->id)
			{
				// Check permissions to delete a whole topic.
				isAllowedTo('remove_any');
			}
			elseif (!allowedTo('remove_any'))
			{
				isAllowedTo('remove_own');
			}

			// ...if there is only one post.
			if (!empty($row['num_replies']))
			{
				throw new Exceptions\Exception('delFirstPost', false);
			}

			return 'topic';
		}

		return true;
	}
}

elkarte / Elkarte

MessagesDelete::_checkDeletePermissions() F last analyzed 2026-01-24 21:07 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

MessagesDelete::_checkDeletePermissions() F
last analyzed 2026-01-24 21:07 UTC
