WikiPage.php

Go to the documentation of this file.

<?php
use MediaWiki\Category\Category;
use MediaWiki\CommentStore\CommentStoreComment;
use MediaWiki\DAO\WikiAwareEntityTrait;
use MediaWiki\Deferred\DeferredUpdates;
use MediaWiki\Edit\PreparedEdit;
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\DeletePage;
use MediaWiki\Page\ExistingPageRecord;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\PageRecord;
use MediaWiki\Page\PageReference;
use MediaWiki\Page\PageStoreRecord;
use MediaWiki\Page\ParserOutputAccess;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Permissions\Authority;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Status\Status;
use MediaWiki\Storage\DerivedPageDataUpdater;
use MediaWiki\Storage\EditResult;
use MediaWiki\Storage\PageUpdater;
use MediaWiki\Storage\PageUpdaterFactory;
use MediaWiki\Storage\PageUpdateStatus;
use MediaWiki\Storage\PreparedUpdate;
use MediaWiki\Storage\RevisionSlotsUpdate;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleArrayFromResult;
use MediaWiki\User\User;
use MediaWiki\User\UserArrayFromResult;
use MediaWiki\User\UserIdentity;
use MediaWiki\Utils\MWTimestamp;
use MediaWiki\WikiMap\WikiMap;
use Wikimedia\Assert\Assert;
use Wikimedia\Assert\PreconditionException;
use Wikimedia\NonSerializable\NonSerializableTrait;
use Wikimedia\Rdbms\FakeResultWrapper;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Rdbms\IReadableDatabase;
use Wikimedia\Rdbms\SelectQueryBuilder;
 
class WikiPage implements Page, PageRecord {
    use NonSerializableTrait;
    use ProtectedHookAccessorTrait;
    use WikiAwareEntityTrait;
 
    // Constants for $mDataLoadedFrom and related
 
    protected $mTitle;
 
    protected $mDataLoaded = false;
 
    private $mPageIsRedirectField = false;
 
    protected $mRedirectTarget = null;
 
    private $mIsNew = false;
 
    protected $mLatest = false;
 
    protected $mPreparedEdit = false;
 
    protected $mId = null;
 
    protected $mDataLoadedFrom = IDBAccessObject::READ_NONE;
 
    private $mLastRevision = null;
 
    protected $mTimestamp = '';
 
    protected $mTouched = '19700101000000';
 
    protected $mLanguage = null;
 
    protected $mLinksUpdated = '19700101000000';
 
    private $derivedDataUpdater = null;
 
    public function __construct( PageIdentity $pageIdentity ) {
        $pageIdentity->assertWiki( PageIdentity::LOCAL );
 
        // TODO: remove the need for casting to Title.
        $title = Title::newFromPageIdentity( $pageIdentity );
        if ( !$title->canExist() ) {
            throw new InvalidArgumentException( "WikiPage constructed on a Title that cannot exist as a page: $title" );
        }
 
        $this->mTitle = $title;
    }
 
    public function __clone() {
        $this->mTitle = clone $this->mTitle;
    }
 
    public static function convertSelectType( $type ) {
        switch ( $type ) {
            case 'fromdb':
                return IDBAccessObject::READ_NORMAL;
            case 'fromdbmaster':
                return IDBAccessObject::READ_LATEST;
            case 'forupdate':
                return IDBAccessObject::READ_LOCKING;
            default:
                // It may already be an integer or whatever else
                return $type;
        }
    }
 
    private function getPageUpdaterFactory(): PageUpdaterFactory {
        return MediaWikiServices::getInstance()->getPageUpdaterFactory();
    }
 
    private function getRevisionStore() {
        return MediaWikiServices::getInstance()->getRevisionStore();
    }
 
    private function getDBLoadBalancer() {
        return MediaWikiServices::getInstance()->getDBLoadBalancer();
    }
 
    public function getActionOverrides() {
        return $this->getContentHandler()->getActionOverrides();
    }
 
    public function getContentHandler() {
        $factory = MediaWikiServices::getInstance()->getContentHandlerFactory();
        return $factory->getContentHandler( $this->getContentModel() );
    }
 
    public function getTitle(): Title {
        return $this->mTitle;
    }
 
    public function clear() {
        $this->mDataLoaded = false;
        $this->mDataLoadedFrom = IDBAccessObject::READ_NONE;
 
        $this->clearCacheFields();
    }
 
    protected function clearCacheFields() {
        $this->mId = null;
        $this->mRedirectTarget = null; // Title object if set
        $this->mPageIsRedirectField = false;
        $this->mLastRevision = null; // Latest revision
        $this->mTouched = '19700101000000';
        $this->mLanguage = null;
        $this->mLinksUpdated = '19700101000000';
        $this->mTimestamp = '';
        $this->mIsNew = false;
        $this->mLatest = false;
        // T59026: do not clear $this->derivedDataUpdater since getDerivedDataUpdater() already
        // checks the requested rev ID and content against the cached one. For most
        // content types, the output should not change during the lifetime of this cache.
        // Clearing it can cause extra parses on edit for no reason.
    }
 
    public function clearPreparedEdit() {
        $this->mPreparedEdit = false;
    }
 
    public static function getQueryInfo() {
        $pageLanguageUseDB = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::PageLanguageUseDB );
 
        $ret = [
            'tables' => [ 'page' ],
            'fields' => [
                'page_id',
                'page_namespace',
                'page_title',
                'page_is_redirect',
                'page_is_new',
                'page_random',
                'page_touched',
                'page_links_updated',
                'page_latest',
                'page_len',
                'page_content_model',
            ],
            'joins' => [],
        ];
 
        if ( $pageLanguageUseDB ) {
            $ret['fields'][] = 'page_lang';
        }
 
        return $ret;
    }
 
    protected function pageData( $dbr, $conditions, $options = [] ) {
        $pageQuery = self::getQueryInfo();
 
        $this->getHookRunner()->onArticlePageDataBefore(
            $this, $pageQuery['fields'], $pageQuery['tables'], $pageQuery['joins'] );
 
        $row = $dbr->newSelectQueryBuilder()
            ->queryInfo( $pageQuery )
            ->where( $conditions )
            ->caller( __METHOD__ )
            ->options( $options )
            ->fetchRow();
 
        $this->getHookRunner()->onArticlePageDataAfter( $this, $row );
 
        return $row;
    }
 
    public function pageDataFromTitle( $dbr, $title, $recency = IDBAccessObject::READ_NORMAL ) {
        if ( !$title->canExist() ) {
            return false;
        }
        $options = [];
        if ( ( $recency & IDBAccessObject::READ_EXCLUSIVE ) == IDBAccessObject::READ_EXCLUSIVE ) {
            $options[] = 'FOR UPDATE';
        } elseif ( ( $recency & IDBAccessObject::READ_LOCKING ) == IDBAccessObject::READ_LOCKING ) {
            $options[] = 'LOCK IN SHARE MODE';
        }
 
        return $this->pageData( $dbr, [
            'page_namespace' => $title->getNamespace(),
            'page_title' => $title->getDBkey() ], $options );
    }
 
    public function pageDataFromId( $dbr, $id, $options = [] ) {
        return $this->pageData( $dbr, [ 'page_id' => $id ], $options );
    }
 
    public function loadPageData( $from = 'fromdb' ) {
        $from = self::convertSelectType( $from );
        if ( is_int( $from ) && $from <= $this->mDataLoadedFrom ) {
            // We already have the data from the correct location, no need to load it twice.
            return;
        }
 
        if ( is_int( $from ) ) {
            $loadBalancer = $this->getDBLoadBalancer();
            if ( ( $from & IDBAccessObject::READ_LATEST ) == IDBAccessObject::READ_LATEST ) {
                $index = DB_PRIMARY;
            } else {
                $index = DB_REPLICA;
            }
            $db = $loadBalancer->getConnection( $index );
            $data = $this->pageDataFromTitle( $db, $this->mTitle, $from );
 
            if ( !$data
                && $index == DB_REPLICA
                && $loadBalancer->hasReplicaServers()
                && $loadBalancer->hasOrMadeRecentPrimaryChanges()
            ) {
                $from = IDBAccessObject::READ_LATEST;
                $db = $loadBalancer->getConnection( DB_PRIMARY );
                $data = $this->pageDataFromTitle( $db, $this->mTitle, $from );
            }
        } else {
            // No idea from where the caller got this data, assume replica DB.
            $data = $from;
            $from = IDBAccessObject::READ_NORMAL;
        }
 
        $this->loadFromRow( $data, $from );
    }
 
    public function wasLoadedFrom( $from ) {
        $from = self::convertSelectType( $from );
 
        if ( !is_int( $from ) ) {
            // No idea from where the caller got this data, assume replica DB.
            $from = IDBAccessObject::READ_NORMAL;
        }
 
        if ( $from <= $this->mDataLoadedFrom ) {
            return true;
        }
 
        return false;
    }
 
    public function loadFromRow( $data, $from ) {
        $lc = MediaWikiServices::getInstance()->getLinkCache();
        $lc->clearLink( $this->mTitle );
 
        if ( $data ) {
            $lc->addGoodLinkObjFromRow( $this->mTitle, $data );
 
            $this->mTitle->loadFromRow( $data );
            $this->mId = intval( $data->page_id );
            $this->mTouched = MWTimestamp::convert( TS_MW, $data->page_touched );
            $this->mLanguage = $data->page_lang ?? null;
            $this->mLinksUpdated = $data->page_links_updated === null
                ? null
                : MWTimestamp::convert( TS_MW, $data->page_links_updated );
            $this->mPageIsRedirectField = (bool)$data->page_is_redirect;
            $this->mIsNew = (bool)( $data->page_is_new ?? 0 );
            $this->mLatest = intval( $data->page_latest );
            // T39225: $latest may no longer match the cached latest RevisionRecord object.
            // Double-check the ID of any cached latest RevisionRecord object for consistency.
            if ( $this->mLastRevision && $this->mLastRevision->getId() != $this->mLatest ) {
                $this->mLastRevision = null;
                $this->mTimestamp = '';
            }
        } else {
            $lc->addBadLinkObj( $this->mTitle );
 
            $this->mTitle->loadFromRow( false );
 
            $this->clearCacheFields();
 
            $this->mId = 0;
        }
 
        $this->mDataLoaded = true;
        $this->mDataLoadedFrom = self::convertSelectType( $from );
    }
 
    public function getId( $wikiId = self::LOCAL ): int {
        $this->assertWiki( $wikiId );
 
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return $this->mId;
    }
 
    public function exists(): bool {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return $this->mId > 0;
    }
 
    public function hasViewableContent() {
        return $this->mTitle->isKnown();
    }
 
    public function isRedirect() {
        return $this->getRedirectTarget() !== null;
    }
 
    public function isNew() {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
 
        return $this->mIsNew;
    }
 
    public function getContentModel() {
        if ( $this->exists() ) {
            $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
 
            return $cache->getWithSetCallback(
                $cache->makeKey( 'page-content-model', $this->getLatest() ),
                $cache::TTL_MONTH,
                function () {
                    $rev = $this->getRevisionRecord();
                    if ( $rev ) {
                        // Look at the revision's actual content model
                        $slot = $rev->getSlot(
                            SlotRecord::MAIN,
                            RevisionRecord::RAW
                        );
                        return $slot->getModel();
                    } else {
                        LoggerFactory::getInstance( 'wikipage' )->warning(
                            'Page exists but has no (visible) revisions!',
                            [
                                'page-title' => $this->mTitle->getPrefixedDBkey(),
                                'page-id' => $this->getId(),
                            ]
                        );
                        return $this->mTitle->getContentModel();
                    }
                },
                [ 'pcTTL' => $cache::TTL_PROC_LONG ]
            );
        }
 
        // use the default model for this page
        return $this->mTitle->getContentModel();
    }
 
    public function checkTouched() {
        return ( $this->exists() && !$this->isRedirect() );
    }
 
    public function getTouched() {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return $this->mTouched;
    }
 
    public function getLanguage() {
        if ( !$this->mDataLoaded ) {
            $this->loadLastEdit();
        }
 
        return $this->mLanguage;
    }
 
    public function getLinksTimestamp() {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return $this->mLinksUpdated;
    }
 
    public function getLatest( $wikiId = self::LOCAL ) {
        $this->assertWiki( $wikiId );
 
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return (int)$this->mLatest;
    }
 
    protected function loadLastEdit() {
        if ( $this->mLastRevision !== null ) {
            return; // already loaded
        }
 
        $latest = $this->getLatest();
        if ( !$latest ) {
            return; // page doesn't exist or is missing page_latest info
        }
 
        if ( $this->mDataLoadedFrom == IDBAccessObject::READ_LOCKING ) {
            // T39225: if session S1 loads the page row FOR UPDATE, the result always
            // includes the latest changes committed. This is true even within REPEATABLE-READ
            // transactions, where S1 normally only sees changes committed before the first S1
            // SELECT. Thus we need S1 to also gets the revision row FOR UPDATE; otherwise, it
            // may not find it since a page row UPDATE and revision row INSERT by S2 may have
            // happened after the first S1 SELECT.
            // https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html#isolevel_repeatable-read
            $revision = $this->getRevisionStore()
                ->getRevisionByPageId( $this->getId(), $latest, IDBAccessObject::READ_LOCKING );
        } elseif ( $this->mDataLoadedFrom == IDBAccessObject::READ_LATEST ) {
            // Bug T93976: if page_latest was loaded from the primary DB, fetch the
            // revision from there as well, as it may not exist yet on a replica DB.
            // Also, this keeps the queries in the same REPEATABLE-READ snapshot.
            $revision = $this->getRevisionStore()
                ->getRevisionByPageId( $this->getId(), $latest, IDBAccessObject::READ_LATEST );
        } else {
            $revision = $this->getRevisionStore()->getKnownCurrentRevision( $this->getTitle(), $latest );
        }
 
        if ( $revision ) {
            $this->setLastEdit( $revision );
        }
    }
 
    private function setLastEdit( RevisionRecord $revRecord ) {
        $this->mLastRevision = $revRecord;
        $this->mLatest = $revRecord->getId();
        $this->mTimestamp = $revRecord->getTimestamp();
        $this->mTouched = max( $this->mTouched, $revRecord->getTimestamp() );
    }
 
    public function getRevisionRecord() {
        $this->loadLastEdit();
        return $this->mLastRevision;
    }
 
    public function getContent( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            return $this->mLastRevision->getContent( SlotRecord::MAIN, $audience, $performer );
        }
        return null;
    }
 
    public function getTimestamp() {
        // Check if the field has been filled by WikiPage::setTimestamp()
        if ( !$this->mTimestamp ) {
            $this->loadLastEdit();
        }
 
        return MWTimestamp::convert( TS_MW, $this->mTimestamp );
    }
 
    public function setTimestamp( $ts ) {
        $this->mTimestamp = MWTimestamp::convert( TS_MW, $ts );
    }
 
    public function getUser( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            $revUser = $this->mLastRevision->getUser( $audience, $performer );
            return $revUser ? $revUser->getId() : 0;
        } else {
            return -1;
        }
    }
 
    public function getCreator( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $revRecord = $this->getRevisionStore()->getFirstRevision( $this->getTitle() );
        if ( $revRecord ) {
            return $revRecord->getUser( $audience, $performer );
        } else {
            return null;
        }
    }
 
    public function getUserText( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            $revUser = $this->mLastRevision->getUser( $audience, $performer );
            return $revUser ? $revUser->getName() : '';
        } else {
            return '';
        }
    }
 
    public function getComment( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            $revComment = $this->mLastRevision->getComment( $audience, $performer );
            return $revComment ? $revComment->text : '';
        } else {
            return '';
        }
    }
 
    public function getMinorEdit() {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            return $this->mLastRevision->isMinor();
        } else {
            return false;
        }
    }
 
    public function isCountable( $editInfo = false ) {
        $mwServices = MediaWikiServices::getInstance();
        $articleCountMethod = $mwServices->getMainConfig()->get( MainConfigNames::ArticleCountMethod );
 
        // NOTE: Keep in sync with DerivedPageDataUpdater::isCountable.
 
        if ( !$this->mTitle->isContentPage() ) {
            return false;
        }
 
        if ( $editInfo instanceof PreparedEdit ) {
            // NOTE: only the main slot can make a page a redirect
            $content = $editInfo->pstContent;
        } elseif ( $editInfo instanceof PreparedUpdate ) {
            // NOTE: only the main slot can make a page a redirect
            $content = $editInfo->getRawContent( SlotRecord::MAIN );
        } else {
            $content = $this->getContent();
        }
 
        if ( !$content || $content->isRedirect() ) {
            return false;
        }
 
        $hasLinks = null;
 
        if ( $articleCountMethod === 'link' ) {
            // nasty special case to avoid re-parsing to detect links
 
            if ( $editInfo ) {
                // ParserOutput::getLinks() is a 2D array of page links, so
                // to be really correct we would need to recurse in the array
                // but the main array should only have items in it if there are
                // links.
                $hasLinks = (bool)count( $editInfo->output->getLinks() );
            } else {
                // NOTE: keep in sync with RevisionRenderer::getLinkCount
                // NOTE: keep in sync with DerivedPageDataUpdater::isCountable
                $dbr = $mwServices->getConnectionProvider()->getReplicaDatabase();
                $hasLinks = (bool)$dbr->newSelectQueryBuilder()
                    ->select( '1' )
                    ->from( 'pagelinks' )
                    ->where( [ 'pl_from' => $this->getId() ] )
                    ->caller( __METHOD__ )->fetchField();
            }
        }
 
        // TODO: MCR: determine $hasLinks for each slot, and use that info
        // with that slot's Content's isCountable method. That requires per-
        // slot ParserOutput in the ParserCache, or per-slot info in the
        // pagelinks table.
        return $content->isCountable( $hasLinks );
    }
 
    public function getRedirectTarget() {
        if ( $this->mRedirectTarget !== null ) {
            return $this->mRedirectTarget;
        }
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        if ( !$this->mPageIsRedirectField ) {
            return null;
        }
 
        // Query the redirect table
        $dbr = MediaWikiServices::getInstance()->getConnectionProvider()->getReplicaDatabase();
        $row = $dbr->newSelectQueryBuilder()
            ->select( [ 'rd_namespace', 'rd_title', 'rd_fragment', 'rd_interwiki' ] )
            ->from( 'redirect' )
            ->where( [ 'rd_from' => $this->getId() ] )
            ->caller( __METHOD__ )->fetchRow();
 
        if ( !$row ) {
            LoggerFactory::getInstance( 'wikipage' )->info(
                'WikiPage found inconsistent redirect status; probably the page was deleted after it was loaded'
            );
            return null;
        }
 
        $this->mRedirectTarget = self::createRedirectTarget(
            $row->rd_namespace, $row->rd_title,
            $row->rd_fragment, $row->rd_interwiki
        );
        return $this->mRedirectTarget;
    }
 
    private static function truncateFragment( $fragment ) {
        return mb_strcut( $fragment, 0, 255 );
    }
 
    private static function createRedirectTarget( $namespace, $title, $fragment, $interwiki ): ?Title {
        // (T203942) We can't redirect to Media namespace because it's virtual.
        // We don't want to modify Title objects farther down the
        // line. So, let's fix this here by changing to File namespace.
        if ( $namespace == NS_MEDIA ) {
            $namespace = NS_FILE;
        }
 
        // mimic behaviour of self::insertRedirectEntry for fragments that didn't
        // come from the redirect table
        $fragment = self::truncateFragment( $fragment );
 
        // T261347: be defensive when fetching data from the redirect table.
        // Use Title::makeTitleSafe(), and if that returns null, ignore the
        // row. In an ideal world, the DB would be cleaned up after a
        // namespace change, but nobody could be bothered to do that.
        $title = Title::makeTitleSafe( $namespace, $title, $fragment, $interwiki );
        if ( $title !== null && $title->isValidRedirectTarget() ) {
            return $title;
        }
        return null;
    }
 
    public function insertRedirectEntry( LinkTarget $rt, $oldLatest = null ) {
        $rt = Title::newFromLinkTarget( $rt );
        if ( !$rt->isValidRedirectTarget() ) {
            // Don't put a bad redirect into the database (T278367)
            return false;
        }
 
        $dbw = MediaWikiServices::getInstance()->getConnectionProvider()->getPrimaryDatabase();
        $dbw->startAtomic( __METHOD__ );
 
        if ( !$oldLatest || $oldLatest == $this->lockAndGetLatest() ) {
            $truncatedFragment = self::truncateFragment( $rt->getFragment() );
            $dbw->newInsertQueryBuilder()
                ->insertInto( 'redirect' )
                ->row( [
                    'rd_from' => $this->getId(),
                    'rd_namespace' => $rt->getNamespace(),
                    'rd_title' => $rt->getDBkey(),
                    'rd_fragment' => $truncatedFragment,
                    'rd_interwiki' => $rt->getInterwiki(),
                ] )
                ->onDuplicateKeyUpdate()
                ->uniqueIndexFields( [ 'rd_from' ] )
                ->set( [
                    'rd_namespace' => $rt->getNamespace(),
                    'rd_title' => $rt->getDBkey(),
                    'rd_fragment' => $truncatedFragment,
                    'rd_interwiki' => $rt->getInterwiki(),
                ] )
                ->caller( __METHOD__ )->execute();
            $success = true;
        } else {
            $success = false;
        }
 
        $dbw->endAtomic( __METHOD__ );
 
        return $success;
    }
 
    public function followRedirect() {
        return $this->getRedirectURL( $this->getRedirectTarget() );
    }
 
    public function getRedirectURL( $rt ) {
        if ( !$rt ) {
            return false;
        }
 
        if ( $rt->isExternal() ) {
            if ( $rt->isLocal() ) {
                // Offsite wikis need an HTTP redirect.
                // This can be hard to reverse and may produce loops,
                // so they may be disabled in the site configuration.
                $source = $this->mTitle->getFullURL( 'redirect=no' );
                return $rt->getFullURL( [ 'rdfrom' => $source ] );
            } else {
                // External pages without "local" bit set are not valid
                // redirect targets
                return false;
            }
        }
 
        if ( $rt->isSpecialPage() ) {
            // Gotta handle redirects to special pages differently:
            // Fill the HTTP response "Location" header and ignore the rest of the page we're on.
            // Some pages are not valid targets.
            if ( $rt->isValidRedirectTarget() ) {
                return $rt->getFullURL();
            } else {
                return false;
            }
        } elseif ( !$rt->isValidRedirectTarget() ) {
            // We somehow got a bad redirect target into the database (T278367)
            return false;
        }
 
        return $rt;
    }
 
    public function getContributors() {
        // @todo: This is expensive; cache this info somewhere.
 
        $services = MediaWikiServices::getInstance();
        $dbr = $services->getConnectionProvider()->getReplicaDatabase();
        $actorNormalization = $services->getActorNormalization();
        $userIdentityLookup = $services->getUserIdentityLookup();
 
        $user = $this->getUser()
            ? User::newFromId( $this->getUser() )
            : User::newFromName( $this->getUserText(), false );
 
        $res = $dbr->newSelectQueryBuilder()
            ->select( [
                'user_id' => 'actor_user',
                'user_name' => 'actor_name',
                'actor_id' => 'MIN(rev_actor)',
                'user_real_name' => 'MIN(user_real_name)',
                'timestamp' => 'MAX(rev_timestamp)',
            ] )
            ->from( 'revision' )
            ->join( 'actor', null, 'rev_actor = actor_id' )
            ->leftJoin( 'user', null, 'actor_user = user_id' )
            ->where( [
                'rev_page' => $this->getId(),
                // The user who made the top revision gets credited as "this page was last edited by
                // John, based on contributions by Tom, Dick and Harry", so don't include them twice.
                $dbr->expr( 'rev_actor', '!=', $actorNormalization->findActorId( $user, $dbr ) ),
                // Username hidden?
                $dbr->bitAnd( 'rev_deleted', RevisionRecord::DELETED_USER ) . ' = 0',
            ] )
            ->groupBy( [ 'actor_user', 'actor_name' ] )
            ->orderBy( 'timestamp', SelectQueryBuilder::SORT_DESC )
            ->caller( __METHOD__ )
            ->fetchResultSet();
        return new UserArrayFromResult( $res );
    }
 
    public function shouldCheckParserCache( ParserOptions $parserOptions, $oldId ) {
        // NOTE: Keep in sync with ParserOutputAccess::shouldUseCache().
        // TODO: Once ParserOutputAccess is stable, deprecated this method.
        return $this->exists()
            && ( $oldId === null || $oldId === 0 || $oldId === $this->getLatest() )
            && $this->getContentHandler()->isParserCacheSupported();
    }
 
    public function getParserOutput(
        ?ParserOptions $parserOptions = null, $oldid = null, $noCache = false
    ) {
        if ( $oldid ) {
            $revision = $this->getRevisionStore()->getRevisionByTitle( $this->getTitle(), $oldid );
 
            if ( !$revision ) {
                return false;
            }
        } else {
            $revision = $this->getRevisionRecord();
        }
 
        if ( !$parserOptions ) {
            $parserOptions = ParserOptions::newFromAnon();
        }
 
        $options = $noCache ? ParserOutputAccess::OPT_NO_CACHE : 0;
 
        $status = MediaWikiServices::getInstance()->getParserOutputAccess()->getParserOutput(
            $this, $parserOptions, $revision, $options
        );
        return $status->isOK() ? $status->getValue() : false; // convert null to false
    }
 
    public function doViewUpdates(
        Authority $performer,
        $oldid = 0,
        RevisionRecord $oldRev = null
    ) {
        if ( MediaWikiServices::getInstance()->getReadOnlyMode()->isReadOnly() ) {
            return;
        }
 
        DeferredUpdates::addCallableUpdate(
            function () use ( $performer ) {
                // In practice, these hook handlers simply debounce into a post-send
                // to do their work since none of the use cases for this hook require
                // a blocking pre-send callback.
                //
                // TODO: Move this hook to post-send.
                //
                // For now, it is unofficially possible for an extension to use
                // onPageViewUpdates to try to insert JavaScript via global $wgOut.
                // This isn't supported (the hook doesn't pass OutputPage), and
                // can't be since OutputPage may be disabled or replaced on some
                // pages that we do support page view updates for. We also run
                // this hook after HTMLFileCache, which also naturally can't
                // support modifying OutputPage. Handlers that modify the page
                // may use onBeforePageDisplay instead, which runs behind
                // HTMLFileCache and won't run on non-OutputPage responses.
                $legacyUser = MediaWikiServices::getInstance()
                    ->getUserFactory()
                    ->newFromAuthority( $performer );
                $this->getHookRunner()->onPageViewUpdates( $this, $legacyUser );
            },
            DeferredUpdates::PRESEND
        );
 
        // Update newtalk and watchlist notification status
        MediaWikiServices::getInstance()
            ->getWatchlistManager()
            ->clearTitleUserNotifications( $performer, $this, $oldid, $oldRev );
    }
 
    public function doPurge() {
        if ( !$this->getHookRunner()->onArticlePurge( $this ) ) {
            return false;
        }
 
        $this->mTitle->invalidateCache();
 
        // Clear file cache and send purge after above page_touched update was committed
        $hcu = MediaWikiServices::getInstance()->getHtmlCacheUpdater();
        $hcu->purgeTitleUrls( $this->mTitle, $hcu::PURGE_PRESEND );
 
        if ( $this->mTitle->getNamespace() === NS_MEDIAWIKI ) {
            MediaWikiServices::getInstance()->getMessageCache()
                ->updateMessageOverride( $this->mTitle, $this->getContent() );
        }
        InfoAction::invalidateCache( $this->mTitle, $this->getLatest() );
 
        return true;
    }
 
    public function insertOn( $dbw, $pageId = null ) {
        $pageIdForInsert = $pageId ? [ 'page_id' => $pageId ] : [];
        $dbw->newInsertQueryBuilder()
            ->insertInto( 'page' )
            ->ignore()
            ->row( [
                'page_namespace'    => $this->mTitle->getNamespace(),
                'page_title'        => $this->mTitle->getDBkey(),
                'page_is_redirect'  => 0, // Will set this shortly...
                'page_is_new'       => 1,
                'page_random'       => wfRandom(),
                'page_touched'      => $dbw->timestamp(),
                'page_latest'       => 0, // Fill this in shortly...
                'page_len'          => 0, // Fill this in shortly...
            ] + $pageIdForInsert )
            ->caller( __METHOD__ )->execute();
 
        if ( $dbw->affectedRows() > 0 ) {
            $newid = $pageId ? (int)$pageId : $dbw->insertId();
            $this->mId = $newid;
            $this->mTitle->resetArticleID( $newid );
 
            return $newid;
        } else {
            return false; // nothing changed
        }
    }
 
    public function updateRevisionOn(
        $dbw,
        RevisionRecord $revision,
        $lastRevision = null,
        $lastRevIsRedirect = null
    ) {
        // TODO: move into PageUpdater or PageStore
        // NOTE: when doing that, make sure cached fields get reset in doUserEditContent,
        // and in the compat stub!
 
        $revId = $revision->getId();
        Assert::parameter( $revId > 0, '$revision->getId()', 'must be > 0' );
 
        $content = $revision->getContent( SlotRecord::MAIN );
        $len = $content ? $content->getSize() : 0;
        $rt = $content ? $content->getRedirectTarget() : null;
        $isNew = $lastRevision === 0;
        $isRedirect = $rt !== null;
 
        $conditions = [ 'page_id' => $this->getId() ];
 
        if ( $lastRevision !== null ) {
            // An extra check against threads stepping on each other
            $conditions['page_latest'] = $lastRevision;
        }
 
        $model = $revision->getSlot( SlotRecord::MAIN, RevisionRecord::RAW )->getModel();
 
        $row = [ /* SET */
            'page_latest'        => $revId,
            'page_touched'       => $dbw->timestamp( $revision->getTimestamp() ),
            'page_is_new'        => $isNew ? 1 : 0,
            'page_is_redirect'   => $isRedirect ? 1 : 0,
            'page_len'           => $len,
            'page_content_model' => $model,
        ];
 
        $dbw->newUpdateQueryBuilder()
            ->update( 'page' )
            ->set( $row )
            ->where( $conditions )
            ->caller( __METHOD__ )->execute();
 
        $result = $dbw->affectedRows() > 0;
        if ( $result ) {
            $insertedRow = $this->pageData( $dbw, [ 'page_id' => $this->getId() ] );
 
            if ( !$insertedRow ) {
                throw new RuntimeException( 'Failed to load freshly inserted row' );
            }
 
            $this->mTitle->loadFromRow( $insertedRow );
            $this->updateRedirectOn( $dbw, $rt, $lastRevIsRedirect );
            $this->setLastEdit( $revision );
            $this->mRedirectTarget = $rt == null ? null : self::createRedirectTarget(
                $rt->getNamespace(), $rt->getDBkey(), $rt->getFragment(), $rt->getInterwiki() );
            $this->mPageIsRedirectField = (bool)$rt;
            $this->mIsNew = $isNew;
 
            // Update the LinkCache.
            $linkCache = MediaWikiServices::getInstance()->getLinkCache();
            $linkCache->addGoodLinkObjFromRow(
                $this->mTitle,
                $insertedRow
            );
        }
 
        return $result;
    }
 
    private function updateRedirectOn( $dbw, $redirectTitle, $lastRevIsRedirect = null ) {
        // Always update redirects (target link might have changed)
        // Update/Insert if we don't know if the last revision was a redirect or not
        // Delete if changing from redirect to non-redirect
        $isRedirect = $redirectTitle !== null;
 
        if ( !$isRedirect && $lastRevIsRedirect === false ) {
            return true;
        }
 
        if ( $isRedirect ) {
            $success = $this->insertRedirectEntry( $redirectTitle );
        } else {
            // This is not a redirect, remove row from redirect table
            $dbw->newDeleteQueryBuilder()
                ->deleteFrom( 'redirect' )
                ->where( [ 'rd_from' => $this->getId() ] )
                ->caller( __METHOD__ )->execute();
            $success = true;
        }
 
        if ( $this->getTitle()->getNamespace() === NS_FILE ) {
            MediaWikiServices::getInstance()->getRepoGroup()->getLocalRepo()
                ->invalidateImageRedirect( $this->getTitle() );
        }
 
        return $success;
    }
 
    public static function hasDifferencesOutsideMainSlot( RevisionRecord $a, RevisionRecord $b ) {
        $aSlots = $a->getSlots();
        $bSlots = $b->getSlots();
        $changedRoles = $aSlots->getRolesWithDifferentContent( $bSlots );
 
        return ( $changedRoles !== [ SlotRecord::MAIN ] && $changedRoles !== [] );
    }
 
    public function supportsSections() {
        return $this->getContentHandler()->supportsSections();
    }
 
    public function replaceSectionContent(
        $sectionId, Content $sectionContent, $sectionTitle = '', $edittime = null
    ) {
        $baseRevId = null;
        if ( $edittime && $sectionId !== 'new' ) {
            $lb = $this->getDBLoadBalancer();
            $rev = $this->getRevisionStore()->getRevisionByTimestamp( $this->mTitle, $edittime );
            // Try the primary database if this thread may have just added it.
            // The logic to fallback to the primary database if the replica is missing
            // the revision could be generalized into RevisionStore, but we don't want
            // to encourage loading of revisions by timestamp.
            if ( !$rev
                && $lb->hasReplicaServers()
                && $lb->hasOrMadeRecentPrimaryChanges()
            ) {
                $rev = $this->getRevisionStore()->getRevisionByTimestamp(
                    $this->mTitle, $edittime, IDBAccessObject::READ_LATEST );
            }
            if ( $rev ) {
                $baseRevId = $rev->getId();
            }
        }
 
        return $this->replaceSectionAtRev( $sectionId, $sectionContent, $sectionTitle, $baseRevId );
    }
 
    public function replaceSectionAtRev( $sectionId, Content $sectionContent,
        $sectionTitle = '', $baseRevId = null
    ) {
        if ( strval( $sectionId ) === '' ) {
            // Whole-page edit; let the whole text through
            $newContent = $sectionContent;
        } else {
            if ( !$this->supportsSections() ) {
                throw new BadMethodCallException( "sections not supported for content model " .
                    $this->getContentHandler()->getModelID() );
            }
 
            // T32711: always use current version when adding a new section
            if ( $baseRevId === null || $sectionId === 'new' ) {
                $oldContent = $this->getContent();
            } else {
                $revRecord = $this->getRevisionStore()->getRevisionById( $baseRevId );
                if ( !$revRecord ) {
                    wfDebug( __METHOD__ . " asked for bogus section (page: " .
                        $this->getId() . "; section: $sectionId)" );
                    return null;
                }
 
                $oldContent = $revRecord->getContent( SlotRecord::MAIN );
            }
 
            if ( !$oldContent ) {
                wfDebug( __METHOD__ . ": no page text" );
                return null;
            }
 
            $newContent = $oldContent->replaceSection( $sectionId, $sectionContent, $sectionTitle );
        }
 
        return $newContent;
    }
 
    public function checkFlags( $flags ) {
        if ( !( $flags & EDIT_NEW ) && !( $flags & EDIT_UPDATE ) ) {
            if ( $this->exists() ) {
                $flags |= EDIT_UPDATE;
            } else {
                $flags |= EDIT_NEW;
            }
        }
 
        return $flags;
    }
 
    private function getDerivedDataUpdater(
        UserIdentity $forUser = null,
        RevisionRecord $forRevision = null,
        RevisionSlotsUpdate $forUpdate = null,
        $forEdit = false
    ) {
        if ( !$forRevision && !$forUpdate ) {
            // NOTE: can't re-use an existing derivedDataUpdater if we don't know what the caller is
            // going to use it with.
            $this->derivedDataUpdater = null;
        }
 
        if ( $this->derivedDataUpdater && !$this->derivedDataUpdater->isContentPrepared() ) {
            // NOTE: can't re-use an existing derivedDataUpdater if other code that has a reference
            // to it did not yet initialize it, because we don't know what data it will be
            // initialized with.
            $this->derivedDataUpdater = null;
        }
 
        // XXX: It would be nice to have an LRU cache instead of trying to re-use a single instance.
        // However, there is no good way to construct a cache key. We'd need to check against all
        // cached instances.
 
        if ( $this->derivedDataUpdater
            && !$this->derivedDataUpdater->isReusableFor(
                $forUser,
                $forRevision,
                $forUpdate,
                $forEdit ? $this->getLatest() : null
            )
        ) {
            $this->derivedDataUpdater = null;
        }
 
        if ( !$this->derivedDataUpdater ) {
            $this->derivedDataUpdater =
                $this->getPageUpdaterFactory()->newDerivedPageDataUpdater( $this );
        }
 
        return $this->derivedDataUpdater;
    }
 
    public function newPageUpdater( $performer, RevisionSlotsUpdate $forUpdate = null ) {
        if ( $performer instanceof Authority ) {
            // TODO: Deprecate this. But better get rid of this method entirely.
            $performer = $performer->getUser();
        }
 
        $pageUpdater = $this->getPageUpdaterFactory()->newPageUpdaterForDerivedPageDataUpdater(
            $this,
            $performer,
            $this->getDerivedDataUpdater( $performer, null, $forUpdate, true )
        );
 
        return $pageUpdater;
    }
 
    public function doUserEditContent(
        Content $content,
        Authority $performer,
        $summary,
        $flags = 0,
        $originalRevId = false,
        $tags = [],
        $undidRevId = 0
    ): PageUpdateStatus {
        $useNPPatrol = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::UseNPPatrol );
        $useRCPatrol = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::UseRCPatrol );
        if ( !( $summary instanceof CommentStoreComment ) ) {
            $summary = CommentStoreComment::newUnsavedComment( trim( $summary ) );
        }
 
        // TODO: this check is here for backwards-compatibility with 1.31 behavior.
        // Checking the minoredit right should be done in the same place the 'bot' right is
        // checked for the EDIT_FORCE_BOT flag, which is currently in EditPage::attemptSave.
        if ( ( $flags & EDIT_MINOR ) && !$performer->isAllowed( 'minoredit' ) ) {
            $flags &= ~EDIT_MINOR;
        }
 
        $slotsUpdate = new RevisionSlotsUpdate();
        $slotsUpdate->modifyContent( SlotRecord::MAIN, $content );
 
        // NOTE: while doUserEditContent() executes, callbacks to getDerivedDataUpdater and
        // prepareContentForEdit will generally use the DerivedPageDataUpdater that is also
        // used by this PageUpdater. However, there is no guarantee for this.
        $updater = $this->newPageUpdater( $performer, $slotsUpdate )
                ->setContent( SlotRecord::MAIN, $content )
            ->setOriginalRevisionId( $originalRevId );
        if ( $undidRevId ) {
            $updater->markAsRevert(
                EditResult::REVERT_UNDO,
                $undidRevId,
                $originalRevId ?: null
            );
        }
 
        $needsPatrol = $useRCPatrol || ( $useNPPatrol && !$this->exists() );
 
        // TODO: this logic should not be in the storage layer, it's here for compatibility
        // with 1.31 behavior. Applying the 'autopatrol' right should be done in the same
        // place the 'bot' right is handled, which is currently in EditPage::attemptSave.
 
        if ( $needsPatrol && $performer->authorizeWrite( 'autopatrol', $this->getTitle() ) ) {
            $updater->setRcPatrolStatus( RecentChange::PRC_AUTOPATROLLED );
        }
 
        $updater->addTags( $tags );
 
        $revRec = $updater->saveRevision(
            $summary,
            $flags
        );
 
        // $revRec will be null if the edit failed, or if no new revision was created because
        // the content did not change.
        if ( $revRec ) {
            // update cached fields
            // TODO: this is currently redundant to what is done in updateRevisionOn.
            // But updateRevisionOn() should move into PageStore, and then this will be needed.
            $this->setLastEdit( $revRec );
        }
 
        return $updater->getStatus();
    }
 
    public function makeParserOptions( $context ) {
        return self::makeParserOptionsFromTitleAndModel(
            $this->getTitle(), $this->getContentModel(), $context
        );
    }
 
    public static function makeParserOptionsFromTitleAndModel(
        PageReference $pageRef, string $contentModel, $context
    ) {
        $options = ParserOptions::newCanonical( $context );
 
        $title = Title::newFromPageReference( $pageRef );
        if ( $title->isConversionTable() ) {
            // @todo ConversionTable should become a separate content model, so
            // we don't need special cases like this one, but see T313455.
            $options->disableContentConversion();
        }
 
        return $options;
    }
 
    public function prepareContentForEdit(
        Content $content,
        ?RevisionRecord $revision,
        UserIdentity $user,
        $serialFormat = null,
        $useStash = true
    ) {
        $slots = RevisionSlotsUpdate::newFromContent( [ SlotRecord::MAIN => $content ] );
        $updater = $this->getDerivedDataUpdater( $user, $revision, $slots );
 
        if ( !$updater->isUpdatePrepared() ) {
            $updater->prepareContent( $user, $slots, $useStash );
 
            if ( $revision ) {
                $updater->prepareUpdate(
                    $revision,
                    [
                        'causeAction' => 'prepare-edit',
                        'causeAgent' => $user->getName(),
                    ]
                );
            }
        }
 
        return $updater->getPreparedEdit();
    }
 
    public function doEditUpdates(
        RevisionRecord $revisionRecord,
        UserIdentity $user,
        array $options = []
    ) {
        $options += [
            'causeAction' => 'edit-page',
            'causeAgent' => $user->getName(),
        ];
 
        $updater = $this->getDerivedDataUpdater( $user, $revisionRecord );
 
        $updater->prepareUpdate( $revisionRecord, $options );
 
        $updater->doUpdates();
    }
 
    public function updateParserCache( array $options = [] ) {
        $revision = $this->getRevisionRecord();
        if ( !$revision || !$revision->getId() ) {
            LoggerFactory::getInstance( 'wikipage' )->info(
                __METHOD__ . ' called with ' . ( $revision ? 'unsaved' : 'no' ) . ' revision'
            );
            return;
        }
        $userIdentity = $revision->getUser( RevisionRecord::RAW );
 
        $updater = $this->getDerivedDataUpdater( $userIdentity, $revision );
        $updater->prepareUpdate( $revision, $options );
        $updater->doParserCacheUpdate();
    }
 
    public function doSecondaryDataUpdates( array $options = [] ) {
        $options['recursive'] ??= true;
        $revision = $this->getRevisionRecord();
        if ( !$revision || !$revision->getId() ) {
            LoggerFactory::getInstance( 'wikipage' )->info(
                __METHOD__ . ' called with ' . ( $revision ? 'unsaved' : 'no' ) . ' revision'
            );
            return;
        }
        $userIdentity = $revision->getUser( RevisionRecord::RAW );
 
        $updater = $this->getDerivedDataUpdater( $userIdentity, $revision );
        $updater->prepareUpdate( $revision, $options );
        $updater->doSecondaryDataUpdates( $options );
    }
 
    public function doUpdateRestrictions( array $limit, array $expiry,
        &$cascade, $reason, UserIdentity $user, $tags = []
    ) {
        $services = MediaWikiServices::getInstance();
        $readOnlyMode = $services->getReadOnlyMode();
        if ( $readOnlyMode->isReadOnly() ) {
            return Status::newFatal( wfMessage( 'readonlytext', $readOnlyMode->getReason() ) );
        }
 
        $this->loadPageData( 'fromdbmaster' );
        $restrictionStore = $services->getRestrictionStore();
        $restrictionStore->loadRestrictions( $this->mTitle, IDBAccessObject::READ_LATEST );
        $restrictionTypes = $restrictionStore->listApplicableRestrictionTypes( $this->mTitle );
        $id = $this->getId();
 
        if ( !$cascade ) {
            $cascade = false;
        }
 
        // Take this opportunity to purge out expired restrictions
        Title::purgeExpiredRestrictions();
 
        // @todo: Same limitations as described in ProtectionForm.php (line 37);
        // we expect a single selection, but the schema allows otherwise.
        $isProtected = false;
        $protect = false;
        $changed = false;
 
        $dbw = MediaWikiServices::getInstance()->getConnectionProvider()->getPrimaryDatabase();
 
        foreach ( $restrictionTypes as $action ) {
            if ( !isset( $expiry[$action] ) || $expiry[$action] === $dbw->getInfinity() ) {
                $expiry[$action] = 'infinity';
            }
            if ( !isset( $limit[$action] ) ) {
                $limit[$action] = '';
            } elseif ( $limit[$action] != '' ) {
                $protect = true;
            }
 
            // Get current restrictions on $action
            $current = implode( '', $restrictionStore->getRestrictions( $this->mTitle, $action ) );
            if ( $current != '' ) {
                $isProtected = true;
            }
 
            if ( $limit[$action] != $current ) {
                $changed = true;
            } elseif ( $limit[$action] != '' ) {
                // Only check expiry change if the action is actually being
                // protected, since expiry does nothing on an not-protected
                // action.
                if ( $restrictionStore->getRestrictionExpiry( $this->mTitle, $action ) != $expiry[$action] ) {
                    $changed = true;
                }
            }
        }
 
        if ( !$changed && $protect && $restrictionStore->areRestrictionsCascading( $this->mTitle ) != $cascade ) {
            $changed = true;
        }
 
        // If nothing has changed, do nothing
        if ( !$changed ) {
            return Status::newGood();
        }
 
        if ( !$protect ) { // No protection at all means unprotection
            $revCommentMsg = 'unprotectedarticle-comment';
            $logAction = 'unprotect';
        } elseif ( $isProtected ) {
            $revCommentMsg = 'modifiedarticleprotection-comment';
            $logAction = 'modify';
        } else {
            $revCommentMsg = 'protectedarticle-comment';
            $logAction = 'protect';
        }
 
        $logRelationsValues = [];
        $logRelationsField = null;
        $logParamsDetails = [];
 
        // Null revision (used for change tag insertion)
        $nullRevisionRecord = null;
 
        if ( $id ) { // Protection of existing page
            $legacyUser = $services->getUserFactory()->newFromUserIdentity( $user );
            if ( !$this->getHookRunner()->onArticleProtect( $this, $legacyUser, $limit, $reason ) ) {
                return Status::newGood();
            }
 
            // Only certain restrictions can cascade...
            $editrestriction = isset( $limit['edit'] )
                ? [ $limit['edit'] ]
                : $restrictionStore->getRestrictions( $this->mTitle, 'edit' );
            foreach ( array_keys( $editrestriction, 'sysop' ) as $key ) {
                $editrestriction[$key] = 'editprotected'; // backwards compatibility
            }
            foreach ( array_keys( $editrestriction, 'autoconfirmed' ) as $key ) {
                $editrestriction[$key] = 'editsemiprotected'; // backwards compatibility
            }
 
            $cascadingRestrictionLevels = $services->getMainConfig()
                ->get( MainConfigNames::CascadingRestrictionLevels );
 
            foreach ( array_keys( $cascadingRestrictionLevels, 'sysop' ) as $key ) {
                $cascadingRestrictionLevels[$key] = 'editprotected'; // backwards compatibility
            }
            foreach ( array_keys( $cascadingRestrictionLevels, 'autoconfirmed' ) as $key ) {
                $cascadingRestrictionLevels[$key] = 'editsemiprotected'; // backwards compatibility
            }
 
            // The schema allows multiple restrictions
            if ( !array_intersect( $editrestriction, $cascadingRestrictionLevels ) ) {
                $cascade = false;
            }
 
            // insert null revision to identify the page protection change as edit summary
            $latest = $this->getLatest();
            $nullRevisionRecord = $this->insertNullProtectionRevision(
                $revCommentMsg,
                $limit,
                $expiry,
                $cascade,
                $reason,
                $user
            );
 
            if ( $nullRevisionRecord === null ) {
                return Status::newFatal( 'no-null-revision', $this->mTitle->getPrefixedText() );
            }
 
            $logRelationsField = 'pr_id';
 
            // T214035: Avoid deadlock on MySQL.
            // Do a DELETE by primary key (pr_id) for any existing protection rows.
            // On MySQL and derivatives, unconditionally deleting by page ID (pr_page) would.
            // place a gap lock if there are no matching rows. This can deadlock when another
            // thread modifies protection settings for page IDs in the same gap.
            $existingProtectionIds = $dbw->newSelectQueryBuilder()
                ->select( 'pr_id' )
                ->from( 'page_restrictions' )
                ->where( [ 'pr_page' => $id, 'pr_type' => array_map( 'strval', array_keys( $limit ) ) ] )
                ->caller( __METHOD__ )->fetchFieldValues();
 
            if ( $existingProtectionIds ) {
                $dbw->newDeleteQueryBuilder()
                    ->deleteFrom( 'page_restrictions' )
                    ->where( [ 'pr_id' => $existingProtectionIds ] )
                    ->caller( __METHOD__ )->execute();
            }
 
            // Update restrictions table
            foreach ( $limit as $action => $restrictions ) {
                if ( $restrictions != '' ) {
                    $cascadeValue = ( $cascade && $action == 'edit' ) ? 1 : 0;
                    $dbw->newInsertQueryBuilder()
                        ->insertInto( 'page_restrictions' )
                        ->row( [
                            'pr_page' => $id,
                            'pr_type' => $action,
                            'pr_level' => $restrictions,
                            'pr_cascade' => $cascadeValue,
                            'pr_expiry' => $dbw->encodeExpiry( $expiry[$action] )
                        ] )
                        ->caller( __METHOD__ )->execute();
                    $logRelationsValues[] = $dbw->insertId();
                    $logParamsDetails[] = [
                        'type' => $action,
                        'level' => $restrictions,
                        'expiry' => $expiry[$action],
                        'cascade' => (bool)$cascadeValue,
                    ];
                }
            }
 
            $this->getHookRunner()->onRevisionFromEditComplete(
                $this, $nullRevisionRecord, $latest, $user, $tags );
 
            $this->getHookRunner()->onArticleProtectComplete( $this, $legacyUser, $limit, $reason );
        } else { // Protection of non-existing page (also known as "title protection")
            // Cascade protection is meaningless in this case
            $cascade = false;
 
            if ( $limit['create'] != '' ) {
                $commentFields = $services->getCommentStore()->insert( $dbw, 'pt_reason', $reason );
                $dbw->newReplaceQueryBuilder()
                    ->table( 'protected_titles' )
                    ->uniqueIndexFields( [ 'pt_namespace', 'pt_title' ] )
                    ->rows( [
                        'pt_namespace' => $this->mTitle->getNamespace(),
                        'pt_title' => $this->mTitle->getDBkey(),
                        'pt_create_perm' => $limit['create'],
                        'pt_timestamp' => $dbw->timestamp(),
                        'pt_expiry' => $dbw->encodeExpiry( $expiry['create'] ),
                        'pt_user' => $user->getId(),
                    ] + $commentFields )
                    ->caller( __METHOD__ )->execute();
                $logParamsDetails[] = [
                    'type' => 'create',
                    'level' => $limit['create'],
                    'expiry' => $expiry['create'],
                ];
            } else {
                $dbw->newDeleteQueryBuilder()
                    ->deleteFrom( 'protected_titles' )
                    ->where( [
                        'pt_namespace' => $this->mTitle->getNamespace(),
                        'pt_title' => $this->mTitle->getDBkey()
                    ] )
                    ->caller( __METHOD__ )->execute();
            }
        }
 
        $this->mTitle->flushRestrictions();
        InfoAction::invalidateCache( $this->mTitle );
 
        if ( $logAction == 'unprotect' ) {
            $params = [];
        } else {
            $protectDescriptionLog = $this->protectDescriptionLog( $limit, $expiry );
            $params = [
                '4::description' => $protectDescriptionLog, // parameter for IRC
                '5:bool:cascade' => $cascade,
                'details' => $logParamsDetails, // parameter for localize and api
            ];
        }
 
        // Update the protection log
        $logEntry = new ManualLogEntry( 'protect', $logAction );
        $logEntry->setTarget( $this->mTitle );
        $logEntry->setComment( $reason );
        $logEntry->setPerformer( $user );
        $logEntry->setParameters( $params );
        if ( $nullRevisionRecord !== null ) {
            $logEntry->setAssociatedRevId( $nullRevisionRecord->getId() );
        }
        $logEntry->addTags( $tags );
        if ( $logRelationsField !== null && count( $logRelationsValues ) ) {
            $logEntry->setRelations( [ $logRelationsField => $logRelationsValues ] );
        }
        $logId = $logEntry->insert();
        $logEntry->publish( $logId );
 
        return Status::newGood( $logId );
    }
 
    public function getCurrentUpdate(): PreparedUpdate {
        Assert::precondition(
            $this->derivedDataUpdater !== null,
            'There is no ongoing update tracked by this instance of WikiPage!'
        );
 
        return $this->derivedDataUpdater;
    }
 
    public function insertNullProtectionRevision(
        string $revCommentMsg,
        array $limit,
        array $expiry,
        bool $cascade,
        string $reason,
        UserIdentity $user
    ): ?RevisionRecord {
        $dbw = MediaWikiServices::getInstance()->getConnectionProvider()->getPrimaryDatabase();
 
        // Prepare a null revision to be added to the history
        $editComment = wfMessage(
            $revCommentMsg,
            $this->mTitle->getPrefixedText(),
            $user->getName()
        )->inContentLanguage()->text();
        if ( $reason ) {
            $editComment .= wfMessage( 'colon-separator' )->inContentLanguage()->text() . $reason;
        }
        $protectDescription = $this->protectDescription( $limit, $expiry );
        if ( $protectDescription ) {
            $editComment .= wfMessage( 'word-separator' )->inContentLanguage()->text();
            $editComment .= wfMessage( 'parentheses' )->params( $protectDescription )
                ->inContentLanguage()->text();
        }
        if ( $cascade ) {
            $editComment .= wfMessage( 'word-separator' )->inContentLanguage()->text();
            $editComment .= wfMessage( 'brackets' )->params(
                wfMessage( 'protect-summary-cascade' )->inContentLanguage()->text()
            )->inContentLanguage()->text();
        }
 
        $revStore = $this->getRevisionStore();
        $comment = CommentStoreComment::newUnsavedComment( $editComment );
        $nullRevRecord = $revStore->newNullRevision(
            $dbw,
            $this->getTitle(),
            $comment,
            true,
            $user
        );
 
        if ( $nullRevRecord ) {
            $inserted = $revStore->insertRevisionOn( $nullRevRecord, $dbw );
 
            // Update page record and touch page
            $oldLatest = $inserted->getParentId();
 
            $this->updateRevisionOn( $dbw, $inserted, $oldLatest );
 
            return $inserted;
        } else {
            return null;
        }
    }
 
    protected function formatExpiry( $expiry ) {
        if ( $expiry != 'infinity' ) {
            $contLang = MediaWikiServices::getInstance()->getContentLanguage();
            return wfMessage(
                'protect-expiring',
                $contLang->timeanddate( $expiry, false, false ),
                $contLang->date( $expiry, false, false ),
                $contLang->time( $expiry, false, false )
            )->inContentLanguage()->text();
        } else {
            return wfMessage( 'protect-expiry-indefinite' )
                ->inContentLanguage()->text();
        }
    }
 
    public function protectDescription( array $limit, array $expiry ) {
        $protectDescription = '';
 
        foreach ( array_filter( $limit ) as $action => $restrictions ) {
            # $action is one of $wgRestrictionTypes = [ 'create', 'edit', 'move', 'upload' ].
            # All possible message keys are listed here for easier grepping:
            # * restriction-create
            # * restriction-edit
            # * restriction-move
            # * restriction-upload
            $actionText = wfMessage( 'restriction-' . $action )->inContentLanguage()->text();
            # $restrictions is one of $wgRestrictionLevels = [ '', 'autoconfirmed', 'sysop' ],
            # with '' filtered out. All possible message keys are listed below:
            # * protect-level-autoconfirmed
            # * protect-level-sysop
            $restrictionsText = wfMessage( 'protect-level-' . $restrictions )
                ->inContentLanguage()->text();
 
            $expiryText = $this->formatExpiry( $expiry[$action] );
 
            if ( $protectDescription !== '' ) {
                $protectDescription .= wfMessage( 'word-separator' )->inContentLanguage()->text();
            }
            $protectDescription .= wfMessage( 'protect-summary-desc' )
                ->params( $actionText, $restrictionsText, $expiryText )
                ->inContentLanguage()->text();
        }
 
        return $protectDescription;
    }
 
    public function protectDescriptionLog( array $limit, array $expiry ) {
        $protectDescriptionLog = '';
 
        $dirMark = MediaWikiServices::getInstance()->getContentLanguage()->getDirMark();
        foreach ( array_filter( $limit ) as $action => $restrictions ) {
            $expiryText = $this->formatExpiry( $expiry[$action] );
            $protectDescriptionLog .=
                $dirMark .
                "[$action=$restrictions] ($expiryText)";
        }
 
        return trim( $protectDescriptionLog );
    }
 
    public function isBatchedDelete( $safetyMargin = 0 ) {
        $deleteRevisionsBatchSize = MediaWikiServices::getInstance()
            ->getMainConfig()->get( MainConfigNames::DeleteRevisionsBatchSize );
 
        $dbr = MediaWikiServices::getInstance()->getConnectionProvider()->getReplicaDatabase();
        $revCount = $this->getRevisionStore()->countRevisionsByPageId( $dbr, $this->getId() );
        $revCount += $safetyMargin;
 
        return $revCount >= $deleteRevisionsBatchSize;
    }
 
    public function doDeleteArticleReal(
        $reason, UserIdentity $deleter, $suppress = false, $u1 = null, &$error = '', $u2 = null,
        $tags = [], $logsubtype = 'delete', $immediate = false
    ) {
        $services = MediaWikiServices::getInstance();
        $deletePage = $services->getDeletePageFactory()->newDeletePage(
            $this,
            $services->getUserFactory()->newFromUserIdentity( $deleter )
        );
 
        $status = $deletePage
            ->setSuppress( $suppress )
            ->setTags( $tags ?: [] )
            ->setLogSubtype( $logsubtype )
            ->forceImmediate( $immediate )
            ->keepLegacyHookErrorsSeparate()
            ->deleteUnsafe( $reason );
        $error = $deletePage->getLegacyHookErrors();
        if ( $status->isGood() ) {
            // BC with old return format
            if ( $deletePage->deletionsWereScheduled()[DeletePage::PAGE_BASE] ) {
                $status->warning( 'delete-scheduled', wfEscapeWikiText( $this->getTitle()->getPrefixedText() ) );
            } else {
                $status->value = $deletePage->getSuccessfulDeletionsIDs()[DeletePage::PAGE_BASE];
            }
        }
        return $status;
    }
 
    public function lockAndGetLatest() {
        $dbw = MediaWikiServices::getInstance()->getConnectionProvider()->getPrimaryDatabase();
        return (int)$dbw->newSelectQueryBuilder()
            ->select( 'page_latest' )
            ->forUpdate()
            ->from( 'page' )
            ->where( [
                'page_id' => $this->getId(),
                // Typically page_id is enough, but some code might try to do
                // updates assuming the title is the same, so verify that
                'page_namespace' => $this->getTitle()->getNamespace(),
                'page_title' => $this->getTitle()->getDBkey()
            ] )
            ->caller( __METHOD__ )->fetchField();
    }
 
    public static function onArticleCreate( Title $title, $maybeIsRedirect = true ) {
        // TODO: move this into a PageEventEmitter service
 
        // Update existence markers on article/talk tabs...
        $other = $title->getOtherPage();
 
        $services = MediaWikiServices::getInstance();
        $hcu = $services->getHtmlCacheUpdater();
        $hcu->purgeTitleUrls( [ $title, $other ], $hcu::PURGE_INTENT_TXROUND_REFLECTED );
 
        $title->touchLinks();
        $title->deleteTitleProtection();
 
        $services->getLinkCache()->invalidateTitle( $title );
 
        // Invalidate caches of articles which include this page
        $jobs = [];
        $jobs[] = HTMLCacheUpdateJob::newForBacklinks(
            $title,
            'templatelinks',
            [ 'causeAction' => 'create-page' ]
        );
        // Images
        if ( $maybeIsRedirect && $title->getNamespace() === NS_FILE ) {
            // Process imagelinks when the file page was created as a redirect
            $jobs[] = HTMLCacheUpdateJob::newForBacklinks(
                $title,
                'imagelinks',
                [ 'causeAction' => 'create-page' ]
            );
        }
        $services->getJobQueueGroup()->lazyPush( $jobs );
 
        if ( $title->getNamespace() === NS_CATEGORY ) {
            // Load the Category object, which will schedule a job to create
            // the category table row if necessary. Checking a replica DB is ok
            // here, in the worst case it'll run an unnecessary recount job on
            // a category that probably doesn't have many members.
            Category::newFromTitle( $title )->getID();
        }
    }
 
    public static function onArticleDelete( Title $title ) {
        // TODO: move this into a PageEventEmitter service
 
        // Update existence markers on article/talk tabs...
        $other = $title->getOtherPage();
 
        $hcu = MediaWikiServices::getInstance()->getHtmlCacheUpdater();
        $hcu->purgeTitleUrls( [ $title, $other ], $hcu::PURGE_INTENT_TXROUND_REFLECTED );
 
        $title->touchLinks();
 
        $services = MediaWikiServices::getInstance();
        $services->getLinkCache()->invalidateTitle( $title );
 
        InfoAction::invalidateCache( $title );
 
        // Messages
        if ( $title->getNamespace() === NS_MEDIAWIKI ) {
            $services->getMessageCache()->updateMessageOverride( $title, null );
        }
 
        // Invalidate caches of articles which include this page
        $jobs = [];
        $jobs[] = HTMLCacheUpdateJob::newForBacklinks(
            $title,
            'templatelinks',
            [ 'causeAction' => 'delete-page' ]
        );
        // Images
        if ( $title->getNamespace() === NS_FILE ) {
            $jobs[] = HTMLCacheUpdateJob::newForBacklinks(
                $title,
                'imagelinks',
                [ 'causeAction' => 'delete-page' ]
            );
        }
        $services->getJobQueueGroup()->lazyPush( $jobs );
 
        // User talk pages
        if ( $title->getNamespace() === NS_USER_TALK ) {
            $user = User::newFromName( $title->getText(), false );
            if ( $user ) {
                MediaWikiServices::getInstance()
                    ->getTalkPageNotificationManager()
                    ->removeUserHasNewMessages( $user );
            }
        }
 
        // Image redirects
        $services->getRepoGroup()->getLocalRepo()->invalidateImageRedirect( $title );
 
        // Purge cross-wiki cache entities referencing this page
        self::purgeInterwikiCheckKey( $title );
    }
 
    public static function onArticleEdit(
        Title $title,
        RevisionRecord $revRecord = null,
        $slotsChanged = null,
        $maybeRedirectChanged = true
    ) {
        // TODO: move this into a PageEventEmitter service
 
        $jobs = [];
        if ( $slotsChanged === null || in_array( SlotRecord::MAIN, $slotsChanged ) ) {
            // Invalidate caches of articles which include this page.
            // Only for the main slot, because only the main slot is transcluded.
            // TODO: MCR: not true for TemplateStyles! [SlotHandler]
            $jobs[] = HTMLCacheUpdateJob::newForBacklinks(
                $title,
                'templatelinks',
                [ 'causeAction' => 'edit-page' ]
            );
        }
        // Images
        if ( $maybeRedirectChanged && $title->getNamespace() === NS_FILE ) {
            // Process imagelinks in case the redirect target has changed
            $jobs[] = HTMLCacheUpdateJob::newForBacklinks(
                $title,
                'imagelinks',
                [ 'causeAction' => 'edit-page' ]
            );
        }
        // Invalidate the caches of all pages which redirect here
        $jobs[] = HTMLCacheUpdateJob::newForBacklinks(
            $title,
            'redirect',
            [ 'causeAction' => 'edit-page' ]
        );
        $services = MediaWikiServices::getInstance();
        $services->getJobQueueGroup()->lazyPush( $jobs );
 
        $services->getLinkCache()->invalidateTitle( $title );
 
        $hcu = MediaWikiServices::getInstance()->getHtmlCacheUpdater();
        $hcu->purgeTitleUrls( $title, $hcu::PURGE_INTENT_TXROUND_REFLECTED );
 
        // Purge ?action=info cache
        $revid = $revRecord ? $revRecord->getId() : null;
        DeferredUpdates::addCallableUpdate( static function () use ( $title, $revid ) {
            InfoAction::invalidateCache( $title, $revid );
        } );
 
        // Purge cross-wiki cache entities referencing this page
        self::purgeInterwikiCheckKey( $title );
    }
 
    private static function purgeInterwikiCheckKey( Title $title ) {
        $enableScaryTranscluding = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::EnableScaryTranscluding );
 
        if ( !$enableScaryTranscluding ) {
            return; // @todo: perhaps this wiki is only used as a *source* for content?
        }
 
        DeferredUpdates::addCallableUpdate( static function () use ( $title ) {
            $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
            $cache->resetCheckKey(
                // Do not include the namespace since there can be multiple aliases to it
                // due to different namespace text definitions on different wikis. This only
                // means that some cache invalidations happen that are not strictly needed.
                $cache->makeGlobalKey(
                    'interwiki-page',
                    WikiMap::getCurrentWikiDbDomain()->getId(),
                    $title->getDBkey()
                )
            );
        } );
    }
 
    public function getCategories() {
        $services = MediaWikiServices::getInstance();
        $id = $this->getId();
        if ( $id == 0 ) {
            return $services->getTitleFactory()->newTitleArrayFromResult( new FakeResultWrapper( [] ) );
        }
 
        $dbr = $services->getDBLoadBalancer()->getMaintenanceConnectionRef( DB_REPLICA );
        $res = $dbr->newSelectQueryBuilder()
            ->select( [ 'page_title' => 'cl_to', 'page_namespace' => (string)NS_CATEGORY ] )
            ->from( 'categorylinks' )
            ->where( [ 'cl_from' => $id ] )
            ->caller( __METHOD__ )->fetchResultSet();
 
        return $services->getTitleFactory()->newTitleArrayFromResult( $res );
    }
 
    public function getHiddenCategories() {
        $result = [];
        $id = $this->getId();
 
        if ( $id == 0 ) {
            return [];
        }
 
        $dbr = MediaWikiServices::getInstance()->getConnectionProvider()->getReplicaDatabase();
        $res = $dbr->newSelectQueryBuilder()
            ->select( [ 'cl_to' ] )
            ->from( 'categorylinks' )
            ->join( 'page', null, 'page_title=cl_to' )
            ->join( 'page_props', null, 'pp_page=page_id' )
            ->where( [ 'cl_from' => $id, 'pp_propname' => 'hiddencat', 'page_namespace' => NS_CATEGORY ] )
            ->caller( __METHOD__ )->fetchResultSet();
 
        foreach ( $res as $row ) {
            $result[] = Title::makeTitle( NS_CATEGORY, $row->cl_to );
        }
 
        return $result;
    }
 
    public function getAutoDeleteReason( &$hasHistory = false ) {
        if ( func_num_args() === 1 ) {
            wfDeprecated( __METHOD__ . ': $hasHistory parameter', '1.38' );
            return $this->getContentHandler()->getAutoDeleteReason( $this->getTitle(), $hasHistory );
        }
        return $this->getContentHandler()->getAutoDeleteReason( $this->getTitle() );
    }
 
    public function updateCategoryCounts( array $added, array $deleted, $id = 0 ) {
        $id = $id ?: $this->getId();
        // Guard against data corruption T301433
        $added = array_map( 'strval', $added );
        $deleted = array_map( 'strval', $deleted );
        $type = MediaWikiServices::getInstance()->getNamespaceInfo()->
            getCategoryLinkType( $this->getTitle()->getNamespace() );
 
        $addFields = [ 'cat_pages = cat_pages + 1' ];
        $removeFields = [ 'cat_pages = cat_pages - 1' ];
        if ( $type !== 'page' ) {
            $addFields[] = "cat_{$type}s = cat_{$type}s + 1";
            $removeFields[] = "cat_{$type}s = cat_{$type}s - 1";
        }
 
        $dbw = MediaWikiServices::getInstance()->getConnectionProvider()->getPrimaryDatabase();
        $res = $dbw->newSelectQueryBuilder()
            ->select( [ 'cat_id', 'cat_title' ] )
            ->from( 'category' )
            ->where( [ 'cat_title' => array_merge( $added, $deleted ) ] )
            ->caller( __METHOD__ )
            ->fetchResultSet();
        $existingCategories = [];
        foreach ( $res as $row ) {
            $existingCategories[$row->cat_id] = $row->cat_title;
        }
        $existingAdded = array_intersect( $existingCategories, $added );
        $existingDeleted = array_intersect( $existingCategories, $deleted );
        $missingAdded = array_diff( $added, $existingAdded );
 
        // For category rows that already exist, do a plain
        // UPDATE instead of INSERT...ON DUPLICATE KEY UPDATE
        // to avoid creating gaps in the cat_id sequence.
        if ( $existingAdded ) {
            $dbw->newUpdateQueryBuilder()
                ->update( 'category' )
                ->set( $addFields )
                ->where( [ 'cat_id' => array_keys( $existingAdded ) ] )
                ->caller( __METHOD__ )->execute();
        }
 
        if ( $missingAdded ) {
            $queryBuilder = $dbw->newInsertQueryBuilder()
                ->insertInto( 'category' )
                ->onDuplicateKeyUpdate()
                ->uniqueIndexFields( [ 'cat_title' ] )
                ->set( $addFields );
            foreach ( $missingAdded as $cat ) {
                $queryBuilder->row( [
                    'cat_title'   => $cat,
                    'cat_pages'   => 1,
                    'cat_subcats' => ( $type === 'subcat' ) ? 1 : 0,
                    'cat_files'   => ( $type === 'file' ) ? 1 : 0,
                ] );
            }
            $queryBuilder->caller( __METHOD__ )->execute();
        }
 
        if ( $existingDeleted ) {
            $dbw->newUpdateQueryBuilder()
                ->update( 'category' )
                ->set( $removeFields )
                ->where( [ 'cat_id' => array_keys( $existingDeleted ) ] )
                ->caller( __METHOD__ )->execute();
        }
 
        foreach ( $added as $catName ) {
            $cat = Category::newFromName( $catName );
            $this->getHookRunner()->onCategoryAfterPageAdded( $cat, $this );
        }
 
        foreach ( $deleted as $catName ) {
            $cat = Category::newFromName( $catName );
            $this->getHookRunner()->onCategoryAfterPageRemoved( $cat, $this, $id );
            // Refresh counts on categories that should be empty now (after commit, T166757)
            DeferredUpdates::addCallableUpdate( static function () use ( $cat ) {
                $cat->refreshCountsIfEmpty();
            } );
        }
    }
 
    public function triggerOpportunisticLinksUpdate( ParserOutput $parserOutput ) {
        if ( MediaWikiServices::getInstance()->getReadOnlyMode()->isReadOnly() ) {
            return;
        }
 
        if ( !$this->getHookRunner()->onOpportunisticLinksUpdate( $this,
            $this->mTitle, $parserOutput )
        ) {
            return;
        }
 
        $config = MediaWikiServices::getInstance()->getMainConfig();
 
        $params = [
            'isOpportunistic' => true,
            'rootJobTimestamp' => $parserOutput->getCacheTime()
        ];
 
        if ( MediaWikiServices::getInstance()->getRestrictionStore()->areRestrictionsCascading( $this->mTitle ) ) {
            // In general, MediaWiki does not re-run LinkUpdate (e.g. for search index, category
            // listings, and backlinks for Whatlinkshere), unless either the page was directly
            // edited, or was re-generate following a template edit propagating to an affected
            // page. As such, during page views when there is no valid ParserCache entry,
            // we re-parse and save, but leave indexes as-is.
            //
            // We make an exception for pages that have cascading protection (perhaps for a wiki's
            // "Main Page"). When such page is re-parsed on-demand after a parser cache miss, we
            // queue a high-priority LinksUpdate job, to ensure that we really protect all
            // content that is currently transcluded onto the page. This is important, because
            // wikitext supports conditional statements based on the current time, which enables
            // transcluding of a different sub page based on which day it is, and then show that
            // information on the Main Page, without the Main Page itself being edited.
            MediaWikiServices::getInstance()->getJobQueueGroup()->lazyPush(
                RefreshLinksJob::newPrioritized( $this->mTitle, $params )
            );
        } elseif ( !$config->get( MainConfigNames::MiserMode ) &&
            $parserOutput->hasReducedExpiry()
        ) {
            // Assume the output contains "dynamic" time/random based magic words.
            // Only update pages that expired due to dynamic content and NOT due to edits
            // to referenced templates/files. When the cache expires due to dynamic content,
            // page_touched is unchanged. We want to avoid triggering redundant jobs due to
            // views of pages that were just purged via HTMLCacheUpdateJob. In that case, the
            // template/file edit already triggered recursive RefreshLinksJob jobs.
            if ( $this->getLinksTimestamp() > $this->getTouched() ) {
                // If a page is uncacheable, do not keep spamming a job for it.
                // Although it would be de-duplicated, it would still waste I/O.
                $cache = ObjectCache::getLocalClusterInstance();
                $key = $cache->makeKey( 'dynamic-linksupdate', 'last', $this->getId() );
                $ttl = max( $parserOutput->getCacheExpiry(), 3600 );
                if ( $cache->add( $key, time(), $ttl ) ) {
                    MediaWikiServices::getInstance()->getJobQueueGroup()->lazyPush(
                        RefreshLinksJob::newDynamic( $this->mTitle, $params )
                    );
                }
            }
        }
    }
 
    public function isLocal() {
        return true;
    }
 
    public function getWikiDisplayName() {
        $sitename = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::Sitename );
        return $sitename;
    }
 
    public function getSourceURL() {
        return $this->getTitle()->getCanonicalURL();
    }
 
    public function __wakeup() {
        // Make sure we re-fetch the latest state from the database.
        // In particular, the latest revision may have changed.
        // As a side-effect, this makes sure mLastRevision doesn't
        // end up being an instance of the old Revision class (see T259181),
        // especially since that class was removed entirely in 1.37.
        $this->clear();
    }
 
    public function getNamespace(): int {
        return $this->getTitle()->getNamespace();
    }
 
    public function getDBkey(): string {
        return $this->getTitle()->getDBkey();
    }
 
    public function getWikiId() {
        return $this->getTitle()->getWikiId();
    }
 
    public function canExist(): bool {
        return true;
    }
 
    public function __toString(): string {
        return $this->mTitle->__toString();
    }
 
    public function isSamePageAs( PageReference $other ): bool {
        // NOTE: keep in sync with PageReferenceValue::isSamePageAs()!
        return $this->getWikiId() === $other->getWikiId()
            && $this->getNamespace() === $other->getNamespace()
            && $this->getDBkey() === $other->getDBkey();
    }
 
    public function toPageRecord(): ExistingPageRecord {
        // TODO: replace individual member fields with a PageRecord instance that is always present
 
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
 
        Assert::precondition(
            $this->exists(),
            'This WikiPage instance does not represent an existing page: ' . $this->mTitle
        );
 
        return new PageStoreRecord(
            (object)[
                'page_id' => $this->getId(),
                'page_namespace' => $this->mTitle->getNamespace(),
                'page_title' => $this->mTitle->getDBkey(),
                'page_latest' => $this->mLatest,
                'page_is_new' => $this->mIsNew ? 1 : 0,
                'page_is_redirect' => $this->mPageIsRedirectField ? 1 : 0,
                'page_touched' => $this->getTouched(),
                'page_lang' => $this->getLanguage()
            ],
            PageIdentity::LOCAL
        );
    }
 
}