MediaLinksHandler.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest\Handler;
 
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;
use Wikimedia\Rdbms\ILoadBalancer;
 
class MediaLinksHandler extends SimpleHandler {
    use MediaFileTrait;
 
    private const MAX_NUM_LINKS = 100;
 
    private $loadBalancer;
 
    private $repoGroup;
 
    private $pageLookup;
 
    private $page = false;
 
    public function __construct(
        ILoadBalancer $loadBalancer,
        RepoGroup $repoGroup,
        PageLookup $pageLookup
    ) {
        $this->loadBalancer = $loadBalancer;
        $this->repoGroup = $repoGroup;
        $this->pageLookup = $pageLookup;
    }
 
    private function getPage(): ?ExistingPageRecord {
        if ( $this->page === false ) {
            $this->page = $this->pageLookup->getExistingPageByText(
                    $this->getValidatedParams()['title']
                );
        }
        return $this->page;
    }
 
    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
            );
        }
 
        // @todo: add continuation if too many links are found
        $results = $this->getDbResults( $page->getId() );
        if ( count( $results ) > self::MAX_NUM_LINKS ) {
            throw new LocalizedHttpException(
                MessageValue::new( 'rest-media-too-many-links' )
                    ->plaintextParams( $title )
                    ->numParams( self::MAX_NUM_LINKS ),
                500
            );
        }
        $response = $this->processDbResults( $results );
        return $this->getResponseFactory()->createJson( $response );
    }
 
    private function getDbResults( int $pageId ) {
        $dbr = $this->loadBalancer->getConnectionRef( DB_REPLICA );
        return $dbr->selectFieldValues(
            'imagelinks',
            'il_to',
            [ 'il_from' => $pageId ],
            __METHOD__,
            [
                'ORDER BY' => 'il_to',
                'LIMIT' => self::MAX_NUM_LINKS + 1,
            ]
        );
    }
 
    private function processDbResults( $results ) {
        // Using "private" here means an equivalent of the Action API's "anon-public-user-private"
        // caching model would be necessary, if caching is ever added to this endpoint.
        $performer = $this->getAuthority();
        $findTitles = array_map( static function ( $title ) use ( $performer ) {
            return [
                'title' => $title,
                'private' => $performer,
            ];
        }, $results );
 
        $files = $this->repoGroup->findFiles( $findTitles );
        list( $maxWidth, $maxHeight ) = self::getImageLimitsFromOption(
            $this->getAuthority()->getUser(),
            'imagesize'
        );
        $transforms = [
            'preferred' => [
                'maxWidth' => $maxWidth,
                'maxHeight' => $maxHeight,
            ]
        ];
        $response = [];
        foreach ( $files as $file ) {
            $response[] = $this->getFileInfo( $file, $performer, $transforms );
        }
 
        $response = [
            'files' => $response
        ];
 
        return $response;
    }
 
    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 {
        $page = $this->getPage();
        if ( !$page ) {
            return null;
        }
 
        // XXX: use hash of the rendered HTML?
        return '"' . $page->getLatest() . '@' . wfTimestamp( TS_MW, $page->getTouched() ) . '"';
    }
 
    protected function getLastModified(): ?string {
        $page = $this->getPage();
        if ( !$page ) {
            return null;
        }
 
        return $page->getTouched();
    }
 
    protected function hasRepresentation() {
        return (bool)$this->getPage();
    }
}