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, $wikiId = false ) {
        Assert::parameterType( 'string|boolean', $wikiId, '$wikiId' );

        $this->mTitle = $title;
        $this->mSlots = $slots;
        $this->mWiki = $wikiId;

        // 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' ];
            }
            $permissionlist = implode( ', ', $permissions );
            if ( $title === null ) {
                wfDebug( "Checking for $permissionlist due to $field match on $bitfield\n" );
                return $user->isAllowedAny( ...$permissions );
            } else {
                $text = $title->getPrefixedText();
                wfDebug( "Checking for $permissionlist on $text due to $field match on $bitfield\n" );

                $permissionManager = MediaWikiServices::getInstance()->getPermissionManager();

                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' );