TranslationStashSpecialPage.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\TranslatorSandbox;
 
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Extension\Translate\Utilities\Utilities;
use MediaWiki\Html\Html;
use MediaWiki\Json\FormatJson;
use MediaWiki\Language\Language;
use MediaWiki\Language\LanguageFactory;
use MediaWiki\Language\LanguageNameUtils;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Title\Title;
use MediaWiki\User\Options\UserOptionsLookup;
 
class TranslationStashSpecialPage extends SpecialPage {
 
    public const CONSTRUCTOR_OPTIONS = [
        'TranslateSandboxLimit',
    ];
 
    public function __construct(
        private readonly LanguageNameUtils $languageNameUtils,
        private readonly TranslationStashReader $stash,
        private readonly UserOptionsLookup $userOptionsLookup,
        private readonly LanguageFactory $languageFactory,
        private readonly ServiceOptions $options,
    ) {
        parent::__construct( 'TranslationStash' );
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
    }
 
    public function doesWrites() {
        return true;
    }
 
    protected function getGroupName(): string {
        return 'translation';
    }
 
    public function execute( $params ) {
        $limit = $this->options->get( 'TranslateSandboxLimit' );
 
        $this->setHeaders();
        $out = $this->getOutput();
 
        if ( !$this->hasPermissionToUse() ) {
            $out->redirect( Title::newMainPage()->getLocalURL() );
 
            return;
        }
 
        $out->addJsConfigVars( 'wgTranslateSandboxLimit', $limit );
        $out->addModules( 'ext.translate.specialTranslationStash' );
        $out->addModuleStyles( 'codex-styles' );
        $this->showPage();
    }
 
    private function hasPermissionToUse(): bool {
        return TranslateSandbox::isSandboxed( $this->getUser() );
    }
 
    private function showPage(): void {
        $out = $this->getOutput();
        $user = $this->getUser();
 
        $count = count( $this->stash->getTranslations( $user ) );
        if ( $count === 0 ) {
            $progress = $this->msg( 'translate-translationstash-initialtranslation' )->parse();
        } else {
            $progress = $this->msg( 'translate-translationstash-translations' )
                ->numParams( $count )
                ->parse();
        }
 
        $out->addHTML(
            <<<HTML
            <div class="grid">
                <div class="row translate-welcome-header">
                    <h1>
                        {$this->msg( 'translate-translationstash-welcome', $user->getName() )->parse()}
                    </h1>
                    <p>
                        {$this->msg( 'translate-translationstash-welcome-note' )->parse()}
                    </p>
                </div>
                <div class="row translate-stash-control">
                    <div class="six columns stash-stats">
                        {$progress}
                    </div>
                    <div class="six columns ext-translate-language-selector">
                        {$this->tuxLanguageSelector()}
                    </div>
                </div>
                {$this->getMessageTable()}
                <div class="row limit-reached hide"></div>
            </div>
            HTML
        );
    }
 
    private function getMessageTable(): string {
        $sourceLang = $this->getSourceLanguage();
        $targetLang = $this->getTargetLanguage();
 
        return Html::element(
            'div',
            [
                'class' => 'row tux-messagelist',
                'data-sourcelangcode' => $sourceLang->getCode(),
                'data-sourcelangdir' => $sourceLang->getDir(),
                'data-targetlangcode' => $targetLang->getCode(),
                'data-targetlangdir' => $targetLang->getDir(),
            ]
        );
    }
 
    private function tuxLanguageSelector(): string {
        // The name will be displayed in the UI language,
        // so use for lang and dir
        $language = $this->getTargetLanguage();
        $targetLangName = $this->languageNameUtils->getLanguageName( $language->getCode() );
 
        $label = Html::element( 'span', [], $this->msg( 'tux-languageselector' )->text() );
 
        $languageIcon = Html::element(
            'span',
            [ 'class' => 'ext-translate-language-icon' ]
        );
 
        $targetLanguageName = Html::element(
            'span',
            [
                'class' => 'ext-translate-target-language',
                'dir' => $language->getDir(),
                'lang' => $language->getHtmlCode()
            ],
            $targetLangName
        );
 
        $expandIcon = Html::element(
            'span',
            [ 'class' => 'ext-translate-language-selector-expand' ]
        );
 
        $value = Html::rawElement(
            'button',
            [
                'class' => 'uls cdx-button',
                'title' => $this->msg( 'tux-select-target-language' )->text()
            ],
            $languageIcon . $targetLanguageName . $expandIcon
        );
 
        return Html::rawElement(
            'div',
            [ 'class' => 'columns ext-translate-language-selector' ],
            "$label $value"
        );
    }
 
    protected function getSourceLanguage(): Language {
        // Bad
        return $this->languageFactory->getLanguage( 'en' );
    }
 
    private function getTargetLanguage(): Language {
        $ui = $this->getLanguage();
        $source = $this->getSourceLanguage();
        if ( !$ui->equals( $source ) ) {
            return $ui;
        }
 
        $options = FormatJson::decode(
            $this->userOptionsLookup->getOption( $this->getUser(), 'translate-sandbox' ),
            true
        );
        $supported = Utilities::getLanguageNames( 'en' );
 
        if ( isset( $options['languages'] ) ) {
            foreach ( $options['languages'] as $code ) {
                if ( !isset( $supported[$code] ) ) {
                    continue;
                }
 
                if ( $code !== $source->getCode() ) {
                    return $this->languageFactory->getLanguage( $code );
                }
            }
        }
 
        // User has not chosen any valid language. Pick the source.
        return $this->languageFactory->getLanguage( $source->getCode() );
    }
}