RevisionRecord.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Revision;
 
use CommentStoreComment;
use Content;
use InvalidArgumentException;
use MediaWiki\DAO\WikiAwareEntity;
use MediaWiki\DAO\WikiAwareEntityTrait;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Page\LegacyArticleIdAccess;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Permissions\Authority;
use MediaWiki\User\UserIdentity;
use Title;
use Wikimedia\NonSerializable\NonSerializableTrait;
 
abstract class RevisionRecord implements WikiAwareEntity {
    use LegacyArticleIdAccess;
    use NonSerializableTrait;
    use WikiAwareEntityTrait;
 
    // RevisionRecord deletion constants
    public const DELETED_TEXT = 1;
    public const DELETED_COMMENT = 2;
    public const DELETED_USER = 4;
    public const DELETED_RESTRICTED = 8;
    public const SUPPRESSED_USER = self::DELETED_USER | self::DELETED_RESTRICTED; // convenience
    public const SUPPRESSED_ALL = self::DELETED_TEXT | self::DELETED_COMMENT | self::DELETED_USER |
        self::DELETED_RESTRICTED; // convenience
 
    // Audience options for accessors
    public const FOR_PUBLIC = 1;
    public const FOR_THIS_USER = 2;
    public const RAW = 3;
 
    protected $wikiId = false;
    protected $mId;
    protected $mPageId;
    protected $mUser;
    protected $mMinorEdit = false;
    protected $mTimestamp;
    protected $mDeleted = 0;
    protected $mSize;
    protected $mSha1;
    protected $mParentId;
    protected $mComment;
 
    protected $mPage;
 
    protected $mSlots;
 
    public function __construct( PageIdentity $page, RevisionSlots $slots, $wikiId = self::LOCAL ) {
        $this->assertWikiIdParam( $wikiId );
 
        $this->mPage = $page;
        $this->mSlots = $slots;
        $this->wikiId = $wikiId;
        $this->mPageId = $this->getArticleId( $page );
 
        if ( $page->getWikiId() !== $wikiId ) {
            $expected = $wikiId ?: 'local';
            $actual = $page->getWikiId() ?: 'local';
            wfDeprecatedMsg(
                "Invalid cross-wiki page {$page}. Expected: {$expected}, got {$actual}",
                '1.36'
            );
        }
 
        if ( !$page->canExist() ) {
            wfDeprecatedMsg(
                "Constructing RevisionRecord for a page that can't exist: {$page}",
                '1.36'
            );
        }
    }
 
    public function hasSameContent( RevisionRecord $rec ) {
        if ( $rec === $this ) {
            return true;
        }
 
        if ( $this->getId() !== null && $this->getId() === $rec->getId() ) {
            return true;
        }
 
        // check size before hash, since size is quicker to compute
        if ( $this->getSize() !== $rec->getSize() ) {
            return false;
        }
 
        // instead of checking the hash, we could also check the content addresses of all slots.
 
        if ( $this->getSha1() === $rec->getSha1() ) {
            return true;
        }
 
        return false;
    }
 
    public function getContent( $role, $audience = self::FOR_PUBLIC, Authority $performer = null ) {
        // XXX: throwing an exception would be nicer, but would a further
        // departure from the signature of Revision::getContent(), and thus
        // more complex and error prone refactoring.
        if ( !$this->audienceCan( self::DELETED_TEXT, $audience, $performer ) ) {
            return null;
        }
 
        $content = $this->getSlot( $role, $audience, $performer )->getContent();
        return $content->copy();
    }
 
    public function getSlot( $role, $audience = self::FOR_PUBLIC, Authority $performer = null ) {
        $slot = $this->mSlots->getSlot( $role );
 
        if ( !$this->audienceCan( self::DELETED_TEXT, $audience, $performer ) ) {
            return SlotRecord::newWithSuppressedContent( $slot );
        }
 
        return $slot;
    }
 
    public function hasSlot( $role ) {
        return $this->mSlots->hasSlot( $role );
    }
 
    public function getSlotRoles() {
        return $this->mSlots->getSlotRoles();
    }
 
    public function getSlots() {
        return $this->mSlots;
    }
 
    public function getOriginalSlots() {
        return new RevisionSlots( $this->mSlots->getOriginalSlots() );
    }
 
    public function getInheritedSlots() {
        return new RevisionSlots( $this->mSlots->getInheritedSlots() );
    }
 
    public function getPrimarySlots() : RevisionSlots {
        return new RevisionSlots( $this->mSlots->getPrimarySlots() );
    }
 
    public function getId( $wikiId = self::LOCAL ) {
        $this->deprecateInvalidCrossWiki( $wikiId, '1.36' );
        return $this->mId;
    }
 
    public function getParentId( $wikiId = self::LOCAL ) {
        $this->deprecateInvalidCrossWiki( $wikiId, '1.36' );
        return $this->mParentId;
    }
 
    abstract public function getSize();
 
    abstract public function getSha1();
 
    public function getPageId( $wikiId = self::LOCAL ) {
        $this->deprecateInvalidCrossWiki( $wikiId, '1.36' );
        return $this->mPageId;
    }
 
    public function getWikiId() {
        return $this->wikiId;
    }
 
    public function getPageAsLinkTarget() {
        // TODO: Should be TitleValue::newFromPage( $this->mPage ),
        // but Title is used too much still, so let's keep propagating it
        return Title::castFromPageIdentity( $this->mPage );
    }
 
    public function getPage() {
        return $this->mPage;
    }
 
    public function getUser( $audience = self::FOR_PUBLIC, Authority $performer = null ) {
        if ( !$this->audienceCan( self::DELETED_USER, $audience, $performer ) ) {
            return null;
        } else {
            return $this->mUser;
        }
    }
 
    public function getComment( $audience = self::FOR_PUBLIC, Authority $performer = null ) {
        if ( !$this->audienceCan( self::DELETED_COMMENT, $audience, $performer ) ) {
            return null;
        } else {
            return $this->mComment;
        }
    }
 
    public function isMinor() {
        return (bool)$this->mMinorEdit;
    }
 
    public function isDeleted( $field ) {
        return ( $this->getVisibility() & $field ) == $field;
    }
 
    public function getVisibility() {
        return (int)$this->mDeleted;
    }
 
    public function getTimestamp() {
        return $this->mTimestamp;
    }
 
    public function audienceCan( $field, $audience, Authority $performer = null ) {
        if ( $audience == self::FOR_PUBLIC && $this->isDeleted( $field ) ) {
            return false;
        } elseif ( $audience == self::FOR_THIS_USER ) {
            if ( !$performer ) {
                throw new InvalidArgumentException(
                    'An Authority object must be given when checking FOR_THIS_USER audience.'
                );
            }
 
            if ( !$this->userCan( $field, $performer ) ) {
                return false;
            }
        }
 
        return true;
    }
 
    public function userCan( $field, Authority $performer ) {
        return self::userCanBitfield( $this->getVisibility(), $field, $performer, $this->mPage );
    }
 
    public static function userCanBitfield( $bitfield, $field, Authority $performer, PageIdentity $page = null ) {
        if ( $bitfield & $field ) { // aspect is deleted
            if ( $bitfield & self::DELETED_RESTRICTED ) {
                $permissions = [ 'suppressrevision', 'viewsuppressed' ];
            } elseif ( $field & self::DELETED_TEXT ) {
                $permissions = [ 'deletedtext' ];
            } else {
                $permissions = [ 'deletedhistory' ];
            }
 
            $permissionlist = implode( ', ', $permissions );
            if ( $page === null ) {
                wfDebug( "Checking for $permissionlist due to $field match on $bitfield" );
                return $performer->isAllowedAny( ...$permissions );
            } else {
                wfDebug( "Checking for $permissionlist on $page due to $field match on $bitfield" );
                foreach ( $permissions as $perm ) {
                    if ( $performer->authorizeRead( $perm, $page ) ) {
                        return true;
                    }
                }
                return false;
            }
        } else {
            return true;
        }
    }
 
    public function isReadyForInsertion() {
        // NOTE: don't check getSize() and getSha1(), since that may cause the full content to
        // be loaded in order to calculate the values. Just assume these methods will not return
        // null if mSlots is not empty.
 
        // NOTE: getId() and getPageId() may return null before a revision is saved, so don't
        // check them.
 
        return $this->getTimestamp() !== null
            && $this->getComment( self::RAW ) !== null
            && $this->getUser( self::RAW ) !== null
            && $this->mSlots->getSlotRoles() !== [];
    }
 
    public function isCurrent() {
        return false;
    }
}
 
class_alias( RevisionRecord::class, 'MediaWiki\Storage\RevisionRecord' );