TranslatableBundleImporter.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\MessageGroupProcessing;
 
use Closure;
use Exception;
use MediaWiki\Content\TextContent;
use MediaWiki\Extension\Translate\PageTranslation\TranslatablePage;
use MediaWiki\Extension\Translate\PageTranslation\TranslatablePageParser;
use MediaWiki\Extension\Translate\Services;
use MediaWiki\Import\Hook\AfterImportPageHook;
use MediaWiki\Import\ImportStreamSource;
use MediaWiki\Import\WikiImporterFactory;
use MediaWiki\Language\FormatterFactory;
use MediaWiki\Language\MessageLocalizer;
use MediaWiki\Logging\ManualLogEntry;
use MediaWiki\Permissions\UltimateAuthority;
use MediaWiki\Revision\RevisionLookup;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Title\NamespaceInfo;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleFactory;
use MediaWiki\User\UserIdentity;
 
class TranslatableBundleImporter implements AfterImportPageHook {
 
    private ?Title $bundleTitle;
    private ?Closure $pageImportCompleteCallback = null;
    private bool $importInProgress = false;
 
    public function __construct(
        private readonly WikiImporterFactory $wikiImporterFactory,
        private readonly TranslatablePageParser $translatablePageParser,
        private readonly RevisionLookup $revisionLookup,
        private readonly NamespaceInfo $namespaceInfo,
        private readonly TitleFactory $titleFactory,
        private readonly FormatterFactory $formatterFactory,
    ) {
    }
 
    public static function getInstance(): self {
        return Services::getInstance()->getTranslatableBundleImporter();
    }
 
    public function import(
        string $importFilePath,
        string $interwikiPrefix,
        bool $assignKnownUsers,
        UserIdentity $user,
        MessageLocalizer $localizer,
        ?Title $targetPage,
        ?string $comment
    ): Title {
        $importSource = ImportStreamSource::newFromFile( $importFilePath );
        if ( !$importSource->isOK() ) {
            throw new TranslatableBundleImportException(
                "Error while reading import file '$importFilePath': " .
                $this->formatterFactory->getStatusFormatter( $localizer )->getMessage( $importSource )->text()
            );
        }
 
        $wikiImporter = $this->wikiImporterFactory
            // This is used only in a maintenance script (importTranslatableBundle.php),
            // so use UltimateAuthority to skip permission checks
            ->getWikiImporter( $importSource->value, new UltimateAuthority( $user ) );
        $wikiImporter->setUsernamePrefix( $interwikiPrefix, $assignKnownUsers );
 
        if ( $targetPage !== null ) {
            $wikiImporter->setImportTitleFactory(
                new TranslatableBundleImportTitleFactory( $this->namespaceInfo, $this->titleFactory, $targetPage )
            );
        }
 
        try {
            $this->importInProgress = true;
            // Reset the currently set title which might have been set during the previous import process
            $this->bundleTitle = null;
            $importResult = $wikiImporter->doImport();
        } catch ( Exception $e ) {
            throw new TranslatableBundleImportException(
                $e->getMessage(),
                $e->getCode(),
                $e
            );
        } finally {
            $this->importInProgress = false;
        }
 
        // @phan-suppress-next-line PhanPossiblyUndeclaredVariable
        if ( $importResult === false ) {
            throw new TranslatableBundleImportException( 'Unknown error while importing translatable bundle.' );
        }
 
        if ( !$this->bundleTitle ) {
            throw new TranslatableBundleImportException( 'Import done, but could not identify imported page.' );
        }
 
        // WikiImporter does not trigger hooks that run after a page is edited. Hence, manually add the ready
        // tag to the imported page if it contains the markup
        $this->addReadyTagForTranslatablePage( $this->bundleTitle );
        $this->logImport( $user, $this->bundleTitle, $comment );
 
        return $this->bundleTitle;
    }
 
    public function setPageImportCompleteCallback( callable $callable ): void {
        $this->pageImportCompleteCallback = Closure::fromCallable( $callable );
    }
 
    private function logImport( UserIdentity $user, Title $bundle, ?string $comment ): void {
        $entry = new ManualLogEntry( 'import', 'translatable-bundle' );
        $entry->setPerformer( $user );
        $entry->setTarget( $bundle );
        $logId = $entry->insert();
        if ( $comment ) {
            $entry->setComment( $comment );
        }
        $entry->publish( $logId );
    }
 
    private function addReadyTagForTranslatablePage( Title $translatablePageTitle ) {
        $revisionRecord = $this->revisionLookup->getRevisionByTitle( $translatablePageTitle );
        if ( !$revisionRecord ) {
            throw new TranslatableBundleImportException(
                "Revision record could not be found for imported page: $translatablePageTitle"
            );
        }
 
        $content = $revisionRecord->getContent( SlotRecord::MAIN );
        if ( !$content instanceof TextContent ) {
            throw new TranslatableBundleImportException(
                "Content in revision record for $translatablePageTitle is not of type TextContent"
            );
        }
 
        if ( $this->translatablePageParser->containsMarkup( $content->getText() ) ) {
            // Add the ready tag
            $page = TranslatablePage::newFromTitle( Title::newFromLinkTarget( $translatablePageTitle ) );
            $page->addReadyTag( $revisionRecord->getId() );
        }
    }
 
    public function onAfterImportPage( $title, $foreignTitle, $revCount, $sRevCount, $pageInfo ) {
        if ( $this->importInProgress ) {
            $this->bundleTitle ??= $title;
            if ( $this->pageImportCompleteCallback ) {
                ( $this->pageImportCompleteCallback )( $title, $foreignTitle );
            }
        }
    }
}