TranslationsSpecialPage.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\TranslatorInterface;
 
use MediaWiki\Extension\Translate\MessageLoading\MessageHandle;
use MediaWiki\Extension\Translate\Utilities\Utilities;
use MediaWiki\Html\Html;
use MediaWiki\HTMLForm\HTMLForm;
use MediaWiki\Language\Language;
use MediaWiki\Language\LanguageNameUtils;
use MediaWiki\Message\Message;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Search\SearchEngineFactory;
use MediaWiki\SpecialPage\IncludableSpecialPage;
use MediaWiki\Title\Title;
use MediaWiki\Utils\MWTimestamp;
use UnexpectedValueException;
use Wikimedia\HtmlArmor\HtmlArmor;
use Wikimedia\Rdbms\IConnectionProvider;
 
class TranslationsSpecialPage extends IncludableSpecialPage {
 
    public function __construct(
        private readonly Language $contentLanguage,
        private readonly LanguageNameUtils $languageNameUtils,
        private readonly IConnectionProvider $dbProvider,
        private readonly SearchEngineFactory $searchEngineFactory,
    ) {
        parent::__construct( 'Translations' );
    }
 
    protected function getGroupName(): string {
        return 'translation';
    }
 
    public function getDescription() {
        return $this->msg( 'translations' );
    }
 
    public function prefixSearchSubpages( $search, $limit, $offset ) {
        return $this->prefixSearchString( $search, $limit, $offset, $this->searchEngineFactory );
    }
 
    public function execute( $par ) {
        $this->setHeaders();
        $this->outputHeader();
 
        $out = $this->getOutput();
        $out->addModuleStyles( 'ext.translate.specialpages.styles' );
 
        $par = (string)$par;
 
        if ( $this->including() ) {
            $title = Title::newFromText( $par );
            if ( !$title ) {
                $out->addWikiMsg( 'translate-translations-including-no-param' );
            } else {
                $this->showTranslations( $title );
            }
 
            return;
        }
 
        $request = $this->getRequest();
        $message = $request->getText( 'message', $par );
        $namespace = $request->getInt( 'namespace', NS_MAIN );
 
        $title = Title::newFromText( $message, $namespace );
 
        $out->addHelpLink(
            'Help:Extension:Translate/Statistics_and_reporting#Translations_in_all_languages'
        );
 
        if ( !$title ) {
            $title = Title::makeTitle( NS_MEDIAWIKI, '' );
            $this->namespaceMessageForm( $title );
        } else {
            $this->namespaceMessageForm( $title );
            $out->addHTML( '<br />' );
            $this->showTranslations( $title );
        }
    }
 
    private function namespaceMessageForm( Title $title ): void {
        $formDescriptor = [
            'textbox' => [
                'type' => 'text',
                'name' => 'message',
                'id' => 'message',
                'label-message' => 'translate-translations-messagename',
                'size' => 30,
                'default' => $title->getText(),
            ],
            'selector' => [
                'type' => 'select',
                'name' => 'namespace',
                'id' => 'namespace',
                'label-message' => 'translate-translations-project',
                'options' => $this->getSortedNamespaces(),
                'default' => $title->getNamespace(),
            ]
        ];
 
        HTMLForm::factory( 'ooui', $formDescriptor, $this->getContext() )
            ->setMethod( 'get' )
            ->setTitle( $this->getPageTitle() ) // Remove subpage
            ->setSubmitTextMsg( 'allpagessubmit' )
            ->setWrapperLegendMsg( 'translate-translations-fieldset-title' )
            ->prepareForm()
            ->displayForm( false );
    }
 
    private function getSortedNamespaces(): array {
        $nslist = [];
        foreach ( $this->getConfig()->get( 'TranslateMessageNamespaces' ) as $ns ) {
            $nslist[$this->contentLanguage->getFormattedNsText( $ns )] = $ns;
        }
        ksort( $nslist );
 
        return $nslist;
    }
 
    private function showTranslations( Title $title ): void {
        $handle = new MessageHandle( $title );
        $namespace = $title->getNamespace();
 
        if ( !$handle->isValid() ) {
            $this->getOutput()->addWikiMsg( 'translate-translations-no-message', $title->getPrefixedText() );
 
            return;
        }
 
        $revisions = Utilities::getTranslationRevisions( $handle );
 
        if ( !$revisions ) {
            $this->getOutput()->addWikiMsg(
                'translate-translations-no-message',
                $title->getPrefixedText()
            );
 
            return;
        } else {
            $this->getOutput()->addWikiMsg(
                'translate-translations-count',
                Message::numParam( count( $revisions ) )
            );
        }
 
        $rows = [
            Html::rawElement(
                'tr',
                [],
                Html::element( 'th', [], $this->msg( 'allmessagesname' )->text() ) .
                    Html::element( 'th', [], $this->msg( 'allmessagescurrent' )->text() ) .
                    Html::element( 'th', [], $this->msg( 'translate-translations-last-edit-header' )->text() )
            ),
        ];
 
        $historyText = "\u{00A0}<sup>" .
            $this->msg( 'translate-translations-history-short' )->escaped() .
            "</sup>\u{00A0}";
        $separator = $this->msg( 'word-separator' )->plain();
 
        foreach ( $revisions as $key => $revision ) {
            $tTitle = Title::makeTitle( $namespace, $key );
            $tHandle = new MessageHandle( $tTitle );
 
            $code = $tHandle->getCode();
 
            $text = Utilities::getLanguageName( $code, $this->getLanguage()->getCode() );
            $text .= $separator;
            $text .= $this->msg( 'parentheses' )->params( $code )->plain();
            $tools = [
                'edit' => Html::element(
                    'a',
                    [ 'href' => Utilities::getEditorUrl( $tHandle ) ],
                    $text
                ),
                'history' => $this->getLinkRenderer()->makeLink(
                    $tTitle,
                    new HtmlArmor( $historyText ),
                    [
                        'title' => $this->msg( 'history-title', $tTitle->getPrefixedDBkey() )->text()
                    ],
                    [ 'action' => 'history' ]
                ),
            ];
 
            $mainContent = $revision->getContent( SlotRecord::MAIN );
            try {
                $pageText = Utilities::getTextFromTextContent( $mainContent );
            } catch ( UnexpectedValueException ) {
                continue;
            }
 
            $class = '';
            if ( MessageHandle::hasFuzzyString( $pageText ) || $tHandle->isFuzzy() ) {
                $class = 'mw-sp-translate-fuzzy';
            }
 
            $languageAttributes = [];
            if ( $this->languageNameUtils->isKnownLanguageTag( $code ) ) {
                $language = $tHandle->getEffectiveLanguage();
                $languageAttributes = [
                    'lang' => $language->getHtmlCode(),
                    'dir' => $language->getDir(),
                ];
            }
 
            $formattedContent = Utilities::convertWhiteSpaceToHTML( $pageText );
 
            // Build the last-edit cell with a sortable Unix timestamp and a linked username.
            $revTimestamp = $revision->getTimestamp();
            $unixTimestamp = wfTimestamp( TS_UNIX, $revTimestamp );
            $humanTimestamp = $this->getLanguage()->getHumanTimestamp( new MWTimestamp( $revTimestamp ) );
 
            $user = $revision->getUser( RevisionRecord::FOR_PUBLIC );
            if ( $user !== null ) {
                $userLinkHtml = $this->getLinkRenderer()->makeUserLink( $user, $this->getContext() );
            } else {
                $userLinkHtml = Html::element(
                    'span',
                    [ 'class' => 'history-deleted' ],
                    $this->msg( 'rev-deleted-user' )->text()
                );
            }
 
            $lastEditHtml = $this->msg( 'translate-translations-last-edit' )
                ->params( $humanTimestamp )
                ->rawParams( $userLinkHtml )
                ->escaped();
 
            $rows[] = Html::rawElement(
                'tr',
                [ 'class' => $class ],
                Html::rawElement( 'td', [], $tools['history'] . $tools['edit'] ) .
                    Html::rawElement( 'td', $languageAttributes, $formattedContent ) .
                    Html::rawElement( 'td', [ 'data-sort-value' => $unixTimestamp ], $lastEditHtml )
            );
        }
 
        $out = Html::rawElement(
            'table',
            [ 'class' => 'mw-sp-translate-table sortable wikitable' ],
            "\n" . implode( "\n", $rows ) . "\n"
        );
        $this->getOutput()->addHTML( $out );
    }
}