EditResultBuilder.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Storage;
 
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\RevisionStoreRecord;
use Wikimedia\Rdbms\ILoadBalancer;
 
class EditResultBuilder {
 
    private const REVERT_METHOD_TO_CHANGE_TAG = [
        EditResult::REVERT_UNDO => 'mw-undo',
        EditResult::REVERT_ROLLBACK => 'mw-rollback',
        EditResult::REVERT_MANUAL => 'mw-manual-revert'
    ];
 
    private $revisionRecord = null;
 
    private $isNew = false;
 
    private $originalRevisionId = false;
 
    private $originalRevision = null;
 
    private $revertMethod = null;
 
    private $newestRevertedRevId = null;
 
    private $oldestRevertedRevId = null;
 
    private $revisionStore;
 
    private $softwareTags;
 
    private $loadBalancer;
 
    private $options;
 
    public function __construct(
        RevisionStore $revisionStore,
        array $softwareTags,
        ILoadBalancer $loadBalancer,
        ServiceOptions $options
    ) {
        $this->revisionStore = $revisionStore;
        $this->softwareTags = $softwareTags;
        $this->loadBalancer = $loadBalancer;
        $this->options = $options;
    }
 
    public function buildEditResult() : EditResult {
        if ( $this->revisionRecord === null ) {
            throw new PageUpdateException(
                'Revision was not set prior to building an EditResult'
            );
        }
 
        // do a last-minute check if this was a manual revert
        $this->detectManualRevert();
 
        return new EditResult(
            $this->isNew,
            $this->originalRevisionId,
            $this->revertMethod,
            $this->oldestRevertedRevId,
            $this->newestRevertedRevId,
            $this->isExactRevert(),
            $this->isNullEdit(),
            $this->getRevertTags()
        );
    }
 
    public function setRevisionRecord( RevisionRecord $revisionRecord ) {
        $this->revisionRecord = $revisionRecord;
    }
 
    public function setIsNew( bool $isNew ) {
        $this->isNew = $isNew;
    }
 
    public function markAsRevert(
        int $revertMethod,
        int $oldestRevertedRevId,
        int $newestRevertedRevId = 0
    ) {
        if ( $oldestRevertedRevId === 0 ) {
            return;
        }
        if ( $newestRevertedRevId === 0 ) {
            $newestRevertedRevId = $oldestRevertedRevId;
        }
 
        $this->revertMethod = $revertMethod;
        $this->oldestRevertedRevId = $oldestRevertedRevId;
        $this->newestRevertedRevId = $newestRevertedRevId;
    }
 
    public function setOriginalRevisionId( $originalRevId ) {
        $this->originalRevisionId = $originalRevId;
    }
 
    private function detectManualRevert() {
        $searchRadius = $this->options->get( 'ManualRevertSearchRadius' );
        if ( !$searchRadius ||
            // we already marked this as a revert
            $this->revertMethod !== null ||
            // it's a null edit, nothing was reverted
            $this->isNullEdit() ||
            // we wouldn't be able to figure out what was the newest reverted edit
            // this also discards new pages
            !$this->revisionRecord->getParentId()
        ) {
            return;
        }
 
        $revertedToRev = $this->findIdenticalRevision( $searchRadius );
        if ( !$revertedToRev ) {
            return;
        }
        $oldestReverted = $this->revisionStore->getNextRevision(
            $revertedToRev,
            RevisionStore::READ_LATEST
        );
        if ( !$oldestReverted ) {
            return;
        }
 
        $this->setOriginalRevisionId( $revertedToRev->getId() );
        $this->markAsRevert(
            EditResult::REVERT_MANUAL,
            $oldestReverted->getId(),
            $this->revisionRecord->getParentId()
        );
    }
 
    private function findIdenticalRevision( int $searchRadius ) : ?RevisionStoreRecord {
        // We use master just in case we encounter replication lag.
        // This is mostly for cases where a revert is applied rapidly after someone saves
        // the previous edit.
        $db = $this->loadBalancer->getConnection( DB_MASTER );
        $revQuery = $this->revisionStore->getQueryInfo();
        $subquery = $db->buildSelectSubquery(
            $revQuery['tables'],
            $revQuery['fields'],
            [ 'rev_page' => $this->revisionRecord->getPageId() ],
            __METHOD__,
            [
                'ORDER BY' => [
                    'rev_timestamp DESC',
                    // for cases where there are multiple revs with same timestamp
                    'rev_id DESC'
                ],
                'LIMIT' => $searchRadius,
                // skip the most recent edit, we can't revert to it anyway
                'OFFSET' => 1
            ],
            $revQuery['joins']
        );
 
        // selectRow effectively uses LIMIT 1 clause, returning only the first result
        $revisionRow = $db->selectRow(
            [ 'recent_revs' => $subquery ],
            '*',
            [ 'rev_sha1' => $this->revisionRecord->getSha1() ],
            __METHOD__
        );
 
        return $revisionRow ?
            $this->revisionStore->newRevisionFromRow( $revisionRow )
            : null;
    }
 
    private function getOriginalRevision(
        int $flags = RevisionStore::READ_NORMAL
    ) : ?RevisionRecord {
        if ( $this->originalRevision ) {
            return $this->originalRevision;
        }
        if ( $this->originalRevisionId === false ) {
            return null;
        }
 
        $this->originalRevision = $this->revisionStore->getRevisionById(
            $this->originalRevisionId,
            $flags
        );
        return $this->originalRevision;
    }
 
    private function isExactRevert() : bool {
        if ( $this->isNew || $this->oldestRevertedRevId === null ) {
            return false;
        }
 
        if ( $this->getOriginalRevision() === null ) {
            // we can't find the original revision for some reason, better return false
            return false;
        }
 
        return $this->revisionRecord->hasSameContent( $this->getOriginalRevision() );
    }
 
    private function isNullEdit() : bool {
        if ( $this->isNew ) {
            return false;
        }
 
        return $this->getOriginalRevision() &&
            $this->originalRevisionId === $this->revisionRecord->getParentId();
    }
 
    private function getRevertTags() : array {
        if ( isset( self::REVERT_METHOD_TO_CHANGE_TAG[$this->revertMethod] ) ) {
            $revertTag = self::REVERT_METHOD_TO_CHANGE_TAG[$this->revertMethod];
            if ( in_array( $revertTag, $this->softwareTags ) ) {
                return [ $revertTag ];
            }
        }
        return [];
    }
}