ChangeTags.php

Go to the documentation of this file.

<?php
namespace MediaWiki\ChangeTags;
 
use MediaWiki\Context\IContextSource;
use MediaWiki\Context\RequestContext;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Html\Html;
use MediaWiki\Language\Language;
use MediaWiki\Language\MessageLocalizer;
use MediaWiki\Language\RawMessage;
use MediaWiki\Logging\ManualLogEntry;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Parser\Sanitizer;
use MediaWiki\Permissions\Authority;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\RecentChanges\RecentChange;
use MediaWiki\RevisionDelete\RevDelLogList;
use MediaWiki\Skin\Skin;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Status\Status;
use MediaWiki\Title\Title;
use MediaWiki\User\UserIdentity;
use Wikimedia\ObjectCache\WANObjectCache;
use Wikimedia\Rdbms\IReadableDatabase;
 
class ChangeTags {
    public const TAG_CONTENT_MODEL_CHANGE = 'mw-contentmodelchange';
    public const TAG_NEW_REDIRECT = 'mw-new-redirect';
    public const TAG_REMOVED_REDIRECT = 'mw-removed-redirect';
    public const TAG_CHANGED_REDIRECT_TARGET = 'mw-changed-redirect-target';
    public const TAG_BLANK = 'mw-blank';
    public const TAG_REPLACE = 'mw-replace';
    public const TAG_RECREATE = 'mw-recreated';
    public const TAG_ROLLBACK = 'mw-rollback';
    public const TAG_UNDO = 'mw-undo';
    public const TAG_MANUAL_REVERT = 'mw-manual-revert';
    public const TAG_REVERTED = 'mw-reverted';
    public const TAG_SERVER_SIDE_UPLOAD = 'mw-server-side-upload';
    public const TAG_IPBLOCK_APPEAL = 'mw-ipblock-appeal';
 
    public const REVERT_TAGS = [ self::TAG_ROLLBACK, self::TAG_UNDO, self::TAG_MANUAL_REVERT ];
 
    public const BYPASS_MAX_USAGE_CHECK = 1;
 
    private const MAX_DELETE_USES = 5000;
 
    private const CHANGE_TAG = 'change_tag';
 
    public const DISPLAY_TABLE_ALIAS = 'changetagdisplay';
 
    public const TAG_SET_ACTIVE_ONLY = true;
    public const TAG_SET_ALL = false;
 
    public const USE_ALL_TAGS = true;
    public const USE_SOFTWARE_TAGS_ONLY = false;
 
    public static function getSoftwareTags( $all = false ) {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->getSoftwareTags( $all );
    }
 
    public static function formatSummaryRow( $tags, $unused, ?MessageLocalizer $localizer = null ) {
        if ( $tags === '' || $tags === null ) {
            return [ '', [] ];
        }
        if ( !$localizer ) {
            $localizer = RequestContext::getMain();
        }
 
        $classes = [];
 
        $tags = explode( ',', $tags );
        $order = array_flip( MediaWikiServices::getInstance()->getChangeTagsStore()->listDefinedTags() );
        usort( $tags, static function ( $a, $b ) use ( $order ) {
            return ( $order[ $a ] ?? INF ) <=> ( $order[ $b ] ?? INF );
        } );
 
        $displayTags = [];
        foreach ( $tags as $tag ) {
            if ( $tag === '' ) {
                continue;
            }
            $classes[] = Sanitizer::escapeClass( "mw-tag-$tag" );
            $description = self::tagDescription( $tag, $localizer );
            if ( $description === false ) {
                continue;
            }
            $displayTags[] = Html::rawElement(
                'span',
                [ 'class' => 'mw-tag-marker ' .
                    Sanitizer::escapeClass( "mw-tag-marker-$tag" ) ],
                $description
            );
        }
 
        if ( !$displayTags ) {
            return [ '', $classes ];
        }
 
        $markers = $localizer->msg( 'tag-list-wrapper' )
            ->numParams( count( $displayTags ) )
            ->rawParams( implode( ' ', $displayTags ) )
            ->parse();
        $markers = Html::rawElement( 'span', [ 'class' => 'mw-tag-markers' ], $markers );
 
        return [ $markers, $classes ];
    }
 
    public static function tagShortDescriptionMessage( $tag, MessageLocalizer $context ) {
        $msg = $context->msg( "tag-$tag" );
        if ( !$msg->exists() ) {
            // No such message
            // Pass through ->msg(), even though it seems redundant, to avoid requesting
            // the user's language from session-less entry points (T227233)
            return $context->msg( new RawMessage( '$1', [ Message::plaintextParam( $tag ) ] ) );
        }
        if ( $msg->isDisabled() ) {
            // The message exists but is disabled, hide the tag.
            return false;
        }
 
        // Message exists and isn't disabled, use it.
        return $msg;
    }
 
    public static function tagHelpLink( $tag, MessageLocalizer $context ) {
        $msg = $context->msg( "tag-$tag-helppage" )->inContentLanguage();
        if ( !$msg->isDisabled() ) {
            return Skin::makeInternalOrExternalUrl( $msg->text() ) ?: null;
        }
        return null;
    }
 
    public static function tagDescription( $tag, MessageLocalizer $context ) {
        $msg = self::tagShortDescriptionMessage( $tag, $context );
        $link = self::tagHelpLink( $tag, $context );
        if ( $msg && $link ) {
            $label = $msg->parse();
            // Avoid invalid HTML caused by link wrapping if the label already contains a link
            if ( !str_contains( $label, '<a ' ) ) {
                return Html::rawElement( 'a', [ 'href' => $link ], $label );
            }
        }
        return $msg ? $msg->parse() : false;
    }
 
    public static function tagLongDescriptionMessage( $tag, MessageLocalizer $context ) {
        $msg = $context->msg( "tag-$tag-description" );
        return $msg->isDisabled() ? false : $msg;
    }
 
    public static function addTags( $tags, $rc_id = null, $rev_id = null,
        $log_id = null, $params = null, ?RecentChange $rc = null
    ) {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->addTags(
            $tags, $rc_id, $rev_id, $log_id, $params, $rc
        );
    }
 
    public static function updateTags( $tagsToAdd, $tagsToRemove, &$rc_id = null,
        &$rev_id = null, &$log_id = null, $params = null, ?RecentChange $rc = null,
        ?UserIdentity $user = null
    ) {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->updateTags(
            $tagsToAdd, $tagsToRemove, $rc_id, $rev_id, $log_id, $params, $rc, $user
        );
    }
 
    public static function getTagsWithData(
        IReadableDatabase $db, $rc_id = null, $rev_id = null, $log_id = null
    ) {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->getTagsWithData( $db, $rc_id, $rev_id, $log_id );
    }
 
    public static function getTags( IReadableDatabase $db, $rc_id = null, $rev_id = null, $log_id = null ) {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->getTags( $db, $rc_id, $rev_id, $log_id );
    }
 
    protected static function restrictedTagError( $msgOne, $msgMulti, $tags ) {
        $lang = RequestContext::getMain()->getLanguage();
        $tags = array_values( $tags );
        $count = count( $tags );
        $status = Status::newFatal( ( $count > 1 ) ? $msgMulti : $msgOne,
            $lang->commaList( $tags ), $count );
        $status->value = $tags;
        return $status;
    }
 
    public static function canAddTagsAccompanyingChange(
        array $tags,
        ?Authority $performer = null,
        $checkBlock = true
    ) {
        $user = null;
        $services = MediaWikiServices::getInstance();
        if ( $performer !== null ) {
            if ( !$performer->isAllowed( 'applychangetags' ) ) {
                return Status::newFatal( 'tags-apply-no-permission' );
            }
 
            if ( $checkBlock && $performer->getBlock() && $performer->getBlock()->isSitewide() ) {
                return Status::newFatal(
                    'tags-apply-blocked',
                    $performer->getUser()->getName()
                );
            }
 
            // ChangeTagsAllowedAdd hook still needs a full User object
            $user = $services->getUserFactory()->newFromAuthority( $performer );
        }
 
        // to be applied, a tag has to be explicitly defined
        $allowedTags = $services->getChangeTagsStore()->listExplicitlyDefinedTags();
        ( new HookRunner( $services->getHookContainer() ) )->onChangeTagsAllowedAdd( $allowedTags, $tags, $user );
        $disallowedTags = array_diff( $tags, $allowedTags );
        if ( $disallowedTags ) {
            return self::restrictedTagError( 'tags-apply-not-allowed-one',
                'tags-apply-not-allowed-multi', $disallowedTags );
        }
 
        return Status::newGood();
    }
 
    public static function canUpdateTags(
        array $tagsToAdd,
        array $tagsToRemove,
        ?Authority $performer = null
    ) {
        if ( $performer !== null ) {
            if ( !$performer->isDefinitelyAllowed( 'changetags' ) ) {
                return Status::newFatal( 'tags-update-no-permission' );
            }
 
            if ( $performer->getBlock() && $performer->getBlock()->isSitewide() ) {
                return Status::newFatal(
                    'tags-update-blocked',
                    $performer->getUser()->getName()
                );
            }
        }
 
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
        if ( $tagsToAdd ) {
            // to be added, a tag has to be explicitly defined
            // @todo Allow extensions to define tags that can be applied by users...
            $explicitlyDefinedTags = $changeTagsStore->listExplicitlyDefinedTags();
            $diff = array_diff( $tagsToAdd, $explicitlyDefinedTags );
            if ( $diff ) {
                return self::restrictedTagError( 'tags-update-add-not-allowed-one',
                    'tags-update-add-not-allowed-multi', $diff );
            }
        }
 
        if ( $tagsToRemove ) {
            // to be removed, a tag must not be defined by an extension, or equivalently it
            // has to be either explicitly defined or not defined at all
            // (assuming no edge case of a tag both explicitly-defined and extension-defined)
            $softwareDefinedTags = $changeTagsStore->listSoftwareDefinedTags();
            $intersect = array_intersect( $tagsToRemove, $softwareDefinedTags );
            if ( $intersect ) {
                return self::restrictedTagError( 'tags-update-remove-not-allowed-one',
                    'tags-update-remove-not-allowed-multi', $intersect );
            }
        }
 
        return Status::newGood();
    }
 
    public static function updateTagsWithChecks( $tagsToAdd, $tagsToRemove,
        $rc_id, $rev_id, $log_id, $params, string $reason, Authority $performer
    ) {
        if ( !$tagsToAdd && !$tagsToRemove ) {
            // no-op, don't bother
            return Status::newGood( (object)[
                'logId' => null,
                'addedTags' => [],
                'removedTags' => [],
            ] );
        }
 
        $tagsToAdd ??= [];
        $tagsToRemove ??= [];
 
        // are we allowed to do this?
        $result = self::canUpdateTags( $tagsToAdd, $tagsToRemove, $performer );
        if ( !$result->isOK() ) {
            $result->value = null;
            return $result;
        }
 
        // basic rate limiting
        $status = PermissionStatus::newEmpty();
        if ( !$performer->authorizeAction( 'changetags', $status ) ) {
            return Status::wrap( $status );
        }
 
        // do it!
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
        [ $tagsAdded, $tagsRemoved, $initialTags ] = $changeTagsStore->updateTags( $tagsToAdd,
            $tagsToRemove, $rc_id, $rev_id, $log_id, $params, null, $performer->getUser() );
        if ( !$tagsAdded && !$tagsRemoved ) {
            // no-op, don't log it
            return Status::newGood( (object)[
                'logId' => null,
                'addedTags' => [],
                'removedTags' => [],
            ] );
        }
 
        // log it
        $logEntry = new ManualLogEntry( 'tag', 'update' );
        $logEntry->setPerformer( $performer->getUser() );
        $logEntry->setComment( $reason );
 
        // find the appropriate target page
        if ( $rev_id ) {
            $revisionRecord = MediaWikiServices::getInstance()
                ->getRevisionLookup()
                ->getRevisionById( $rev_id );
            if ( $revisionRecord ) {
                $logEntry->setTarget( $revisionRecord->getPageAsLinkTarget() );
            }
        } elseif ( $log_id ) {
            // This function is from revision deletion logic and has nothing to do with
            // change tags, but it appears to be the only other place in core where we
            // perform logged actions on log items.
            $logEntry->setTarget( RevDelLogList::suggestTarget( null, [ $log_id ] ) );
        }
 
        if ( !$logEntry->getTarget() ) {
            // target is required, so we have to set something
            $logEntry->setTarget( SpecialPage::getTitleFor( 'Tags' ) );
        }
 
        $logParams = [
            '4::revid' => $rev_id,
            '5::logid' => $log_id,
            '6:list:tagsAdded' => $tagsAdded,
            '7:number:tagsAddedCount' => count( $tagsAdded ),
            '8:list:tagsRemoved' => $tagsRemoved,
            '9:number:tagsRemovedCount' => count( $tagsRemoved ),
            'initialTags' => $initialTags,
        ];
        $logEntry->setParameters( $logParams );
        $logEntry->setRelations( [ 'Tag' => array_merge( $tagsAdded, $tagsRemoved ) ] );
 
        $dbw = MediaWikiServices::getInstance()->getConnectionProvider()->getPrimaryDatabase();
        $logId = $logEntry->insert( $dbw );
        // Only send this to UDP, not RC, similar to patrol events
        $logEntry->publish( $logId, 'udp' );
 
        return Status::newGood( (object)[
            'logId' => $logId,
            'addedTags' => $tagsAdded,
            'removedTags' => $tagsRemoved,
        ] );
    }
 
    public static function modifyDisplayQuery( &$tables, &$fields, &$conds,
        &$join_conds, &$options, $filter_tag = '', bool $exclude = false
    ) {
        wfDeprecated( __METHOD__, '1.41' );
        MediaWikiServices::getInstance()->getChangeTagsStore()->modifyDisplayQuery(
            $tables,
            $fields,
            $conds,
            $join_conds,
            $options,
            $filter_tag,
            $exclude
        );
    }
 
    public static function getDisplayTableName() {
        wfDeprecated( __METHOD__, '1.41' );
        return self::CHANGE_TAG;
    }
 
    public static function makeTagSummarySubquery( $tables ) {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->makeTagSummarySubquery( $tables );
    }
 
    public static function buildTagFilterSelector(
        $selected = '', $ooui = false, ?IContextSource $context = null,
        bool $activeOnly = self::TAG_SET_ACTIVE_ONLY,
        bool $useAllTags = self::USE_ALL_TAGS
    ) {
        if ( !$context ) {
            $context = RequestContext::getMain();
        }
 
        $config = $context->getConfig();
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
        if ( !$config->get( MainConfigNames::UseTagFilter ) ||
        !count( $changeTagsStore->listDefinedTags() ) ) {
            return null;
        }
 
        $tags = self::getChangeTagList(
            $context,
            $context->getLanguage(),
            $activeOnly,
            $useAllTags,
            true
        );
 
        $autocomplete = [];
        foreach ( $tags as $tagInfo ) {
            $autocomplete[ $tagInfo['label'] ] = $tagInfo['name'];
        }
 
        $data = [];
        $data[0] = Html::rawElement(
            'label',
            [ 'for' => 'tagfilter' ],
            $context->msg( 'tag-filter' )->parse()
        );
 
        if ( $ooui ) {
            $options = Html::listDropdownOptionsOoui( $autocomplete );
 
            $data[1] = new \OOUI\ComboBoxInputWidget( [
                'id' => 'tagfilter',
                'name' => 'tagfilter',
                'value' => $selected,
                'classes' => 'mw-tagfilter-input',
                'options' => $options,
            ] );
        } else {
            $optionsHtml = '';
            foreach ( $autocomplete as $label => $name ) {
                $optionsHtml .= Html::element( 'option', [ 'value' => $name ], $label );
            }
            $datalistHtml = Html::rawElement( 'datalist', [ 'id' => 'tagfilter-datalist' ], $optionsHtml );
 
            $data[1] = Html::input(
                'tagfilter',
                $selected,
                'text',
                [
                    'class' => [ 'mw-tagfilter-input', 'mw-ui-input', 'mw-ui-input-inline' ],
                    'size' => 20,
                    'id' => 'tagfilter',
                    'list' => 'tagfilter-datalist',
                ]
            ) . $datalistHtml;
        }
 
        return $data;
    }
 
    public static function defineTag( $tag ) {
        wfDeprecated( __METHOD__, '1.41' );
        MediaWikiServices::getInstance()->getChangeTagsStore()->defineTag( $tag );
    }
 
    public static function canActivateTag( $tag, ?Authority $performer = null ) {
        if ( $performer !== null ) {
            if ( !$performer->isAllowed( 'managechangetags' ) ) {
                return Status::newFatal( 'tags-manage-no-permission' );
            }
            if ( $performer->getBlock() && $performer->getBlock()->isSitewide() ) {
                return Status::newFatal(
                    'tags-manage-blocked',
                    $performer->getUser()->getName()
                );
            }
        }
 
        // defined tags cannot be activated (a defined tag is either extension-
        // defined, in which case the extension chooses whether or not to active it;
        // or user-defined, in which case it is considered active)
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
        $definedTags = $changeTagsStore->listDefinedTags();
        if ( in_array( $tag, $definedTags ) ) {
            return Status::newFatal( 'tags-activate-not-allowed', $tag );
        }
 
        // non-existing tags cannot be activated
        if ( !isset( $changeTagsStore->tagUsageStatistics()[$tag] ) ) { // we already know the tag is undefined
            return Status::newFatal( 'tags-activate-not-found', $tag );
        }
 
        return Status::newGood();
    }
 
    public static function activateTagWithChecks( string $tag, string $reason, Authority $performer,
        bool $ignoreWarnings = false, array $logEntryTags = []
    ) {
        // are we allowed to do this?
        $result = self::canActivateTag( $tag, $performer );
        if ( $ignoreWarnings ? !$result->isOK() : !$result->isGood() ) {
            $result->value = null;
            return $result;
        }
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
 
        $changeTagsStore->defineTag( $tag );
 
        $logId = $changeTagsStore->logTagManagementAction( 'activate', $tag, $reason, $performer->getUser(),
            null, $logEntryTags );
 
        return Status::newGood( $logId );
    }
 
    public static function canDeactivateTag( $tag, ?Authority $performer = null ) {
        if ( $performer !== null ) {
            if ( !$performer->isAllowed( 'managechangetags' ) ) {
                return Status::newFatal( 'tags-manage-no-permission' );
            }
            if ( $performer->getBlock() && $performer->getBlock()->isSitewide() ) {
                return Status::newFatal(
                    'tags-manage-blocked',
                    $performer->getUser()->getName()
                );
            }
        }
 
        // only explicitly-defined tags can be deactivated
        $explicitlyDefinedTags = MediaWikiServices::getInstance()->getChangeTagsStore()->listExplicitlyDefinedTags();
        if ( !in_array( $tag, $explicitlyDefinedTags ) ) {
            return Status::newFatal( 'tags-deactivate-not-allowed', $tag );
        }
        return Status::newGood();
    }
 
    public static function deactivateTagWithChecks( string $tag, string $reason, Authority $performer,
        bool $ignoreWarnings = false, array $logEntryTags = []
    ) {
        // are we allowed to do this?
        $result = self::canDeactivateTag( $tag, $performer );
        if ( $ignoreWarnings ? !$result->isOK() : !$result->isGood() ) {
            $result->value = null;
            return $result;
        }
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
 
        $changeTagsStore->undefineTag( $tag );
 
        $logId = $changeTagsStore->logTagManagementAction( 'deactivate', $tag, $reason,
            $performer->getUser(), null, $logEntryTags );
 
        return Status::newGood( $logId );
    }
 
    public static function isTagNameValid( $tag ) {
        // no empty tags
        if ( $tag === '' ) {
            return Status::newFatal( 'tags-create-no-name' );
        }
 
        // tags cannot contain commas (used to be used as a delimiter in tag_summary table),
        // pipe (used as a delimiter between multiple tags in
        // SpecialRecentchanges and friends), or slashes (would break tag description messages in
        // MediaWiki namespace)
        if ( str_contains( $tag, ',' ) || str_contains( $tag, '|' ) || str_contains( $tag, '/' ) ) {
            return Status::newFatal( 'tags-create-invalid-chars' );
        }
 
        // could the MediaWiki namespace description messages be created?
        $title = Title::makeTitleSafe( NS_MEDIAWIKI, "Tag-$tag-description" );
        if ( $title === null ) {
            return Status::newFatal( 'tags-create-invalid-title-chars' );
        }
 
        return Status::newGood();
    }
 
    public static function canCreateTag( $tag, ?Authority $performer = null ) {
        $user = null;
        $services = MediaWikiServices::getInstance();
        if ( $performer !== null ) {
            if ( !$performer->isAllowed( 'managechangetags' ) ) {
                return Status::newFatal( 'tags-manage-no-permission' );
            }
            if ( $performer->getBlock() && $performer->getBlock()->isSitewide() ) {
                return Status::newFatal(
                    'tags-manage-blocked',
                    $performer->getUser()->getName()
                );
            }
            // ChangeTagCanCreate hook still needs a full User object
            $user = $services->getUserFactory()->newFromAuthority( $performer );
        }
 
        $status = self::isTagNameValid( $tag );
        if ( !$status->isGood() ) {
            return $status;
        }
 
        // does the tag already exist?
        $changeTagsStore = $services->getChangeTagsStore();
        if (
            isset( $changeTagsStore->tagUsageStatistics()[$tag] ) ||
            in_array( $tag, $changeTagsStore->listDefinedTags() )
        ) {
            return Status::newFatal( 'tags-create-already-exists', $tag );
        }
 
        // check with hooks
        $canCreateResult = Status::newGood();
        ( new HookRunner( $services->getHookContainer() ) )->onChangeTagCanCreate( $tag, $user, $canCreateResult );
        return $canCreateResult;
    }
 
    public static function createTagWithChecks( string $tag, string $reason, Authority $performer,
        bool $ignoreWarnings = false, array $logEntryTags = []
    ) {
        // are we allowed to do this?
        $result = self::canCreateTag( $tag, $performer );
        if ( $ignoreWarnings ? !$result->isOK() : !$result->isGood() ) {
            $result->value = null;
            return $result;
        }
 
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
        $changeTagsStore->defineTag( $tag );
        $logId = $changeTagsStore->logTagManagementAction( 'create', $tag, $reason,
            $performer->getUser(), null, $logEntryTags );
 
        return Status::newGood( $logId );
    }
 
    public static function deleteTagEverywhere( $tag ) {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->deleteTagEverywhere( $tag );
    }
 
    public static function canDeleteTag( $tag, ?Authority $performer = null, int $flags = 0 ) {
        $user = null;
        $services = MediaWikiServices::getInstance();
        if ( $performer !== null ) {
            if ( !$performer->isAllowed( 'deletechangetags' ) ) {
                return Status::newFatal( 'tags-delete-no-permission' );
            }
            if ( $performer->getBlock() && $performer->getBlock()->isSitewide() ) {
                return Status::newFatal(
                    'tags-manage-blocked',
                    $performer->getUser()->getName()
                );
            }
            // ChangeTagCanDelete hook still needs a full User object
            $user = $services->getUserFactory()->newFromAuthority( $performer );
        }
 
        $changeTagsStore = $services->getChangeTagsStore();
        $tagUsage = $changeTagsStore->tagUsageStatistics();
        if (
            !isset( $tagUsage[$tag] ) &&
            !in_array( $tag, $changeTagsStore->listDefinedTags() )
        ) {
            return Status::newFatal( 'tags-delete-not-found', $tag );
        }
 
        if ( $flags !== self::BYPASS_MAX_USAGE_CHECK &&
            isset( $tagUsage[$tag] ) &&
            $tagUsage[$tag] > self::MAX_DELETE_USES
        ) {
            return Status::newFatal( 'tags-delete-too-many-uses', $tag, self::MAX_DELETE_USES );
        }
 
        $softwareDefined = $changeTagsStore->listSoftwareDefinedTags();
        if ( in_array( $tag, $softwareDefined ) ) {
            // extension-defined tags can't be deleted unless the extension
            // specifically allows it
            $status = Status::newFatal( 'tags-delete-not-allowed' );
        } else {
            // user-defined tags are deletable unless otherwise specified
            $status = Status::newGood();
        }
 
        ( new HookRunner( $services->getHookContainer() ) )->onChangeTagCanDelete( $tag, $user, $status );
        return $status;
    }
 
    public static function deleteTagWithChecks( string $tag, string $reason, Authority $performer,
        bool $ignoreWarnings = false, array $logEntryTags = []
    ) {
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
        // are we allowed to do this?
        $result = self::canDeleteTag( $tag, $performer );
        if ( $ignoreWarnings ? !$result->isOK() : !$result->isGood() ) {
            $result->value = null;
            return $result;
        }
 
        // store the tag usage statistics
        $hitcount = $changeTagsStore->tagUsageStatistics()[$tag] ?? 0;
 
        // do it!
        $deleteResult = $changeTagsStore->deleteTagEverywhere( $tag );
        if ( !$deleteResult->isOK() ) {
            return $deleteResult;
        }
 
        // log it
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
        $logId = $changeTagsStore->logTagManagementAction( 'delete', $tag, $reason, $performer->getUser(),
            $hitcount, $logEntryTags );
 
        $deleteResult->value = $logId;
        return $deleteResult;
    }
 
    public static function listSoftwareActivatedTags() {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->listSoftwareActivatedTags();
    }
 
    public static function listDefinedTags() {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->listDefinedTags();
    }
 
    public static function listExplicitlyDefinedTags() {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->listExplicitlyDefinedTags();
    }
 
    public static function listSoftwareDefinedTags() {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->listSoftwareDefinedTags();
    }
 
    public static function purgeTagCacheAll() {
        wfDeprecated( __METHOD__, '1.41' );
        MediaWikiServices::getInstance()->getChangeTagsStore()->purgeTagCacheAll();
    }
 
    public static function tagUsageStatistics() {
        wfDeprecated( __METHOD__, '1.41' );
        return MediaWikiServices::getInstance()->getChangeTagsStore()->tagUsageStatistics();
    }
 
    private const TAG_DESC_CHARACTER_LIMIT = 120;
 
    public static function getChangeTagListSummary(
        MessageLocalizer $localizer,
        Language $lang,
        bool $activeOnly = self::TAG_SET_ACTIVE_ONLY,
        bool $useAllTags = self::USE_ALL_TAGS
    ) {
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
 
        if ( $useAllTags ) {
            $tagKeys = $changeTagsStore->listDefinedTags();
            $cacheKey = 'tags-list-summary';
        } else {
            $tagKeys = $changeTagsStore->getCoreDefinedTags();
            $cacheKey = 'core-software-tags-summary';
        }
 
        // if $tagHitCounts exists, check against it later to determine whether or not to omit tags
        $tagHitCounts = null;
        if ( $activeOnly ) {
            $tagHitCounts = $changeTagsStore->tagUsageStatistics();
        } else {
            // The full set of tags should use a different cache key than the subset
            $cacheKey .= '-all';
        }
 
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
        return $cache->getWithSetCallback(
            $cache->makeKey( $cacheKey, $lang->getCode() ),
            WANObjectCache::TTL_DAY,
            static function ( $oldValue, &$ttl, array &$setOpts ) use ( $localizer, $tagKeys, $tagHitCounts ) {
                $result = [];
                foreach ( $tagKeys as $tagName ) {
                    // Only list tags that are still actively defined
                    if ( $tagHitCounts !== null ) {
                        // Only list tags with more than 0 hits
                        $hits = $tagHitCounts[$tagName] ?? 0;
                        if ( $hits <= 0 ) {
                            continue;
                        }
                    }
 
                    $labelMsg = self::tagShortDescriptionMessage( $tagName, $localizer );
                    $helpLink = self::tagHelpLink( $tagName, $localizer );
                    $descriptionMsg = self::tagLongDescriptionMessage( $tagName, $localizer );
                    // Don't cache the message object, use the correct MessageLocalizer to parse later.
                    $result[] = [
                        'name' => $tagName,
                        'labelMsg' => (bool)$labelMsg,
                        'label' => $labelMsg ? $labelMsg->plain() : $tagName,
                        'descriptionMsg' => (bool)$descriptionMsg,
                        'description' => $descriptionMsg ? $descriptionMsg->plain() : '',
                        'helpLink' => $helpLink,
                        'cssClass' => Sanitizer::escapeClass( 'mw-tag-' . $tagName ),
                    ];
                }
                return $result;
            }
        );
    }
 
    public static function getChangeTagList(
        MessageLocalizer $localizer, Language $lang,
        bool $activeOnly = self::TAG_SET_ACTIVE_ONLY, bool $useAllTags = self::USE_ALL_TAGS,
        $labelsOnly = false
    ) {
        $tags = self::getChangeTagListSummary( $localizer, $lang, $activeOnly, $useAllTags );
 
        foreach ( $tags as &$tagInfo ) {
            if ( $tagInfo['labelMsg'] ) {
                // Optimization: Skip the parsing if the label contains only plain text (T344352)
                if ( wfEscapeWikiText( $tagInfo['label'] ) !== $tagInfo['label'] ) {
                    // Use localizer with the correct page title to parse plain message from the cache.
                    $labelMsg = new RawMessage( $tagInfo['label'] );
                    $tagInfo['label'] = Sanitizer::stripAllTags( $localizer->msg( $labelMsg )->parse() );
                }
            } else {
                $tagInfo['label'] = $localizer->msg( 'tag-hidden', $tagInfo['name'] )->text();
            }
            // Optimization: Skip parsing the descriptions if not needed by the caller (T344352)
            if ( $labelsOnly ) {
                unset( $tagInfo['description'] );
            } elseif ( $tagInfo['descriptionMsg'] ) {
                // Optimization: Skip the parsing if the description contains only plain text (T344352)
                if ( wfEscapeWikiText( $tagInfo['description'] ) !== $tagInfo['description'] ) {
                    $descriptionMsg = new RawMessage( $tagInfo['description'] );
                    $tagInfo['description'] = Sanitizer::stripAllTags( $localizer->msg( $descriptionMsg )->parse() );
                }
                $tagInfo['description'] = $lang->truncateForVisual( $tagInfo['description'],
                    self::TAG_DESC_CHARACTER_LIMIT );
            }
            unset( $tagInfo['labelMsg'] );
            unset( $tagInfo['descriptionMsg'] );
        }
 
        // Instead of sorting by hit count (disabled for now), sort by display name
        usort( $tags, static function ( $a, $b ) {
            return strcasecmp( $a['label'], $b['label'] );
        } );
        return $tags;
    }
 
    public static function showTagEditingUI( Authority $performer ) {
        $changeTagsStore = MediaWikiServices::getInstance()->getChangeTagsStore();
        return $performer->isAllowed( 'changetags' ) && (bool)$changeTagsStore->listExplicitlyDefinedTags();
    }
}
 
class_alias( ChangeTags::class, 'ChangeTags' );