WikiRevision.php

Go to the documentation of this file.

<?php
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
use MediaWiki\Revision\MutableRevisionSlots;
use MediaWiki\Revision\SlotRecord;
 
class WikiRevision implements ImportableUploadRevision, ImportableOldRevision {
 
    public $title = null;
 
    public $id = 0;
 
    public $timestamp = "20010115000000";
 
    public $user_text = "";
 
    public $userObj = null;
 
    public $model = null;
 
    public $format = null;
 
    public $text = "";
 
    protected $size;
 
    public $content = null;
 
    protected $contentHandler = null;
 
    public $comment = "";
 
    private $slots;
 
    public $minor = false;
 
    public $type = "";
 
    public $action = "";
 
    public $params = "";
 
    public $fileSrc = '';
 
    public $sha1base36 = false;
 
    protected $tags = [];
 
    public $archiveName = '';
 
    protected $filename;
 
    protected $src = null;
 
    public $isTemp = false;
 
    public $fileIsTemp;
 
    private $mNoUpdates = false;
 
    private $config;
 
    public function __construct( Config $config ) {
        $this->config = $config;
        $this->slots = new MutableRevisionSlots();
    }
 
    public function setTitle( $title ) {
        if ( is_object( $title ) ) {
            $this->title = $title;
        } elseif ( $title === null ) {
            throw new MWException( "WikiRevision given a null title in import. "
                . "You may need to adjust \$wgLegalTitleChars." );
        } else {
            throw new MWException( "WikiRevision given non-object title in import." );
        }
    }
 
    public function setID( $id ) {
        $this->id = $id;
    }
 
    public function setTimestamp( $ts ) {
        # 2003-08-05T18:30:02Z
        $this->timestamp = wfTimestamp( TS_MW, $ts );
    }
 
    public function setUsername( $user ) {
        $this->user_text = $user;
    }
 
    public function setUserObj( $user ) {
        $this->userObj = $user;
    }
 
    public function setUserIP( $ip ) {
        $this->user_text = $ip;
    }
 
    public function setModel( $model ) {
        $this->model = $model;
    }
 
    public function setFormat( $format ) {
        $this->format = $format;
    }
 
    public function setText( $text ) {
        $handler = ContentHandler::getForModelID( $this->model );
        $content = $handler->unserializeContent( $text );
        $this->setContent( SlotRecord::MAIN, $content );
    }
 
    public function setContent( $role, $content ) {
        $this->slots->setContent( $role, $content );
 
        // backwards compat
        if ( $role === SlotRecord::MAIN ) {
            $this->content = $content;
            $this->model = $content->getModel();
            $this->format = $content->getDefaultFormat();
            $this->text = $content->serialize();
        }
    }
 
    public function setComment( $text ) {
        $this->comment = $text;
    }
 
    public function setMinor( $minor ) {
        $this->minor = (bool)$minor;
    }
 
    public function setSrc( $src ) {
        $this->src = $src;
    }
 
    public function setFileSrc( $src, $isTemp ) {
        $this->fileSrc = $src;
        $this->fileIsTemp = $isTemp;
        $this->isTemp = $isTemp;
    }
 
    public function setSha1Base36( $sha1base36 ) {
        $this->sha1base36 = $sha1base36;
    }
 
    public function setTags( array $tags ) {
        $this->tags = $tags;
    }
 
    public function setFilename( $filename ) {
        $this->filename = $filename;
    }
 
    public function setArchiveName( $archiveName ) {
        $this->archiveName = $archiveName;
    }
 
    public function setSize( $size ) {
        $this->size = intval( $size );
    }
 
    public function setType( $type ) {
        $this->type = $type;
    }
 
    public function setAction( $action ) {
        $this->action = $action;
    }
 
    public function setParams( $params ) {
        $this->params = $params;
    }
 
    public function setNoUpdates( $noupdates ) {
        $this->mNoUpdates = $noupdates;
    }
 
    public function getTitle() {
        return $this->title;
    }
 
    public function getID() {
        return $this->id;
    }
 
    public function getTimestamp() {
        return $this->timestamp;
    }
 
    public function getUser() {
        return $this->user_text;
    }
 
    public function getUserObj() {
        return $this->userObj;
    }
 
    public function getText() {
        return $this->text;
    }
 
    public function getContentHandler() {
        if ( $this->contentHandler === null ) {
            $this->contentHandler = MediaWikiServices::getInstance()
                ->getContentHandlerFactory()
                ->getContentHandler( $this->getModel() );
        }
 
        return $this->contentHandler;
    }
 
    public function getContent( $role = SlotRecord::MAIN ) {
        return $this->slots->getContent( $role );
    }
 
    public function getSlot( $role ) {
        return $this->slots->getSlot( $role );
    }
 
    public function getSlotRoles() {
        return $this->slots->getSlotRoles();
    }
 
    public function getModel() {
        if ( $this->model === null ) {
            $this->model = $this->getTitle()->getContentModel();
        }
 
        return $this->model;
    }
 
    public function getFormat() {
        if ( $this->format === null ) {
            $this->format = $this->getContentHandler()->getDefaultFormat();
        }
 
        return $this->format;
    }
 
    public function getComment() {
        return $this->comment;
    }
 
    public function getMinor() {
        return $this->minor;
    }
 
    public function getSrc() {
        return $this->src;
    }
 
    public function getSha1() {
        if ( $this->sha1base36 ) {
            return Wikimedia\base_convert( $this->sha1base36, 36, 16 );
        }
        return false;
    }
 
    public function getSha1Base36() {
        if ( $this->sha1base36 ) {
            return $this->sha1base36;
        }
        return false;
    }
 
    public function getTags() {
        return $this->tags;
    }
 
    public function getFileSrc() {
        return $this->fileSrc;
    }
 
    public function isTempSrc() {
        return $this->isTemp;
    }
 
    public function getFilename() {
        return $this->filename;
    }
 
    public function getArchiveName() {
        return $this->archiveName;
    }
 
    public function getSize() {
        return $this->size;
    }
 
    public function getType() {
        return $this->type;
    }
 
    public function getAction() {
        return $this->action;
    }
 
    public function getParams() {
        return $this->params;
    }
 
    public function importOldRevision() {
        if ( $this->mNoUpdates ) {
            $importer = MediaWikiServices::getInstance()->getWikiRevisionOldRevisionImporterNoUpdates();
        } else {
            $importer = MediaWikiServices::getInstance()->getWikiRevisionOldRevisionImporter();
        }
        return $importer->import( $this );
    }
 
    public function importLogItem() {
        $dbw = wfGetDB( DB_MASTER );
 
        $user = $this->getUserObj() ?: User::newFromName( $this->getUser(), false );
 
        # @todo FIXME: This will not record autoblocks
        if ( !$this->getTitle() ) {
            wfDebug( __METHOD__ . ": skipping invalid {$this->type}/{$this->action} log time, timestamp " .
                $this->timestamp );
            return false;
        }
        # Check if it exists already
        // @todo FIXME: Use original log ID (better for backups)
        $prior = $dbw->selectField( 'logging', '1',
            [ 'log_type' => $this->getType(),
                'log_action' => $this->getAction(),
                'log_timestamp' => $dbw->timestamp( $this->timestamp ),
                'log_namespace' => $this->getTitle()->getNamespace(),
                'log_title' => $this->getTitle()->getDBkey(),
                'log_params' => $this->params ],
            __METHOD__
        );
        // @todo FIXME: This could fail slightly for multiple matches :P
        if ( $prior ) {
            wfDebug( __METHOD__
                . ": skipping existing item for Log:{$this->type}/{$this->action}, timestamp "
                . $this->timestamp );
            return false;
        }
        $data = [
            'log_type' => $this->type,
            'log_action' => $this->action,
            'log_timestamp' => $dbw->timestamp( $this->timestamp ),
            'log_namespace' => $this->getTitle()->getNamespace(),
            'log_title' => $this->getTitle()->getDBkey(),
            'log_params' => $this->params
        ] + CommentStore::getStore()->insert( $dbw, 'log_comment', $this->getComment() )
            + ActorMigration::newMigration()->getInsertValues( $dbw, 'log_user', $user );
        $dbw->insert( 'logging', $data, __METHOD__ );
 
        return true;
    }
 
    public function importUpload() {
        $importer = MediaWikiServices::getInstance()->getWikiRevisionUploadImporter();
        $statusValue = $importer->import( $this );
        return $statusValue->isGood();
    }
 
    public function downloadSource() {
        $importer = new ImportableUploadRevisionImporter(
            $this->config->get( 'EnableUploads' ),
            LoggerFactory::getInstance( 'UploadRevisionImporter' )
        );
        return $importer->downloadSource( $this );
    }
 
}