MediaLinksHandler.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest\Handler;
 
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;
use Wikimedia\Rdbms\ILoadBalancer;
 
class MediaLinksHandler extends SimpleHandler {
    use MediaFileTrait;
 
    private const MAX_NUM_LINKS = 100;
 
    private $permissionManager;
 
    private $loadBalancer;
 
    private $repoGroup;
 
    private $user;
 
    public function __construct(
        PermissionManager $permissionManager,
        ILoadBalancer $loadBalancer,
        RepoGroup $repoGroup
    ) {
        $this->permissionManager = $permissionManager;
        $this->loadBalancer = $loadBalancer;
        $this->repoGroup = $repoGroup;
 
        // @todo Inject this, when there is a good way to do that
        $this->user = RequestContext::getMain()->getUser();
    }
 
    public function run( $title ) {
        $titleObj = Title::newFromText( $title );
        if ( !$titleObj || !$titleObj->getArticleID() ) {
            throw new LocalizedHttpException(
                MessageValue::new( 'rest-nonexistent-title' )->plaintextParams( $title ),
                404
            );
        }
 
        if ( !$this->permissionManager->userCan( 'read', $this->user, $titleObj ) ) {
            throw new LocalizedHttpException(
                MessageValue::new( 'rest-permission-denied-title' )->plaintextParams( $title ),
                403
            );
        }
 
        // @todo: add continuation if too many links are found
        $results = $this->getDbResults( $titleObj->getArticleID() );
        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.
        $findTitles = array_map( function ( $title ) {
            return [
                'title' => $title,
                'private' => $this->user,
            ];
        }, $results );
 
        $files = $this->repoGroup->findFiles( $findTitles );
        list( $maxWidth, $maxHeight ) = self::getImageLimitsFromOption( $this->user, 'imagesize' );
        $transforms = [
            'preferred' => [
                'maxWidth' => $maxWidth,
                'maxHeight' => $maxHeight,
            ]
        ];
        $response = [];
        foreach ( $files as $file ) {
            $response[] = $this->getFileInfo( $file, $this->user, $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,
            ],
        ];
    }
}