PageUpdater.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Storage;
 
use AtomicSectionUpdate;
use CommentStoreComment;
use Content;
use ContentHandler;
use DeferredUpdates;
use InvalidArgumentException;
use LogicException;
use ManualLogEntry;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Content\IContentHandlerFactory;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Revision\MutableRevisionRecord;
use MediaWiki\Revision\RevisionAccessException;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Revision\SlotRoleRegistry;
use MediaWiki\User\UserEditTracker;
use MediaWiki\User\UserGroupManager;
use MediaWiki\User\UserIdentity;
use MWException;
use RecentChange;
use RuntimeException;
use Status;
use Title;
use TitleFormatter;
use User;
use Wikimedia\Assert\Assert;
use Wikimedia\Rdbms\DBConnRef;
use Wikimedia\Rdbms\DBUnexpectedError;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\ILoadBalancer;
use WikiPage;
 
class PageUpdater {
 
    public const CONSTRUCTOR_OPTIONS = [
        'ManualRevertSearchRadius',
        'UseRCPatrol',
    ];
 
    private $author;
 
    private $wikiPage;
 
    private $derivedDataUpdater;
 
    private $loadBalancer;
 
    private $revisionStore;
 
    private $slotRoleRegistry;
 
    private $contentHandlerFactory;
 
    private $hookRunner;
 
    private $hookContainer;
 
    private $userEditTracker;
 
    private $userGroupManager;
 
    private $titleFormatter;
 
    private $useAutomaticEditSummaries = true;
 
    private $rcPatrolStatus = RecentChange::PRC_UNPATROLLED;
 
    private $usePageCreationLog = true;
 
    private $tags = [];
 
    private $slotsUpdate;
 
    private $status = null;
 
    private $editResultBuilder;
 
    private $editResult = null;
 
    private $serviceOptions;
 
    private $flags = 0;
 
    private $softwareTags = [];
 
    public function __construct(
        UserIdentity $author,
        WikiPage $wikiPage,
        DerivedPageDataUpdater $derivedDataUpdater,
        ILoadBalancer $loadBalancer,
        RevisionStore $revisionStore,
        SlotRoleRegistry $slotRoleRegistry,
        IContentHandlerFactory $contentHandlerFactory,
        HookContainer $hookContainer,
        UserEditTracker $userEditTracker,
        UserGroupManager $userGroupManager,
        TitleFormatter $titleFormatter,
        ServiceOptions $serviceOptions,
        array $softwareTags
    ) {
        $serviceOptions->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->serviceOptions = $serviceOptions;
 
        $this->author = $author;
        $this->wikiPage = $wikiPage;
        $this->derivedDataUpdater = $derivedDataUpdater;
 
        $this->loadBalancer = $loadBalancer;
        $this->revisionStore = $revisionStore;
        $this->slotRoleRegistry = $slotRoleRegistry;
        $this->contentHandlerFactory = $contentHandlerFactory;
        $this->hookContainer = $hookContainer;
        $this->hookRunner = new HookRunner( $hookContainer );
        $this->userEditTracker = $userEditTracker;
        $this->userGroupManager = $userGroupManager;
        $this->titleFormatter = $titleFormatter;
 
        $this->slotsUpdate = new RevisionSlotsUpdate();
        $this->editResultBuilder = new EditResultBuilder(
            $revisionStore,
            $softwareTags,
            new ServiceOptions(
                EditResultBuilder::CONSTRUCTOR_OPTIONS,
                [
                    'ManualRevertSearchRadius' =>
                        $serviceOptions->get( 'ManualRevertSearchRadius' )
                ]
            )
        );
        $this->softwareTags = $softwareTags;
    }
 
    public function setFlags( int $flags ) {
        $this->flags |= $flags;
        return $this;
    }
 
    public function prepareUpdate( int $flags = 0 ) {
        $this->setFlags( $flags );
 
        // Load the data from the primary database if needed. Needed to check flags.
        $this->grabParentRevision();
        if ( !$this->derivedDataUpdater->isUpdatePrepared() ) {
            // Avoid statsd noise and wasted cycles check the edit stash (T136678)
            $useStashed = !( ( $this->flags & EDIT_INTERNAL ) || ( $this->flags & EDIT_FORCE_BOT ) );
            // Prepare the update. This performs PST and generates the canonical ParserOutput.
            $this->derivedDataUpdater->prepareContent(
                $this->author,
                $this->slotsUpdate,
                $useStashed
            );
        }
    }
 
    private static function toLegacyUser( UserIdentity $user ) {
        return User::newFromIdentity( $user );
    }
 
    public function setUseAutomaticEditSummaries( $useAutomaticEditSummaries ) {
        $this->useAutomaticEditSummaries = $useAutomaticEditSummaries;
        return $this;
    }
 
    public function setRcPatrolStatus( $status ) {
        $this->rcPatrolStatus = $status;
        return $this;
    }
 
    public function setUsePageCreationLog( $use ) {
        $this->usePageCreationLog = $use;
        return $this;
    }
 
    private function getWikiId() {
        return false; // TODO: get from RevisionStore!
    }
 
    private function getDBConnectionRef( $mode ) {
        return $this->loadBalancer->getConnectionRef( $mode, [], $this->getWikiId() );
    }
 
    private function getPage(): PageIdentity {
        return $this->wikiPage;
    }
 
    private function getTitle() {
        // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
        return $this->wikiPage->getTitle();
    }
 
    private function getWikiPage() {
        // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
        return $this->wikiPage;
    }
 
    public function hasEditConflict( $expectedParentRevision ) {
        $parent = $this->grabParentRevision();
        $parentId = $parent ? $parent->getId() : 0;
 
        return $parentId !== $expectedParentRevision;
    }
 
    public function grabParentRevision() {
        return $this->derivedDataUpdater->grabCurrentRevision();
    }
 
    public function setContent( $role, Content $content ) {
        $this->ensureRoleAllowed( $role );
 
        $this->slotsUpdate->modifyContent( $role, $content );
        return $this;
    }
 
    public function setSlot( SlotRecord $slot ) {
        $this->ensureRoleAllowed( $slot->getRole() );
 
        $this->slotsUpdate->modifySlot( $slot );
        return $this;
    }
 
    public function inheritSlot( SlotRecord $originalSlot ) {
        // NOTE: slots can be inherited even if the role is not "allowed" on the title.
        // NOTE: this slot is inherited from some other revision, but it's
        // a "modified" slot for the RevisionSlotsUpdate and DerivedPageDataUpdater,
        // since it's not implicitly inherited from the parent revision.
        $inheritedSlot = SlotRecord::newInherited( $originalSlot );
        $this->slotsUpdate->modifySlot( $inheritedSlot );
        return $this;
    }
 
    public function removeSlot( $role ) {
        $this->ensureRoleNotRequired( $role );
 
        $this->slotsUpdate->removeSlot( $role );
    }
 
    public function setOriginalRevisionId( $originalRevId ) {
        $this->editResultBuilder->setOriginalRevision( $originalRevId );
        return $this;
    }
 
    public function markAsRevert(
        int $revertMethod,
        int $newestRevertedRevId,
        int $revertAfterRevId = null
    ) {
        $this->editResultBuilder->markAsRevert(
            $revertMethod, $newestRevertedRevId, $revertAfterRevId
        );
        return $this;
    }
 
    public function getEditResult(): ?EditResult {
        return $this->editResult;
    }
 
    public function addTag( string $tag ) {
        $this->tags[] = trim( $tag );
        return $this;
    }
 
    public function addTags( array $tags ) {
        Assert::parameterElementType( 'string', $tags, '$tags' );
        foreach ( $tags as $tag ) {
            $this->addTag( $tag );
        }
        return $this;
    }
 
    public function addSoftwareTag( string $tag ): self {
        if ( in_array( $tag, $this->softwareTags ) ) {
            $this->addTag( $tag );
        }
        return $this;
    }
 
    public function getExplicitTags() {
        return $this->tags;
    }
 
    private function computeEffectiveTags() {
        $tags = $this->tags;
        $editResult = $this->getEditResult();
 
        foreach ( $this->slotsUpdate->getModifiedRoles() as $role ) {
            $old_content = $this->getParentContent( $role );
 
            $handler = $this->getContentHandler( $role );
            $content = $this->slotsUpdate->getModifiedSlot( $role )->getContent();
 
            // TODO: MCR: Do this for all slots. Also add tags for removing roles!
            $tag = $handler->getChangeTag( $old_content, $content, $this->flags );
            // If there is no applicable tag, null is returned, so we need to check
            if ( $tag ) {
                $tags[] = $tag;
            }
        }
 
        $tags = array_merge( $tags, $editResult->getRevertTags() );
 
        return array_unique( $tags );
    }
 
    private function getParentContent( $role ) {
        $parent = $this->grabParentRevision();
 
        if ( $parent && $parent->hasSlot( $role ) ) {
            return $parent->getContent( $role, RevisionRecord::RAW );
        }
 
        return null;
    }
 
    private function getContentHandler( $role ) {
        if ( $this->slotsUpdate->isModifiedSlot( $role ) ) {
            $slot = $this->slotsUpdate->getModifiedSlot( $role );
        } else {
            $parent = $this->grabParentRevision();
 
            if ( $parent ) {
                $slot = $parent->getSlot( $role, RevisionRecord::RAW );
            } else {
                throw new RevisionAccessException(
                    'No such slot: {role}',
                    [ 'role' => $role ]
                );
            }
        }
 
        return $this->contentHandlerFactory->getContentHandler( $slot->getModel() );
    }
 
    private function makeAutoSummary() {
        if ( !$this->useAutomaticEditSummaries || ( $this->flags & EDIT_AUTOSUMMARY ) === 0 ) {
            return CommentStoreComment::newUnsavedComment( '' );
        }
 
        // NOTE: this generates an auto-summary for SOME RANDOM changed slot!
        // TODO: combine auto-summaries for multiple slots!
        // XXX: this logic should not be in the storage layer!
        $roles = $this->slotsUpdate->getModifiedRoles();
        $role = reset( $roles );
 
        if ( $role === false ) {
            return CommentStoreComment::newUnsavedComment( '' );
        }
 
        $handler = $this->getContentHandler( $role );
        $content = $this->slotsUpdate->getModifiedSlot( $role )->getContent();
        $old_content = $this->getParentContent( $role );
        $summary = $handler->getAutosummary( $old_content, $content, $this->flags );
 
        return CommentStoreComment::newUnsavedComment( $summary );
    }
 
    public function saveRevision( CommentStoreComment $summary, int $flags = 0 ) {
        $this->setFlags( $flags );
 
        if ( $this->wasCommitted() ) {
            throw new RuntimeException(
                'saveRevision() or updateRevision() has already been called on this PageUpdater!'
            );
        }
 
        // Low-level sanity check
        if ( $this->getPage()->getDBkey() === '' ) {
            throw new RuntimeException( 'Something is trying to edit an article with an empty title' );
        }
 
        // NOTE: slots can be inherited even if the role is not "allowed" on the title.
        $status = Status::newGood();
        $this->checkAllRolesAllowed(
            $this->slotsUpdate->getModifiedRoles(),
            $status
        );
        $this->checkNoRolesRequired(
            $this->slotsUpdate->getRemovedRoles(),
            $status
        );
 
        if ( !$status->isOK() ) {
            return null;
        }
 
        // Make sure the given content is allowed in the respective slots of this page
        foreach ( $this->slotsUpdate->getModifiedRoles() as $role ) {
            $slot = $this->slotsUpdate->getModifiedSlot( $role );
            $roleHandler = $this->slotRoleRegistry->getRoleHandler( $role );
 
            if ( !$roleHandler->isAllowedModel( $slot->getModel(), $this->getPage() ) ) {
                $contentHandler = $this->contentHandlerFactory
                    ->getContentHandler( $slot->getModel() );
                $this->status = Status::newFatal( 'content-not-allowed-here',
                    ContentHandler::getLocalizedName( $contentHandler->getModelID() ),
                    $this->titleFormatter->getPrefixedText( $this->getPage() ),
                    wfMessage( $roleHandler->getNameMessageKey() )
                    // TODO: defer message lookup to caller
                );
                return null;
            }
        }
 
        // Load the data from the primary database if needed. Needed to check flags.
        // NOTE: This grabs the parent revision as the CAS token, if grabParentRevision
        // wasn't called yet. If the page is modified by another process before we are done with
        // it, this method must fail (with status 'edit-conflict')!
        // NOTE: The parent revision may be different from the edit's base revision.
        $this->prepareUpdate();
 
        // Detect whether update or creation should be performed.
        if ( !( $this->flags & EDIT_NEW ) && !( $this->flags & EDIT_UPDATE ) ) {
            $this->flags |= ( $this->derivedDataUpdater->pageExisted() ) ? EDIT_UPDATE : EDIT_NEW;
        }
 
        // Trigger pre-save hook (using provided edit summary)
        $renderedRevision = $this->derivedDataUpdater->getRenderedRevision();
        $hookStatus = Status::newGood( [] );
        $allowedByHook = $this->hookRunner->onMultiContentSave(
            $renderedRevision, $this->author, $summary, $this->flags, $hookStatus
        );
        if ( $allowedByHook && $this->hookContainer->isRegistered( 'PageContentSave' ) ) {
            // Also run the legacy hook.
            // NOTE: WikiPage should only be used for the legacy hook,
            // and only if something uses the legacy hook.
            $mainContent = $this->derivedDataUpdater->getSlots()->getContent( SlotRecord::MAIN );
 
            $legacyUser = self::toLegacyUser( $this->author );
 
            // Deprecated since 1.35.
            $allowedByHook = $this->hookRunner->onPageContentSave(
                $this->getWikiPage(), $legacyUser, $mainContent, $summary,
                $this->flags & EDIT_MINOR, null, null, $this->flags, $hookStatus
            );
        }
 
        if ( !$allowedByHook ) {
            // The hook has prevented this change from being saved.
            if ( $hookStatus->isOK() ) {
                // Hook returned false but didn't call fatal(); use generic message
                $hookStatus->fatal( 'edit-hook-aborted' );
            }
 
            $this->status = $hookStatus;
            return null;
        }
 
        // Provide autosummaries if one is not provided and autosummaries are enabled
        // XXX: $summary == null seems logical, but the empty string may actually come from the user
        // XXX: Move this logic out of the storage layer! It does not belong here! Use a callback?
        if ( $summary->text === '' && $summary->data === null ) {
            $summary = $this->makeAutoSummary();
        }
 
        // Actually create the revision and create/update the page.
        // Do NOT yet set $this->status!
        if ( $this->flags & EDIT_UPDATE ) {
            $status = $this->doModify( $summary );
        } else {
            $status = $this->doCreate( $summary );
        }
 
        // Promote user to any groups they meet the criteria for
        DeferredUpdates::addCallableUpdate( function () {
            $this->userGroupManager->addUserToAutopromoteOnceGroups( $this->author, 'onEdit' );
            // Also run 'onView' for backwards compatibility
            $this->userGroupManager->addUserToAutopromoteOnceGroups( $this->author, 'onView' );
        } );
 
        // NOTE: set $this->status only after all hooks have been called,
        // so wasCommitted doesn't return true when called indirectly from a hook handler!
        $this->status = $status;
 
        // TODO: replace bad status with Exceptions!
        return ( $this->status && $this->status->isOK() )
            ? $this->status->value['revision-record']
            : null;
    }
 
    public function updateRevision( int $revId = 0 ) {
        if ( $this->wasCommitted() ) {
            throw new RuntimeException(
                'saveRevision() or updateRevision() has already been called on this PageUpdater!'
            );
        }
 
        // Low-level sanity check
        if ( $this->getPage()->getDBkey() === '' ) {
            throw new RuntimeException( 'Something is trying to edit an article with an empty title' );
        }
 
        $status = Status::newGood();
        $this->checkAllRolesAllowed(
            $this->slotsUpdate->getModifiedRoles(),
            $status
        );
        $this->checkAllRolesDerived(
            $this->slotsUpdate->getModifiedRoles(),
            $status
        );
        $this->checkAllRolesDerived(
            $this->slotsUpdate->getRemovedRoles(),
            $status
        );
 
        if ( $revId === 0 ) {
            $revision = $this->grabParentRevision();
        } else {
            $revision = $this->revisionStore->getRevisionById( $revId, RevisionStore::READ_LATEST );
        }
        if ( $revision === null ) {
            $status->fatal( 'edit-gone-missing' );
        }
 
        if ( !$status->isOK() ) {
            $this->status = $status;
            return;
        }
 
        // Make sure the given content is allowed in the respective slots of this page
        foreach ( $this->slotsUpdate->getModifiedRoles() as $role ) {
            $slot = $this->slotsUpdate->getModifiedSlot( $role );
            $roleHandler = $this->slotRoleRegistry->getRoleHandler( $role );
 
            if ( !$roleHandler->isAllowedModel( $slot->getModel(), $this->getPage() ) ) {
                $contentHandler = $this->contentHandlerFactory
                    ->getContentHandler( $slot->getModel() );
                $this->status = Status::newFatal(
                    'content-not-allowed-here',
                    ContentHandler::getLocalizedName( $contentHandler->getModelID() ),
                    $this->titleFormatter->getPrefixedText( $this->getPage() ),
                    wfMessage( $roleHandler->getNameMessageKey() )
                // TODO: defer message lookup to caller
                );
                return;
            }
        }
 
        // XXX: do we need PST?
 
        $this->flags |= EDIT_INTERNAL;
        $this->status = $this->doUpdate( $revision );
    }
 
    public function wasCommitted() {
        return $this->status !== null;
    }
 
    public function getStatus() {
        return $this->status;
    }
 
    public function wasSuccessful() {
        return $this->status && $this->status->isOK();
    }
 
    public function isNew() {
        return $this->status && $this->status->isOK() && $this->status->value['new'];
    }
 
    public function isUnchanged() {
        return $this->status
            && $this->status->isOK()
            && $this->status->value['revision-record'] === null;
    }
 
    public function getNewRevision() {
        return ( $this->status && $this->status->isOK() )
            ? $this->status->value['revision-record']
            : null;
    }
 
    private function makeNewRevision(
        CommentStoreComment $comment,
        Status $status
    ) {
        $wikiPage = $this->getWikiPage();
        $title = $this->getTitle();
        $parent = $this->grabParentRevision();
 
        // XXX: we expect to get a MutableRevisionRecord here, but that's a bit brittle!
        // TODO: introduce something like an UnsavedRevisionFactory service instead!
        $rev = $this->derivedDataUpdater->getRevision();
        '@phan-var MutableRevisionRecord $rev';
 
        // Avoid fatal error when the Title's ID changed, T204793
        if (
            $rev->getPageId() !== null && $title->exists()
            && $rev->getPageId() !== $title->getArticleID()
        ) {
            $titlePageId = $title->getArticleID();
            $revPageId = $rev->getPageId();
            $masterPageId = $title->getArticleID( Title::READ_LATEST );
 
            if ( $revPageId === $masterPageId ) {
                wfWarn( __METHOD__ . ": Encountered stale Title object: old ID was $titlePageId, "
                    . "continuing with new ID from primary DB, $masterPageId" );
            } else {
                throw new InvalidArgumentException(
                    "Revision inherited page ID $revPageId from its parent, "
                    . "but the provided Title object belongs to page ID $masterPageId"
                );
            }
        }
 
        $rev->setPageId( $title->getArticleID() );
 
        if ( $parent ) {
            $oldid = $parent->getId();
            $rev->setParentId( $oldid );
        } else {
            $oldid = 0;
        }
 
        $rev->setComment( $comment );
        $rev->setUser( $this->author );
        $rev->setMinorEdit( ( $this->flags & EDIT_MINOR ) > 0 );
 
        foreach ( $rev->getSlots()->getSlots() as $slot ) {
            $content = $slot->getContent();
 
            // XXX: We may push this up to the "edit controller" level, see T192777.
            // XXX: prepareSave() and isValid() could live in SlotRoleHandler
            // XXX: PrepareSave should not take a WikiPage!
            $legacyUser = self::toLegacyUser( $this->author );
            $prepStatus = $content->prepareSave( $wikiPage, $this->flags, $oldid, $legacyUser );
 
            // TODO: MCR: record which problem arose in which slot.
            $status->merge( $prepStatus );
        }
 
        $this->checkAllRequiredRoles(
            $rev->getSlotRoles(),
            $status
        );
 
        return $rev;
    }
 
    private function buildEditResult( RevisionRecord $revision, bool $isNew ) {
        $this->editResultBuilder->setRevisionRecord( $revision );
        $this->editResultBuilder->setIsNew( $isNew );
        $this->editResult = $this->editResultBuilder->buildEditResult();
    }
 
    private function doUpdate( RevisionRecord $revision ): Status {
        $currentRevision = $this->grabParentRevision();
        if ( !$currentRevision ) {
            // Article gone missing
            return Status::newFatal( 'edit-gone-missing' );
        }
 
        $dbw = $this->getDBConnectionRef( DB_PRIMARY );
        $dbw->startAtomic( __METHOD__ );
 
        $slots = $this->revisionStore->updateslotsOn( $revision, $this->slotsUpdate, $dbw );
 
        $dbw->endAtomic( __METHOD__ );
 
        // Return the slots and revision to the caller
        $newRevisionRecord = MutableRevisionRecord::newUpdatedRevisionRecord( $revision, $slots );
        $status = Status::newGood( [
            'revision-record' => $newRevisionRecord,
            'slots' => $slots,
        ] );
 
        $isCurrent = $revision->getId( $this->getWikiId() ) ===
            $currentRevision->getId( $this->getWikiId() );
 
        if ( $isCurrent ) {
            // Update page_touched
            $this->getTitle()->invalidateCache( $newRevisionRecord->getTimestamp() );
 
            $this->buildEditResult( $newRevisionRecord, false );
 
            // Do secondary updates once the main changes have been committed...
            $wikiPage = $this->getWikiPage(); // TODO: use for legacy hooks only!
            DeferredUpdates::addUpdate(
                $this->getAtomicSectionUpdate(
                    $dbw,
                    $wikiPage,
                    $newRevisionRecord,
                    $revision->getComment(),
                    [ 'changed' => false, ]
                ),
                DeferredUpdates::PRESEND
            );
        }
 
        return $status;
    }
 
    private function doModify( CommentStoreComment $summary ) {
        $wikiPage = $this->getWikiPage(); // TODO: use for legacy hooks only!
 
        // Update article, but only if changed.
        $status = Status::newGood(
            [ 'new' => false, 'revision-record' => null ]
        );
 
        $oldRev = $this->grabParentRevision();
        $oldid = $oldRev ? $oldRev->getId() : 0;
 
        if ( !$oldRev ) {
            // Article gone missing
            return $status->fatal( 'edit-gone-missing' );
        }
 
        $newRevisionRecord = $this->makeNewRevision(
            $summary,
            $status
        );
 
        if ( !$status->isOK() ) {
            return $status;
        }
 
        $now = $newRevisionRecord->getTimestamp();
 
        // XXX: we may want a flag that allows a null revision to be forced!
        $changed = $this->derivedDataUpdater->isChange();
 
        // We build the EditResult before the $change if/else branch in order to pass
        // the correct $newRevisionRecord to EditResultBuilder. In case this is a null
        // edit, $newRevisionRecord will be later overridden to its parent revision, which
        // would confuse EditResultBuilder.
        if ( !$changed ) {
            // This is a null edit, ensure original revision ID is set properly
            $this->editResultBuilder->setOriginalRevision( $oldRev );
        }
        $this->buildEditResult( $newRevisionRecord, false );
 
        $dbw = $this->getDBConnectionRef( DB_PRIMARY );
 
        if ( $changed ) {
            $dbw->startAtomic( __METHOD__ );
 
            // Get the latest page_latest value while locking it.
            // Do a CAS style check to see if it's the same as when this method
            // started. If it changed then bail out before touching the DB.
            $latestNow = $wikiPage->lockAndGetLatest(); // TODO: move to storage service, pass DB
            if ( $latestNow != $oldid ) {
                // We don't need to roll back, since we did not modify the database yet.
                // XXX: Or do we want to rollback, any transaction started by calling
                // code will fail? If we want that, we should probably throw an exception.
                $dbw->endAtomic( __METHOD__ );
 
                // Page updated or deleted in the mean time
                return $status->fatal( 'edit-conflict' );
            }
 
            // At this point we are now comitted to returning an OK
            // status unless some DB query error or other exception comes up.
            // This way callers don't have to call rollback() if $status is bad
            // unless they actually try to catch exceptions (which is rare).
 
            // Save revision content and meta-data
            $newRevisionRecord = $this->revisionStore->insertRevisionOn( $newRevisionRecord, $dbw );
 
            // Update page_latest and friends to reflect the new revision
            // TODO: move to storage service
            $wasRedirect = $this->derivedDataUpdater->wasRedirect();
            if ( !$wikiPage->updateRevisionOn( $dbw, $newRevisionRecord, null, $wasRedirect ) ) {
                throw new PageUpdateException( "Failed to update page row to use new revision." );
            }
 
            $editResult = $this->getEditResult();
            $tags = $this->computeEffectiveTags();
            $this->hookRunner->onRevisionFromEditComplete(
                $wikiPage,
                $newRevisionRecord,
                $editResult->getOriginalRevisionId(),
                $this->author,
                $tags
            );
 
            // Update recentchanges
            if ( !( $this->flags & EDIT_SUPPRESS_RC ) ) {
                // Add RC row to the DB
                RecentChange::notifyEdit(
                    $now,
                    $this->getPage(),
                    $newRevisionRecord->isMinor(),
                    $this->author,
                    $summary->text, // TODO: pass object when that becomes possible
                    $oldid,
                    $newRevisionRecord->getTimestamp(),
                    ( $this->flags & EDIT_FORCE_BOT ) > 0,
                    '',
                    $oldRev->getSize(),
                    $newRevisionRecord->getSize(),
                    $newRevisionRecord->getId(),
                    $this->rcPatrolStatus,
                    $tags,
                    $editResult
                );
            }
 
            $this->userEditTracker->incrementUserEditCount( $this->author );
 
            $dbw->endAtomic( __METHOD__ );
 
            // Return the new revision to the caller
            $status->value['revision-record'] = $newRevisionRecord;
        } else {
            // T34948: revision ID must be set to page {{REVISIONID}} and
            // related variables correctly. Likewise for {{REVISIONUSER}} (T135261).
            // Since we don't insert a new revision into the database, the least
            // error-prone way is to reuse given old revision.
            $newRevisionRecord = $oldRev;
 
            $status->warning( 'edit-no-change' );
            // Update page_touched as updateRevisionOn() was not called.
            // Other cache updates are managed in WikiPage::onArticleEdit()
            // via WikiPage::doEditUpdates().
            $this->getTitle()->invalidateCache( $now );
        }
 
        // Do secondary updates once the main changes have been committed...
        // NOTE: the updates have to be processed before sending the response to the client
        // (DeferredUpdates::PRESEND), otherwise the client may already be following the
        // HTTP redirect to the standard view before derived data has been created - most
        // importantly, before the parser cache has been updated. This would cause the
        // content to be parsed a second time, or may cause stale content to be shown.
        DeferredUpdates::addUpdate(
            $this->getAtomicSectionUpdate(
                $dbw,
                $wikiPage,
                $newRevisionRecord,
                $summary,
                [ 'changed' => $changed, ]
            ),
            DeferredUpdates::PRESEND
        );
 
        return $status;
    }
 
    private function doCreate( CommentStoreComment $summary ) {
        $wikiPage = $this->getWikiPage(); // TODO: use for legacy hooks only!
 
        if ( !$this->derivedDataUpdater->getSlots()->hasSlot( SlotRecord::MAIN ) ) {
            throw new PageUpdateException( 'Must provide a main slot when creating a page!' );
        }
 
        $status = Status::newGood(
            [ 'new' => true, 'revision-record' => null ]
        );
 
        $newRevisionRecord = $this->makeNewRevision(
            $summary,
            $status
        );
 
        if ( !$status->isOK() ) {
            return $status;
        }
 
        $this->buildEditResult( $newRevisionRecord, true );
        $now = $newRevisionRecord->getTimestamp();
 
        $dbw = $this->getDBConnectionRef( DB_PRIMARY );
        $dbw->startAtomic( __METHOD__ );
 
        // Add the page record unless one already exists for the title
        // TODO: move to storage service
        $newid = $wikiPage->insertOn( $dbw );
        if ( $newid === false ) {
            $dbw->endAtomic( __METHOD__ );
            return $status->fatal( 'edit-already-exists' );
        }
 
        // At this point we are now comitted to returning an OK
        // status unless some DB query error or other exception comes up.
        // This way callers don't have to call rollback() if $status is bad
        // unless they actually try to catch exceptions (which is rare).
        $newRevisionRecord->setPageId( $newid );
 
        // Save the revision text...
        $newRevisionRecord = $this->revisionStore->insertRevisionOn( $newRevisionRecord, $dbw );
 
        // Update the page record with revision data
        // TODO: move to storage service
        if ( !$wikiPage->updateRevisionOn( $dbw, $newRevisionRecord, 0 ) ) {
            throw new PageUpdateException( "Failed to update page row to use new revision." );
        }
 
        $tags = $this->computeEffectiveTags();
        $this->hookRunner->onRevisionFromEditComplete(
            $wikiPage, $newRevisionRecord, false, $this->author, $tags
        );
 
        // Update recentchanges
        if ( !( $this->flags & EDIT_SUPPRESS_RC ) ) {
            // Add RC row to the DB
            RecentChange::notifyNew(
                $now,
                $this->getPage(),
                $newRevisionRecord->isMinor(),
                $this->author,
                $summary->text, // TODO: pass object when that becomes possible
                ( $this->flags & EDIT_FORCE_BOT ) > 0,
                '',
                $newRevisionRecord->getSize(),
                $newRevisionRecord->getId(),
                $this->rcPatrolStatus,
                $tags
            );
        }
 
        $this->userEditTracker->incrementUserEditCount( $this->author );
 
        if ( $this->usePageCreationLog ) {
            // Log the page creation
            // @TODO: Do we want a 'recreate' action?
            $logEntry = new ManualLogEntry( 'create', 'create' );
            $logEntry->setPerformer( $this->author );
            $logEntry->setTarget( $this->getPage() );
            $logEntry->setComment( $summary->text );
            $logEntry->setTimestamp( $now );
            $logEntry->setAssociatedRevId( $newRevisionRecord->getId() );
            $logEntry->insert();
            // Note that we don't publish page creation events to recentchanges
            // (i.e. $logEntry->publish()) since this would create duplicate entries,
            // one for the edit and one for the page creation.
        }
 
        $dbw->endAtomic( __METHOD__ );
 
        // Return the new revision to the caller
        $status->value['revision-record'] = $newRevisionRecord;
 
        // Do secondary updates once the main changes have been committed...
        DeferredUpdates::addUpdate(
            $this->getAtomicSectionUpdate(
                $dbw,
                $wikiPage,
                $newRevisionRecord,
                $summary,
                [ 'created' => true ]
            ),
            DeferredUpdates::PRESEND
        );
 
        return $status;
    }
 
    private function getAtomicSectionUpdate(
        IDatabase $dbw,
        WikiPage $wikiPage,
        RevisionRecord $newRevisionRecord,
        CommentStoreComment $summary,
        array $hints = []
    ) {
        return new AtomicSectionUpdate(
            $dbw,
            __METHOD__,
            function () use (
                $wikiPage, $newRevisionRecord,
                $summary, $hints
            ) {
                // set debug data
                $hints['causeAction'] = 'edit-page';
                $hints['causeAgent'] = $this->author->getName();
 
                $editResult = $this->getEditResult();
                $hints['editResult'] = $editResult;
 
                if ( $editResult->isRevert() ) {
                    // Should the reverted tag update be scheduled right away?
                    // The revert is approved if either patrolling is disabled or the
                    // edit is patrolled or autopatrolled.
                    $approved = !$this->serviceOptions->get( 'UseRCPatrol' ) ||
                        $this->rcPatrolStatus === RecentChange::PRC_PATROLLED ||
                        $this->rcPatrolStatus === RecentChange::PRC_AUTOPATROLLED;
 
                    // Allow extensions to override the patrolling subsystem.
                    $this->hookRunner->onBeforeRevertedTagUpdate(
                        $wikiPage,
                        $this->author,
                        $summary,
                        $this->flags,
                        $newRevisionRecord,
                        $editResult,
                        $approved
                    );
                    $hints['approved'] = $approved;
                }
 
                // Update links tables, site stats, etc.
                $this->derivedDataUpdater->prepareUpdate( $newRevisionRecord, $hints );
                $this->derivedDataUpdater->doUpdates();
 
                $created = $hints['created'] ?? false;
                $this->flags |= ( $created ? EDIT_NEW : EDIT_UPDATE );
 
                // PageSaveComplete replaced old PageContentInsertComplete and
                // PageContentSaveComplete hooks since 1.35
                $this->hookRunner->onPageSaveComplete(
                    $wikiPage,
                    $this->author,
                    $summary->text,
                    $this->flags,
                    $newRevisionRecord,
                    $editResult
                );
            }
        );
    }
 
    private function getRequiredSlotRoles() {
        return $this->slotRoleRegistry->getRequiredRoles( $this->getPage() );
    }
 
    private function getAllowedSlotRoles() {
        return $this->slotRoleRegistry->getAllowedRoles( $this->getPage() );
    }
 
    private function ensureRoleAllowed( $role ) {
        $allowedRoles = $this->getAllowedSlotRoles();
        if ( !in_array( $role, $allowedRoles ) ) {
            throw new PageUpdateException( "Slot role `$role` is not allowed." );
        }
    }
 
    private function ensureRoleNotRequired( $role ) {
        $requiredRoles = $this->getRequiredSlotRoles();
        if ( in_array( $role, $requiredRoles ) ) {
            throw new PageUpdateException( "Slot role `$role` is required." );
        }
    }
 
    private function checkAllRolesAllowed( array $roles, Status $status ) {
        $allowedRoles = $this->getAllowedSlotRoles();
 
        $forbidden = array_diff( $roles, $allowedRoles );
        if ( !empty( $forbidden ) ) {
            $status->error(
                'edit-slots-cannot-add',
                count( $forbidden ),
                implode( ', ', $forbidden )
            );
        }
    }
 
    private function checkAllRolesDerived( array $roles, Status $status ) {
        $notDerived = array_filter(
            $roles,
            function ( $role ) {
                return !$this->slotRoleRegistry->getRoleHandler( $role )->isDerived();
            }
        );
        if ( $notDerived ) {
            $status->error(
                'edit-slots-not-derived',
                count( $notDerived ),
                implode( ', ', $notDerived )
            );
        }
    }
 
    private function checkNoRolesRequired( array $roles, Status $status ) {
        $requiredRoles = $this->getRequiredSlotRoles();
 
        $needed = array_diff( $roles, $requiredRoles );
        if ( !empty( $needed ) ) {
            $status->error(
                'edit-slots-cannot-remove',
                count( $needed ),
                implode( ', ', $needed )
            );
        }
    }
 
    private function checkAllRequiredRoles( array $roles, Status $status ) {
        $requiredRoles = $this->getRequiredSlotRoles();
 
        $missing = array_diff( $requiredRoles, $roles );
        if ( !empty( $missing ) ) {
            $status->error(
                'edit-slots-missing',
                count( $missing ),
                implode( ', ', $missing )
            );
        }
    }
 
}