ArchivedFile.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
use MediaWiki\Permissions\Authority;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\User\UserIdentity;
 
class ArchivedFile {
 
    // Audience options for ::getDescription() and ::getUploader()
    public const FOR_PUBLIC = 1;
    public const FOR_THIS_USER = 2;
    public const RAW = 3;
 
    private $id;
 
    private $name;
 
    private $group;
 
    private $key;
 
    private $size;
 
    private $bits;
 
    private $width;
 
    private $height;
 
    private $metadata;
 
    private $mime;
 
    private $media_type;
 
    private $description;
 
    private $user;
 
    private $timestamp;
 
    private $dataLoaded;
 
    private $deleted;
 
    private $sha1;
 
    private $pageCount;
 
    private $archive_name;
 
    protected $handler;
 
    protected $title; # image title
 
    protected $exists;
 
    public function __construct( $title, $id = 0, $key = '', $sha1 = '' ) {
        $this->id = -1;
        $this->title = false;
        $this->name = false;
        $this->group = 'deleted'; // needed for direct use of constructor
        $this->key = '';
        $this->size = 0;
        $this->bits = 0;
        $this->width = 0;
        $this->height = 0;
        $this->metadata = '';
        $this->mime = "unknown/unknown";
        $this->media_type = '';
        $this->description = '';
        $this->user = null;
        $this->timestamp = null;
        $this->deleted = 0;
        $this->dataLoaded = false;
        $this->exists = false;
        $this->sha1 = '';
 
        if ( $title instanceof Title ) {
            $this->title = File::normalizeTitle( $title, 'exception' );
            $this->name = $title->getDBkey();
        }
 
        if ( $id ) {
            $this->id = $id;
        }
 
        if ( $key ) {
            $this->key = $key;
        }
 
        if ( $sha1 ) {
            $this->sha1 = $sha1;
        }
 
        if ( !$id && !$key && !( $title instanceof Title ) && !$sha1 ) {
            throw new MWException( "No specifications provided to ArchivedFile constructor." );
        }
    }
 
    public function load() {
        if ( $this->dataLoaded ) {
            return true;
        }
        $conds = [];
 
        if ( $this->id > 0 ) {
            $conds['fa_id'] = $this->id;
        }
        if ( $this->key ) {
            $conds['fa_storage_group'] = $this->group;
            $conds['fa_storage_key'] = $this->key;
        }
        if ( $this->title ) {
            $conds['fa_name'] = $this->title->getDBkey();
        }
        if ( $this->sha1 ) {
            $conds['fa_sha1'] = $this->sha1;
        }
 
        if ( $conds === [] ) {
            throw new MWException( "No specific information for retrieving archived file" );
        }
 
        if ( !$this->title || $this->title->getNamespace() === NS_FILE ) {
            $this->dataLoaded = true; // set it here, to have also true on miss
            $dbr = wfGetDB( DB_REPLICA );
            $fileQuery = self::getQueryInfo();
            $row = $dbr->selectRow(
                $fileQuery['tables'],
                $fileQuery['fields'],
                $conds,
                __METHOD__,
                [ 'ORDER BY' => 'fa_timestamp DESC' ],
                $fileQuery['joins']
            );
            if ( !$row ) {
                // this revision does not exist?
                return null;
            }
 
            // initialize fields for filestore image object
            $this->loadFromRow( $row );
        } else {
            throw new MWException( 'This title does not correspond to an image page.' );
        }
        $this->exists = true;
 
        return true;
    }
 
    public static function newFromRow( $row ) {
        $file = new ArchivedFile( Title::makeTitle( NS_FILE, $row->fa_name ) );
        $file->loadFromRow( $row );
 
        return $file;
    }
 
    public static function getQueryInfo() {
        $commentQuery = MediaWikiServices::getInstance()->getCommentStore()->getJoin( 'fa_description' );
        return [
            'tables' => [
                'filearchive',
                'filearchive_actor' => 'actor'
            ] + $commentQuery['tables'],
            'fields' => [
                'fa_id',
                'fa_name',
                'fa_archive_name',
                'fa_storage_key',
                'fa_storage_group',
                'fa_size',
                'fa_bits',
                'fa_width',
                'fa_height',
                'fa_metadata',
                'fa_media_type',
                'fa_major_mime',
                'fa_minor_mime',
                'fa_timestamp',
                'fa_deleted',
                'fa_deleted_timestamp', /* Used by LocalFileRestoreBatch */
                'fa_sha1',
                'fa_actor',
                'fa_user' => 'filearchive_actor.actor_user',
                'fa_user_text' => 'filearchive_actor.actor_name'
            ] + $commentQuery['fields'],
            'joins' => [
                'filearchive_actor' => [ 'JOIN', 'actor_id=fa_actor' ]
            ] + $commentQuery['joins'],
        ];
    }
 
    public function loadFromRow( $row ) {
        $this->id = intval( $row->fa_id );
        $this->name = $row->fa_name;
        $this->archive_name = $row->fa_archive_name;
        $this->group = $row->fa_storage_group;
        $this->key = $row->fa_storage_key;
        $this->size = $row->fa_size;
        $this->bits = $row->fa_bits;
        $this->width = $row->fa_width;
        $this->height = $row->fa_height;
        $this->metadata = $row->fa_metadata;
        $this->mime = "$row->fa_major_mime/$row->fa_minor_mime";
        $this->media_type = $row->fa_media_type;
        $this->description = MediaWikiServices::getInstance()->getCommentStore()
            // Legacy because $row may have come from self::selectFields()
            ->getCommentLegacy( wfGetDB( DB_REPLICA ), 'fa_description', $row )->text;
        $this->user = User::newFromAnyId( $row->fa_user, $row->fa_user_text, $row->fa_actor );
        $this->timestamp = $row->fa_timestamp;
        $this->deleted = $row->fa_deleted;
        if ( isset( $row->fa_sha1 ) ) {
            $this->sha1 = $row->fa_sha1;
        } else {
            // old row, populate from key
            $this->sha1 = LocalRepo::getHashFromKey( $this->key );
        }
        if ( !$this->title ) {
            $this->title = Title::makeTitleSafe( NS_FILE, $row->fa_name );
        }
    }
 
    public function getTitle() {
        if ( !$this->title ) {
            $this->load();
        }
        return $this->title;
    }
 
    public function getName() {
        if ( $this->name === false ) {
            $this->load();
        }
 
        return $this->name;
    }
 
    public function getID() {
        $this->load();
 
        return $this->id;
    }
 
    public function exists() {
        $this->load();
 
        return $this->exists;
    }
 
    public function getKey() {
        $this->load();
 
        return $this->key;
    }
 
    public function getStorageKey() {
        return $this->getKey();
    }
 
    public function getGroup() {
        return $this->group;
    }
 
    public function getWidth() {
        $this->load();
 
        return $this->width;
    }
 
    public function getHeight() {
        $this->load();
 
        return $this->height;
    }
 
    public function getMetadata() {
        $this->load();
 
        return $this->metadata;
    }
 
    public function getSize() {
        $this->load();
 
        return $this->size;
    }
 
    public function getBits() {
        $this->load();
 
        return $this->bits;
    }
 
    public function getMimeType() {
        $this->load();
 
        return $this->mime;
    }
 
    private function getHandler() {
        if ( !isset( $this->handler ) ) {
            $this->handler = MediaHandler::getHandler( $this->getMimeType() );
        }
 
        return $this->handler;
    }
 
    public function pageCount() {
        if ( !isset( $this->pageCount ) ) {
            // @FIXME: callers expect File objects
            // @phan-suppress-next-line PhanTypeMismatchArgument
            if ( $this->getHandler() && $this->handler->isMultiPage( $this ) ) {
                // @phan-suppress-next-line PhanTypeMismatchArgument
                $this->pageCount = $this->handler->pageCount( $this );
            } else {
                $this->pageCount = false;
            }
        }
 
        return $this->pageCount;
    }
 
    public function getMediaType() {
        $this->load();
 
        return $this->media_type;
    }
 
    public function getTimestamp() {
        $this->load();
 
        return wfTimestamp( TS_MW, $this->timestamp );
    }
 
    public function getSha1() {
        $this->load();
 
        return $this->sha1;
    }
 
    public function getUser( $type = 'text' ) {
        wfDeprecated( __METHOD__, '1.37' );
        $this->load();
 
        if ( $type === 'object' ) {
            return $this->user ? User::newFromIdentity( $this->user ) : null;
        } elseif ( $type === 'text' ) {
            return $this->user ? $this->user->getName() : '';
        } elseif ( $type === 'id' ) {
            return $this->user ? $this->user->getId() : 0;
        }
 
        throw new MWException( "Unknown type '$type'." );
    }
 
    public function getUploader( int $audience = self::FOR_PUBLIC, Authority $performer = null ): ?UserIdentity {
        $this->load();
        if ( $audience === self::FOR_PUBLIC && $this->isDeleted( File::DELETED_USER ) ) {
            return null;
        } elseif ( $audience === self::FOR_THIS_USER && !$this->userCan( File::DELETED_USER, $performer ) ) {
            return null;
        } else {
            return $this->user;
        }
    }
 
    public function getDescription( int $audience = self::FOR_PUBLIC, Authority $performer = null ): string {
        $this->load();
        if ( $audience === self::FOR_PUBLIC && $this->isDeleted( File::DELETED_COMMENT ) ) {
            return '';
        } elseif ( $audience === self::FOR_THIS_USER && !$this->userCan( File::DELETED_COMMENT, $performer ) ) {
            return '';
        } else {
            return $this->description;
        }
    }
 
    public function getRawUser() {
        wfDeprecated( __METHOD__, '1.37' );
        return $this->getUser( 'id' );
    }
 
    public function getRawUserText() {
        wfDeprecated( __METHOD__, '1.37' );
        return $this->getUser( 'text' );
    }
 
    public function getRawDescription() {
        wfDeprecated( __METHOD__, '1.37' );
        $this->load();
        return $this->description;
    }
 
    public function getVisibility() {
        $this->load();
 
        return $this->deleted;
    }
 
    public function isDeleted( $field ) {
        $this->load();
 
        return ( $this->deleted & $field ) == $field;
    }
 
    public function userCan( $field, Authority $performer ) {
        $this->load();
        $title = $this->getTitle();
 
        return RevisionRecord::userCanBitfield(
            $this->deleted,
            $field,
            $performer,
            $title ?: null
        );
    }
}