LanguageLinksHandler.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest\Handler;
 
use MalformedTitleException;
use MediaWiki\Languages\LanguageNameUtils;
use MediaWiki\Page\ExistingPageRecord;
use MediaWiki\Page\PageLookup;
use MediaWiki\Rest\LocalizedHttpException;
use MediaWiki\Rest\Response;
use MediaWiki\Rest\SimpleHandler;
use TitleFormatter;
use TitleParser;
use Wikimedia\Message\MessageValue;
use Wikimedia\Message\ParamType;
use Wikimedia\Message\ScalarParam;
use Wikimedia\ParamValidator\ParamValidator;
use Wikimedia\Rdbms\ILoadBalancer;
 
class LanguageLinksHandler extends SimpleHandler {
 
    private $loadBalancer;
 
    private $languageNameUtils;
 
    private $titleFormatter;
 
    private $titleParser;
 
    private $pageLookup;
 
    private $page = false;
 
    public function __construct(
        ILoadBalancer $loadBalancer,
        LanguageNameUtils $languageNameUtils,
        TitleFormatter $titleFormatter,
        TitleParser $titleParser,
        PageLookup $pageLookup
    ) {
        $this->loadBalancer = $loadBalancer;
        $this->languageNameUtils = $languageNameUtils;
        $this->titleFormatter = $titleFormatter;
        $this->titleParser = $titleParser;
        $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(
                new MessageValue( 'rest-nonexistent-title',
                    [ new ScalarParam( ParamType::PLAINTEXT, $title ) ]
                ),
                404
            );
        }
        if ( !$this->getAuthority()->authorizeRead( 'read', $page ) ) {
            throw new LocalizedHttpException(
                new MessageValue( 'rest-permission-denied-title',
                    [ new ScalarParam( ParamType::PLAINTEXT, $title ) ] ),
                403
            );
        }
 
        return $this->getResponseFactory()
            ->createJson( $this->fetchLinks( $page->getId() ) );
    }
 
    private function fetchLinks( $pageId ) {
        $result = [];
        $res = $this->loadBalancer->getConnectionRef( DB_REPLICA )
            ->select(
                'langlinks',
                '*',
                [ 'll_from' => $pageId ],
                __METHOD__,
                [ 'ORDER BY' => 'll_lang' ]
            );
        foreach ( $res as $item ) {
            try {
                $targetTitle = $this->titleParser->parseTitle( $item->ll_title );
                $result[] = [
                    'code' => $item->ll_lang,
                    'name' => $this->languageNameUtils->getLanguageName( $item->ll_lang ),
                    'key' => $this->titleFormatter->getPrefixedDBkey( $targetTitle ),
                    'title' => $this->titleFormatter->getPrefixedText( $targetTitle )
                ];
            } catch ( MalformedTitleException $e ) {
                // skip malformed titles
            }
        }
        return $result;
    }
 
    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();
    }
 
}