MediaFileHandler.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest\Handler;
 
use File;
use MediaFileTrait;
use MediaWiki\Page\ExistingPageRecord;
use MediaWiki\Page\PageLookup;
use MediaWiki\Rest\LocalizedHttpException;
use MediaWiki\Rest\Response;
use MediaWiki\Rest\SimpleHandler;
use RepoGroup;
use Wikimedia\Message\MessageValue;
use Wikimedia\ParamValidator\ParamValidator;
 
class MediaFileHandler extends SimpleHandler {
    use MediaFileTrait;
 
    private $repoGroup;
 
    private $pageLookup;
 
    private $page = false;
 
    private $file = false;
 
    public function __construct(
        RepoGroup $repoGroup,
        PageLookup $pageLookup
    ) {
        $this->repoGroup = $repoGroup;
        $this->pageLookup = $pageLookup;
    }
 
    private function getPage(): ?ExistingPageRecord {
        if ( $this->page === false ) {
            $this->page = $this->pageLookup->getExistingPageByText(
                    $this->getValidatedParams()['title'], NS_FILE
                );
        }
        return $this->page;
    }
 
    private function getFile(): ?File {
        if ( $this->file === false ) {
            $page = $this->getPage();
            $this->file =
                $this->repoGroup->findFile( $page, [ 'private' => $this->getAuthority() ] ) ?: null;
        }
        return $this->file;
    }
 
    public function run( $title ) {
        $page = $this->getPage();
 
        if ( !$page ) {
            throw new LocalizedHttpException(
                MessageValue::new( 'rest-nonexistent-title' )->plaintextParams( $title ),
                404
            );
        }
 
        if ( !$this->getAuthority()->authorizeRead( 'read', $page ) ) {
            throw new LocalizedHttpException(
                MessageValue::new( 'rest-permission-denied-title' )->plaintextParams( $title ),
                403
            );
        }
 
        $fileObj = $this->getFile();
        if ( !$fileObj || !$fileObj->exists() ) {
            throw new LocalizedHttpException(
                MessageValue::new( 'rest-cannot-load-file' )->plaintextParams( $title ),
                404
            );
        }
 
        $response = $this->getResponse( $fileObj );
        return $this->getResponseFactory()->createJson( $response );
    }
 
    private function getResponse( File $file ): array {
        list( $maxWidth, $maxHeight ) = self::getImageLimitsFromOption(
            $this->getAuthority()->getUser(), 'imagesize'
        );
        list( $maxThumbWidth, $maxThumbHeight ) = self::getImageLimitsFromOption(
            $this->getAuthority()->getUser(), 'thumbsize'
        );
        $transforms = [
            'preferred' => [
                'maxWidth' => $maxWidth,
                'maxHeight' => $maxHeight
            ],
            'thumbnail' => [
                'maxWidth' => $maxThumbWidth,
                'maxHeight' => $maxThumbHeight
            ]
        ];
 
        return $this->getFileInfo( $file, $this->getAuthority(), $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;
    }
}