TranslateEditAddons.php

Go to the documentation of this file.

<?php
use MediaWiki\Extension\Translate\MessageGroupProcessing\RevTagStore;
use MediaWiki\Extension\Translate\PageTranslation\Hooks as PageTranslationHooks;
use MediaWiki\Extension\Translate\Services;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Storage\EditResult;
use MediaWiki\User\UserIdentity;
 
class TranslateEditAddons {
    public static function disallowLangTranslations( Title $title, User $user,
        $action, &$result
    ) {
        if ( $action !== 'edit' ) {
            return true;
        }
 
        $handle = new MessageHandle( $title );
        if ( !$handle->isValid() ) {
            return true;
        }
 
        if ( $user->isAllowed( 'translate-manage' ) ) {
            return true;
        }
 
        $group = $handle->getGroup();
        $languages = $group->getTranslatableLanguages();
        $langCode = $handle->getCode();
        if ( $languages !== null && $langCode && !isset( $languages[$langCode] ) ) {
            $result = [ 'translate-language-disabled' ];
            return false;
        }
 
        $groupId = $group->getId();
        $checks = [
            $groupId,
            strtok( $groupId, '-' ),
            '*'
        ];
 
        $disabledLanguages = Services::getInstance()->getConfigHelper()->getDisabledTargetLanguages();
        foreach ( $checks as $check ) {
            if ( isset( $disabledLanguages[$check][$langCode] ) ) {
                $reason = $disabledLanguages[$check][$langCode];
                $result = [ 'translate-page-disabled', $reason ];
                return false;
            }
        }
 
        return true;
    }
 
    public static function onSaveComplete(
        WikiPage $wikiPage,
        UserIdentity $userIdentity,
        string $summary,
        int $flags,
        RevisionRecord $revisionRecord,
        EditResult $editResult
    ) {
        global $wgEnablePageTranslation;
 
        $content = $wikiPage->getContent();
 
        if ( !$content instanceof TextContent ) {
            // Screw it, not interested
            return true;
        }
 
        $text = $content->getText();
        $title = $wikiPage->getTitle();
        $handle = new MessageHandle( $title );
 
        if ( !$handle->isValid() ) {
            return true;
        }
 
        // Update it.
        $revId = $revisionRecord->getId();
 
        $fuzzy = self::checkNeedsFuzzy( $handle, $text );
        self::updateFuzzyTag( $title, $revId, $fuzzy );
 
        $group = $handle->getGroup();
        // Update translation stats - source language should always be up to date
        if ( $handle->getCode() !== $group->getSourceLanguage() ) {
            // This will update in-process cache immediately, but the value is saved
            // to the database in a deferred update. See MessageGroupStats::queueUpdates.
            // In case an error happens before that, the stats may be stale, but that
            // would be fixed by the next update or purge.
            MessageGroupStats::clear( $handle );
        }
 
        // This job asks for stats, however the updated stats are written in a deferred update.
        // To make it less likely that the job would be executed before the updated stats are
        // written, create the job inside a deferred update too.
        DeferredUpdates::addCallableUpdate(
            static function () use ( $handle ) {
                MessageGroupStatesUpdaterJob::onChange( $handle );
            }
        );
 
        $user = User::newFromIdentity( $userIdentity );
 
        if ( $fuzzy === false ) {
            Hooks::run( 'Translate:newTranslation', [ $handle, $revId, $text, $user ] );
        }
 
        TTMServer::onChange( $handle );
 
        if ( $wgEnablePageTranslation && $handle->isPageTranslation() ) {
            // Updates for translatable pages only
            $minor = $flags & EDIT_MINOR;
            PageTranslationHooks::onSectionSave( $wikiPage, $user, $content,
                $summary, $minor, $flags, $handle );
        }
 
        return true;
    }
 
    protected static function checkNeedsFuzzy( MessageHandle $handle, $text ) {
        // Docs are exempt for checks
        if ( $handle->isDoc() ) {
            return false;
        }
 
        // Check for explicit tag.
        if ( MessageHandle::hasFuzzyString( $text ) ) {
            return true;
        }
 
        // Not all groups have validators
        $group = $handle->getGroup();
        $validator = $group->getValidator();
 
        // no validator set
        if ( !$validator ) {
            return false;
        }
 
        $code = $handle->getCode();
        $key = $handle->getKey();
        $en = $group->getMessage( $key, $group->getSourceLanguage() );
        $message = new FatMessage( $key, $en );
        // Take the contents from edit field as a translation.
        $message->setTranslation( $text );
        if ( $message->definition() === null ) {
            // This should NOT happen, but add a check since it seems to be happening
            // See: https://phabricator.wikimedia.org/T255669
            LoggerFactory::getInstance( 'Translate' )->warning(
                'Message definition is empty! Title: {title}, group: {group}, key: {key}',
                [
                    'title' => $handle->getTitle()->getPrefixedText(),
                    'group' => $group->getId(),
                    'key' => $key
                ]
            );
            return false;
        }
 
        $validationResult = $validator->quickValidate( $message, $code );
        return $validationResult->hasIssues();
    }
 
    protected static function updateFuzzyTag( Title $title, $revision, $fuzzy ) {
        $dbw = wfGetDB( DB_PRIMARY );
 
        $conds = [
            'rt_page' => $title->getArticleID(),
            'rt_type' => RevTagStore::FUZZY_TAG,
            'rt_revision' => $revision
        ];
 
        // Replace the existing fuzzy tag, if any
        if ( $fuzzy !== false ) {
            $index = array_keys( $conds );
            $dbw->replace( 'revtag', [ $index ], $conds, __METHOD__ );
        } else {
            $dbw->delete( 'revtag', $conds, __METHOD__ );
        }
 
        return (bool)$dbw->affectedRows();
    }
 
    public static function updateTransverTag( MessageHandle $handle, $revision,
        $text, User $user
    ) {
        if ( $user->isAllowed( 'bot' ) ) {
            return false;
        }
 
        $group = $handle->getGroup();
 
        $title = $handle->getTitle();
        $name = $handle->getKey() . '/' . $group->getSourceLanguage();
        $definitionTitle = Title::makeTitleSafe( $title->getNamespace(), $name );
        if ( !$definitionTitle || !$definitionTitle->exists() ) {
            return true;
        }
 
        $definitionRevision = $definitionTitle->getLatestRevID();
 
        $dbw = wfGetDB( DB_PRIMARY );
 
        $conds = [
            'rt_page' => $title->getArticleID(),
            'rt_type' => RevTagStore::TRANSVER_PROP,
            'rt_revision' => $revision,
            'rt_value' => $definitionRevision,
        ];
        $index = [ 'rt_type', 'rt_page', 'rt_revision' ];
        $dbw->replace( 'revtag', [ $index ], $conds, __METHOD__ );
 
        return true;
    }
 
    public static function disablePreSaveTransform( WikiPage $wikiPage, ParserOptions $popts ) {
        global $wgTranslateUsePreSaveTransform;
 
        if ( !$wgTranslateUsePreSaveTransform ) {
            $handle = new MessageHandle( $wikiPage->getTitle() );
            if ( $handle->isMessageNamespace() && !$handle->isDoc() ) {
                $popts->setPreSaveTransform( false );
            }
        }
 
        return true;
    }
}