RevisionRecord.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Revision;
 
use CommentStoreComment;
use Content;
use InvalidArgumentException;
use LogicException;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\MediaWikiServices;
use MediaWiki\User\UserIdentity;
use MWException;
use Title;
use User;
use Wikimedia\Assert\Assert;
 
abstract class RevisionRecord {
 
    // RevisionRecord deletion constants
    const DELETED_TEXT = 1;
    const DELETED_COMMENT = 2;
    const DELETED_USER = 4;
    const DELETED_RESTRICTED = 8;
    const SUPPRESSED_USER = self::DELETED_USER | self::DELETED_RESTRICTED; // convenience
    const SUPPRESSED_ALL = self::DELETED_TEXT | self::DELETED_COMMENT | self::DELETED_USER |
        self::DELETED_RESTRICTED; // convenience
 
    // Audience options for accessors
    const FOR_PUBLIC = 1;
    const FOR_THIS_USER = 2;
    const RAW = 3;
 
    protected $mWiki = false;
    protected $mId;
    protected $mPageId;
    protected $mUser;
    protected $mMinorEdit = false;
    protected $mTimestamp;
    protected $mDeleted = 0;
    protected $mSize;
    protected $mSha1;
    protected $mParentId;
    protected $mComment;
 
    protected $mTitle; // TODO: we only need the title for permission checks!
 
    protected $mSlots;
 
    function __construct( Title $title, RevisionSlots $slots, $dbDomain = false ) {
        Assert::parameterType( 'string|boolean', $dbDomain, '$dbDomain' );
 
        $this->mTitle = $title;
        $this->mSlots = $slots;
        $this->mWiki = $dbDomain;
 
        // XXX: this is a sensible default, but we may not have a Title object here in the future.
        $this->mPageId = $title->getArticleID();
    }
 
    public function __sleep() {
        throw new LogicException( __CLASS__ . ' is not serializable.' );
    }
 
    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, User $user = 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, $user ) ) {
            return null;
        }
 
        $content = $this->getSlot( $role, $audience, $user )->getContent();
        return $content->copy();
    }
 
    public function getSlot( $role, $audience = self::FOR_PUBLIC, User $user = null ) {
        $slot = $this->mSlots->getSlot( $role );
 
        if ( !$this->audienceCan( self::DELETED_TEXT, $audience, $user ) ) {
            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 getId() {
        return $this->mId;
    }
 
    public function getParentId() {
        return $this->mParentId;
    }
 
    abstract public function getSize();
 
    abstract public function getSha1();
 
    public function getPageId() {
        return $this->mPageId;
    }
 
    public function getWikiId() {
        return $this->mWiki;
    }
 
    public function getPageAsLinkTarget() {
        return $this->mTitle;
    }
 
    public function getUser( $audience = self::FOR_PUBLIC, User $user = null ) {
        if ( !$this->audienceCan( self::DELETED_USER, $audience, $user ) ) {
            return null;
        } else {
            return $this->mUser;
        }
    }
 
    public function getComment( $audience = self::FOR_PUBLIC, User $user = null ) {
        if ( !$this->audienceCan( self::DELETED_COMMENT, $audience, $user ) ) {
            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, User $user = null ) {
        if ( $audience == self::FOR_PUBLIC && $this->isDeleted( $field ) ) {
            return false;
        } elseif ( $audience == self::FOR_THIS_USER ) {
            if ( !$user ) {
                throw new InvalidArgumentException(
                    'A User object must be given when checking FOR_THIS_USER audience.'
                );
            }
 
            if ( !$this->userCan( $field, $user ) ) {
                return false;
            }
        }
 
        return true;
    }
 
    protected function userCan( $field, User $user ) {
        // TODO: use callback for permission checks, so we don't need to know a Title object!
        return self::userCanBitfield( $this->getVisibility(), $field, $user, $this->mTitle );
    }
 
    public static function userCanBitfield( $bitfield, $field, User $user, Title $title = 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' ];
            }
 
            // XXX: How can we avoid global scope here?
            //      Perhaps the audience check should be done in a callback.
            $permissionManager = MediaWikiServices::getInstance()->getPermissionManager();
            $permissionlist = implode( ', ', $permissions );
            if ( $title === null ) {
                wfDebug( "Checking for $permissionlist due to $field match on $bitfield\n" );
                foreach ( $permissions as $perm ) {
                    if ( $permissionManager->userHasRight( $user, $perm ) ) {
                        return true;
                    }
                }
                return false;
            } else {
                $text = $title->getPrefixedText();
                wfDebug( "Checking for $permissionlist on $text due to $field match on $bitfield\n" );
 
                foreach ( $permissions as $perm ) {
                    if ( $permissionManager->userCan( $perm, $user, $title ) ) {
                        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() !== [];
    }
 
}
 
class_alias( RevisionRecord::class, 'MediaWiki\Storage\RevisionRecord' );