SpecialPageLanguage.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Specials;
 
use MediaWiki\Api\ApiMessage;
use MediaWiki\Content\IContentHandlerFactory;
use MediaWiki\Context\IContextSource;
use MediaWiki\Html\Html;
use MediaWiki\HTMLForm\HTMLForm;
use MediaWiki\Language\LanguageNameUtils;
use MediaWiki\Language\RawMessage;
use MediaWiki\Logging\LogEventsList;
use MediaWiki\Logging\LogPage;
use MediaWiki\Logging\ManualLogEntry;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\Search\SearchEngineFactory;
use MediaWiki\SpecialPage\FormSpecialPage;
use MediaWiki\Status\Status;
use MediaWiki\Title\MalformedTitleException;
use MediaWiki\Title\Title;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IDatabase;
 
class SpecialPageLanguage extends FormSpecialPage {
    private $goToUrl;
 
    public function __construct(
        private readonly IContentHandlerFactory $contentHandlerFactory,
        private readonly LanguageNameUtils $languageNameUtils,
        private readonly IConnectionProvider $dbProvider,
        private readonly SearchEngineFactory $searchEngineFactory,
    ) {
        parent::__construct( 'PageLanguage', 'pagelang' );
    }
 
    public function doesWrites() {
        return true;
    }
 
    protected function preHtml() {
        $this->getOutput()->addModules( 'mediawiki.misc-authed-ooui' );
        return parent::preHtml();
    }
 
    protected function getFormFields() {
        // Get default from the subpage of Special page
        $defaultName = $this->par;
        $title = $defaultName ? Title::newFromText( $defaultName ) : null;
        if ( $title ) {
            $defaultPageLanguage = $this->contentHandlerFactory->getContentHandler( $title->getContentModel() )
                ->getPageLanguage( $title );
 
            $hasCustomLanguageSet = !$defaultPageLanguage->equals( $title->getPageLanguage() );
        } else {
            $hasCustomLanguageSet = false;
        }
 
        $page = [];
        $page['pagename'] = [
            'type' => 'title',
            'label-message' => 'pagelang-name',
            'default' => $title ? $title->getPrefixedText() : $defaultName,
            'autofocus' => $defaultName === null,
            'exists' => true,
        ];
 
        // Options for whether to use the default language or select language
        $selectoptions = [
            (string)$this->msg( 'pagelang-use-default' )->escaped() => 1,
            (string)$this->msg( 'pagelang-select-lang' )->escaped() => 2,
        ];
        $page['selectoptions'] = [
            'id' => 'mw-pl-options',
            'type' => 'radio',
            'options' => $selectoptions,
            'default' => $hasCustomLanguageSet ? 2 : 1
        ];
 
        // Building a language selector
        $page['language'] = [
            'id' => 'mw-pl-languageselector',
            'cssclass' => 'mw-languageselector',
            'type' => 'language',
            'useCodex' => true,
            'label-message' => 'pagelang-language',
            'value' => $title ?
                $title->getPageLanguage()->getCode() :
                $this->getConfig()->get( MainConfigNames::LanguageCode ),
        ];
 
        // Allow user to enter a comment explaining the change
        $page['reason'] = [
            'type' => 'text',
            'label-message' => 'pagelang-reason'
        ];
 
        return $page;
    }
 
    protected function postHtml() {
        if ( $this->par ) {
            return $this->showLogFragment( $this->par );
        }
        return '';
    }
 
    protected function getDisplayFormat() {
        return 'ooui';
    }
 
    public function alterForm( HTMLForm $form ) {
        $this->getHookRunner()->onLanguageSelector( $this->getOutput(), 'mw-languageselector' );
        $form->setId( 'mw-pagelanguage-form' )
            ->setSubmitTextMsg( 'pagelang-submit' );
    }
 
    public function onSubmit( array $data ) {
        $pageName = $data['pagename'];
 
        // Check if user wants to use default language
        if ( $data['selectoptions'] == 1 ) {
            $newLanguage = 'default';
        } else {
            $newLanguage = $data['language'];
        }
 
        try {
            $title = Title::newFromTextThrow( $pageName );
        } catch ( MalformedTitleException $ex ) {
            return Status::newFatal( $ex->getMessageObject() );
        }
 
        // Check permissions and make sure the user has permission to edit the page
        $status = PermissionStatus::newEmpty();
        if ( !$this->getAuthority()->authorizeWrite( 'edit', $title, $status ) ) {
            $wikitext = $this->getOutput()->formatPermissionStatus( $status );
            // Hack to get our wikitext parsed
            return Status::newFatal( new RawMessage( '$1', [ $wikitext ] ) );
        }
 
        // Url to redirect to after the operation
        $this->goToUrl = $title->getFullUrlForRedirect(
            $title->isRedirect() ? [ 'redirect' => 'no' ] : []
        );
 
        return self::changePageLanguage(
            $this->getContext(),
            $title,
            $newLanguage,
            $data['reason'] ?? '',
            [],
            $this->dbProvider->getPrimaryDatabase()
        );
    }
 
    public static function changePageLanguage( IContextSource $context, Title $title,
        $newLanguage, $reason = "", array $tags = [], ?IDatabase $dbw = null ) {
        // Get the default language for the wiki
        $defLang = $context->getConfig()->get( MainConfigNames::LanguageCode );
 
        $pageId = $title->getArticleID();
 
        // Check if article exists
        if ( !$pageId ) {
            return Status::newFatal(
                'pagelang-nonexistent-page',
                wfEscapeWikiText( $title->getPrefixedText() )
            );
        }
 
        // Load the page language from DB
        $dbw ??= MediaWikiServices::getInstance()->getConnectionProvider()->getPrimaryDatabase();
        $oldLanguage = $dbw->newSelectQueryBuilder()
            ->select( 'page_lang' )
            ->from( 'page' )
            ->where( [ 'page_id' => $pageId ] )
            ->caller( __METHOD__ )->fetchField();
 
        // Check if user wants to use the default language
        if ( $newLanguage === 'default' ) {
            $newLanguage = null;
        }
 
        // No change in language
        if ( $newLanguage === $oldLanguage ) {
            // Check if old language does not exist
            if ( !$oldLanguage ) {
                return Status::newFatal( ApiMessage::create(
                    [
                        'pagelang-unchanged-language-default',
                        wfEscapeWikiText( $title->getPrefixedText() )
                    ],
                    'pagelang-unchanged-language'
                ) );
            }
            return Status::newFatal(
                'pagelang-unchanged-language',
                wfEscapeWikiText( $title->getPrefixedText() ),
                $oldLanguage
            );
        }
 
        // Hardcoded [def] if the language is set to null
        $logOld = $oldLanguage ?: $defLang . '[def]';
        $logNew = $newLanguage ?: $defLang . '[def]';
 
        // Writing new page language to database
        $pageUpdate = $dbw->newUpdateQueryBuilder()
            ->update( 'page' )
            ->set( [ 'page_lang' => $newLanguage ] )
            ->where( [
                'page_id' => $pageId,
                'page_lang' => $oldLanguage,
            ] )
            ->caller( __METHOD__ );
        $pageUpdate->execute();
        MediaWikiServices::getInstance()->getLinkWriteDuplicator()->duplicate( $pageUpdate );
 
        if ( !$dbw->affectedRows() ) {
            return Status::newFatal( 'pagelang-db-failed' );
        }
 
        // Logging change of language
        $logParams = [
            '4::oldlanguage' => $logOld,
            '5::newlanguage' => $logNew
        ];
        $entry = new ManualLogEntry( 'pagelang', 'pagelang' );
        $entry->setPerformer( $context->getUser() );
        $entry->setTarget( $title );
        $entry->setParameters( $logParams );
        $entry->setComment( is_string( $reason ) ? $reason : "" );
        $entry->addTags( $tags );
 
        $logid = $entry->insert();
        $entry->publish( $logid );
 
        // Force re-render so that language-based content (parser functions etc.) gets updated
        $title->invalidateCache();
 
        return Status::newGood( (object)[
            'oldLanguage' => $logOld,
            'newLanguage' => $logNew,
            'logId' => $logid,
        ] );
    }
 
    public function onSuccess() {
        // Success causes a redirect
        $this->getOutput()->redirect( $this->goToUrl );
    }
 
    private function showLogFragment( string $title ): string {
        $moveLogPage = new LogPage( 'pagelang' );
        $out1 = Html::element( 'h2', [], $moveLogPage->getName()->text() );
        $out2 = '';
        LogEventsList::showLogExtract( $out2, 'pagelang', $title );
        return $out1 . $out2;
    }
 
    public function prefixSearchSubpages( $search, $limit, $offset ) {
        return $this->prefixSearchString( $search, $limit, $offset, $this->searchEngineFactory );
    }
 
    protected function getGroupName() {
        return 'pagetools';
    }
}
 
class_alias( SpecialPageLanguage::class, 'SpecialPageLanguage' );