WikiRevision.php

Go to the documentation of this file.

<?php
class WikiRevision {
 
    public $importer = null;
 
    public $title = null;
 
    public $id = 0;
 
    public $timestamp = "20010115000000";
 
    public $user = 0;
 
    public $user_text = "";
 
    public $userObj = null;
 
    public $model = null;
 
    public $format = null;
 
    public $text = "";
 
    protected $size;
 
    public $content = null;
 
    protected $contentHandler = null;
 
    public $comment = "";
 
    public $minor = false;
 
    public $type = "";
 
    public $action = "";
 
    public $params = "";
 
    public $fileSrc = '';
 
    public $sha1base36 = false;
 
    public $archiveName = '';
 
    protected $filename;
 
    protected $src;
 
    public $isTemp = false;
 
    public $fileIsTemp;
 
    private $mNoUpdates = false;
 
    private $config;
 
    public function __construct( Config $config ) {
        $this->config = $config;
    }
 
    public function setTitle( $title ) {
        if ( is_object( $title ) ) {
            $this->title = $title;
        } elseif ( is_null( $title ) ) {
            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 ) {
        $this->text = $text;
    }
 
    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 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 ( is_null( $this->contentHandler ) ) {
            $this->contentHandler = ContentHandler::getForModelID( $this->getModel() );
        }
 
        return $this->contentHandler;
    }
 
    public function getContent() {
        if ( is_null( $this->content ) ) {
            $handler = $this->getContentHandler();
            $this->content = $handler->unserializeContent( $this->text, $this->getFormat() );
        }
 
        return $this->content;
    }
 
    public function getModel() {
        if ( is_null( $this->model ) ) {
            $this->model = $this->getTitle()->getContentModel();
        }
 
        return $this->model;
    }
 
    public function getFormat() {
        if ( is_null( $this->format ) ) {
            $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 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() {
        $dbw = wfGetDB( DB_MASTER );
 
        # Sneak a single revision into place
        $user = $this->getUserObj() ?: User::newFromName( $this->getUser() );
        if ( $user ) {
            $userId = intval( $user->getId() );
            $userText = $user->getName();
        } else {
            $userId = 0;
            $userText = $this->getUser();
            $user = new User;
        }
 
        // avoid memory leak...?
        Title::clearCaches();
 
        $page = WikiPage::factory( $this->title );
        $page->loadPageData( 'fromdbmaster' );
        if ( !$page->exists() ) {
            // must create the page...
            $pageId = $page->insertOn( $dbw );
            $created = true;
            $oldcountable = null;
        } else {
            $pageId = $page->getId();
            $created = false;
 
            // Note: sha1 has been in XML dumps since 2012. If you have an
            // older dump, the duplicate detection here won't work.
            $prior = $dbw->selectField( 'revision', '1',
                [ 'rev_page' => $pageId,
                    'rev_timestamp' => $dbw->timestamp( $this->timestamp ),
                    'rev_sha1' => $this->sha1base36 ],
                __METHOD__
            );
            if ( $prior ) {
                // @todo FIXME: This could fail slightly for multiple matches :P
                wfDebug( __METHOD__ . ": skipping existing revision for [[" .
                    $this->title->getPrefixedText() . "]], timestamp " . $this->timestamp . "\n" );
                return false;
            }
        }
 
        if ( !$pageId ) {
            // This seems to happen if two clients simultaneously try to import the
            // same page
            wfDebug( __METHOD__ . ': got invalid $pageId when importing revision of [[' .
                $this->title->getPrefixedText() . ']], timestamp ' . $this->timestamp . "\n" );
            return false;
        }
 
        // Select previous version to make size diffs correct
        // @todo This assumes that multiple revisions of the same page are imported
        // in order from oldest to newest.
        $prevId = $dbw->selectField( 'revision', 'rev_id',
            [
                'rev_page' => $pageId,
                'rev_timestamp <= ' . $dbw->addQuotes( $dbw->timestamp( $this->timestamp ) ),
            ],
            __METHOD__,
            [ 'ORDER BY' => [
                    'rev_timestamp DESC',
                    'rev_id DESC', // timestamp is not unique per page
                ]
            ]
        );
 
        # @todo FIXME: Use original rev_id optionally (better for backups)
        # Insert the row
        $revision = new Revision( [
            'title' => $this->title,
            'page' => $pageId,
            'content_model' => $this->getModel(),
            'content_format' => $this->getFormat(),
            // XXX: just set 'content' => $this->getContent()?
            'text' => $this->getContent()->serialize( $this->getFormat() ),
            'comment' => $this->getComment(),
            'user' => $userId,
            'user_text' => $userText,
            'timestamp' => $this->timestamp,
            'minor_edit' => $this->minor,
            'parent_id' => $prevId,
            ] );
        $revision->insertOn( $dbw );
        $changed = $page->updateIfNewerOn( $dbw, $revision );
 
        if ( $changed !== false && !$this->mNoUpdates ) {
            wfDebug( __METHOD__ . ": running updates\n" );
            // countable/oldcountable stuff is handled in WikiImporter::finishImportPage
            $page->doEditUpdates(
                $revision,
                $user,
                [ 'created' => $created, 'oldcountable' => 'no-change' ]
            );
        }
 
        return true;
    }
 
    public function importLogItem() {
        $dbw = wfGetDB( DB_MASTER );
 
        $user = $this->getUserObj() ?: User::newFromName( $this->getUser() );
        if ( $user ) {
            $userId = intval( $user->getId() );
            $userText = $user->getName();
        } else {
            $userId = 0;
            $userText = $this->getUser();
        }
 
        # @todo FIXME: This will not record autoblocks
        if ( !$this->getTitle() ) {
            wfDebug( __METHOD__ . ": skipping invalid {$this->type}/{$this->action} log time, timestamp " .
                $this->timestamp . "\n" );
            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_user_text' => $this->user_text,
                '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 . "\n" );
            return false;
        }
        $data = [
            'log_type' => $this->type,
            'log_action' => $this->action,
            'log_timestamp' => $dbw->timestamp( $this->timestamp ),
            'log_user' => $userId,
            'log_user_text' => $userText,
            'log_namespace' => $this->getTitle()->getNamespace(),
            'log_title' => $this->getTitle()->getDBkey(),
            'log_params' => $this->params
        ] + CommentStore::newKey( 'log_comment' )->insert( $dbw, $this->getComment() );
        $dbw->insert( 'logging', $data, __METHOD__ );
 
        return true;
    }
 
    public function importUpload() {
        # Construct a file
        $archiveName = $this->getArchiveName();
        if ( $archiveName ) {
            wfDebug( __METHOD__ . "Importing archived file as $archiveName\n" );
            $file = OldLocalFile::newFromArchiveName( $this->getTitle(),
                RepoGroup::singleton()->getLocalRepo(), $archiveName );
        } else {
            $file = wfLocalFile( $this->getTitle() );
            $file->load( File::READ_LATEST );
            wfDebug( __METHOD__ . 'Importing new file as ' . $file->getName() . "\n" );
            if ( $file->exists() && $file->getTimestamp() > $this->getTimestamp() ) {
                $archiveName = $file->getTimestamp() . '!' . $file->getName();
                $file = OldLocalFile::newFromArchiveName( $this->getTitle(),
                    RepoGroup::singleton()->getLocalRepo(), $archiveName );
                wfDebug( __METHOD__ . "File already exists; importing as $archiveName\n" );
            }
        }
        if ( !$file ) {
            wfDebug( __METHOD__ . ': Bad file for ' . $this->getTitle() . "\n" );
            return false;
        }
 
        # Get the file source or download if necessary
        $source = $this->getFileSrc();
        $autoDeleteSource = $this->isTempSrc();
        if ( !strlen( $source ) ) {
            $source = $this->downloadSource();
            $autoDeleteSource = true;
        }
        if ( !strlen( $source ) ) {
            wfDebug( __METHOD__ . ": Could not fetch remote file.\n" );
            return false;
        }
 
        $tmpFile = new TempFSFile( $source );
        if ( $autoDeleteSource ) {
            $tmpFile->autocollect();
        }
 
        $sha1File = ltrim( sha1_file( $source ), '0' );
        $sha1 = $this->getSha1();
        if ( $sha1 && ( $sha1 !== $sha1File ) ) {
            wfDebug( __METHOD__ . ": Corrupt file $source.\n" );
            return false;
        }
 
        $user = $this->getUserObj() ?: User::newFromName( $this->getUser() );
 
        # Do the actual upload
        if ( $archiveName ) {
            $status = $file->uploadOld( $source, $archiveName,
                $this->getTimestamp(), $this->getComment(), $user );
        } else {
            $flags = 0;
            $status = $file->upload( $source, $this->getComment(), $this->getComment(),
                $flags, false, $this->getTimestamp(), $user );
        }
 
        if ( $status->isGood() ) {
            wfDebug( __METHOD__ . ": Successful\n" );
            return true;
        } else {
            wfDebug( __METHOD__ . ': failed: ' . $status->getHTML() . "\n" );
            return false;
        }
    }
 
    public function downloadSource() {
        if ( !$this->config->get( 'EnableUploads' ) ) {
            return false;
        }
 
        $tempo = tempnam( wfTempDir(), 'download' );
        $f = fopen( $tempo, 'wb' );
        if ( !$f ) {
            wfDebug( "IMPORT: couldn't write to temp file $tempo\n" );
            return false;
        }
 
        // @todo FIXME!
        $src = $this->getSrc();
        $data = Http::get( $src, [], __METHOD__ );
        if ( !$data ) {
            wfDebug( "IMPORT: couldn't fetch source $src\n" );
            fclose( $f );
            unlink( $tempo );
            return false;
        }
 
        fwrite( $f, $data );
        fclose( $f );
 
        return $tempo;
    }
 
}