MediaFileHandler.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest\Handler;
 
use File;
use MediaFileTrait;
use MediaWiki\Permissions\PermissionManager;
use MediaWiki\Rest\LocalizedHttpException;
use MediaWiki\Rest\Response;
use MediaWiki\Rest\SimpleHandler;
use RepoGroup;
use RequestContext;
use Title;
use User;
use Wikimedia\Message\MessageValue;
use Wikimedia\ParamValidator\ParamValidator;
 
class MediaFileHandler extends SimpleHandler {
    use MediaFileTrait;
 
    private $permissionManager;
 
    private $repoGroup;
 
    private $user;
 
    private $title = null;
 
    private $file = null;
 
    public function __construct(
        PermissionManager $permissionManager,
        RepoGroup $repoGroup
    ) {
        $this->permissionManager = $permissionManager;
        $this->repoGroup = $repoGroup;
 
        // @todo Inject this, when there is a good way to do that
        $this->user = RequestContext::getMain()->getUser();
    }
 
    private function getTitle() {
        if ( $this->title === null ) {
            $this->title =
                Title::newFromText( $this->getValidatedParams()['title'], NS_FILE ) ?? false;
        }
        return $this->title;
    }
 
    private function getFile() {
        if ( $this->file === null ) {
            $title = $this->getTitle();
            $this->file =
                $this->repoGroup->findFile( $title, [ 'private' => $this->user ] ) ?? false;
        }
        return $this->file;
    }
 
    public function run( $title ) {
        $titleObj = $this->getTitle();
        $fileObj = $this->getFile();
 
        if ( !$titleObj || !$titleObj->exists() ) {
            throw new LocalizedHttpException(
                MessageValue::new( 'rest-nonexistent-title' )->plaintextParams(
                    $titleObj->getPrefixedDBkey()
                ),
                404
            );
        }
 
        if ( !$this->permissionManager->userCan( 'read', $this->user, $titleObj ) ) {
            throw new LocalizedHttpException(
                MessageValue::new( 'rest-permission-denied-title' )->plaintextParams(
                    $titleObj->getPrefixedDBkey()
                ),
                403
            );
        }
 
        if ( !$fileObj || !$fileObj->exists() ) {
            throw new LocalizedHttpException(
                MessageValue::new( 'rest-cannot-load-file' )->plaintextParams(
                    $titleObj->getPrefixedDBkey()
                ),
                404
            );
        }
 
        $response = $this->getResponse( $fileObj );
        return $this->getResponseFactory()->createJson( $response );
    }
 
    private function getResponse( File $file ) : array {
        list( $maxWidth, $maxHeight ) = self::getImageLimitsFromOption(
            $this->user, 'imagesize'
        );
        list( $maxThumbWidth, $maxThumbHeight ) = self::getImageLimitsFromOption(
            $this->user, 'thumbsize'
        );
        $transforms = [
            'preferred' => [
                'maxWidth' => $maxWidth,
                'maxHeight' => $maxHeight
            ],
            'thumbnail' => [
                'maxWidth' => $maxThumbWidth,
                'maxHeight' => $maxThumbHeight
            ]
        ];
 
        return $this->getFileInfo( $file, $this->user, $transforms );
    }
 
    public function needsWriteAccess() {
        return false;
    }
 
    public function getParamSettings() {
        return [
            'title' => [
                self::PARAM_SOURCE => 'path',
                ParamValidator::PARAM_TYPE => 'string',
                ParamValidator::PARAM_REQUIRED => true,
            ],
        ];
    }
 
    protected function getETag(): ?string {
        $file = $this->getFile();
        if ( !$file || !$file->exists() ) {
            return null;
        }
 
        return '"' . $file->getSha1() . '"';
    }
 
    protected function getLastModified(): ?string {
        $file = $this->getFile();
        if ( !$file || !$file->exists() ) {
            return null;
        }
 
        return $file->getTimestamp();
    }
 
    protected function hasRepresentation() {
        $file = $this->getFile();
        return $file ? $file->exists() : false;
    }
}