RevTagStore.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\MessageGroupProcessing;
 
use MediaWiki\Extension\Translate\Utilities\Utilities;
use MediaWiki\Page\PageIdentity;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\RawSQLExpression;
use Wikimedia\Rdbms\SelectQueryBuilder;
 
class RevTagStore {
    public const FUZZY_TAG = 'fuzzy';
    public const TRANSVER_PROP = 'tp:transver';
    public const TP_MARK_TAG = 'tp:mark';
    public const TP_READY_TAG = 'tp:tag';
    public const MB_VALID_TAG = 'mb:valid';
 
    private array $tagCache = [];
 
    public function __construct(
        private readonly IConnectionProvider $dbProvider,
    ) {
    }
 
    public function replaceTag(
        PageIdentity $identity,
        string $tag,
        int $revisionId,
        ?array $value = null
    ): void {
        if ( !$identity->exists() ) {
            return;
        }
 
        $articleId = $identity->getId();
 
        $dbw = $this->dbProvider->getPrimaryDatabase();
        $conditions = [
            'rt_page' => $articleId,
            'rt_type' => $tag
        ];
        $dbw->newDeleteQueryBuilder()
            ->deleteFrom( 'revtag' )
            ->where( $conditions )
            ->caller( __METHOD__ )
            ->execute();
 
        if ( $value !== null ) {
            $conditions['rt_value'] = serialize( implode( '|', $value ) );
        }
 
        $conditions['rt_revision'] = $revisionId;
        $dbw->newInsertQueryBuilder()
            ->insertInto( 'revtag' )
            ->row( $conditions )
            ->caller( __METHOD__ )
            ->execute();
 
        $this->tagCache[$articleId][$tag] = $revisionId;
    }
 
    public function getLatestRevisionWithTag( PageIdentity $identity, string $tag ): ?int {
        $response = $this->getLatestRevisionsForTags( $identity, $tag );
        return $response[$tag] ?? null;
    }
 
    public function getLatestRevisionsForTags( PageIdentity $identity, string ...$tags ): ?array {
        if ( !$identity->exists() ) {
            return null;
        }
 
        $articleId = $identity->getId();
 
        $response = [];
        $remainingTags = [];
 
        // ATTENTION: Cache should only be updated on POST requests.
        foreach ( $tags as $tag ) {
            if ( isset( $this->tagCache[$articleId][$tag] ) ) {
                $response[$tag] = $this->tagCache[$articleId][$tag];
            } else {
                $remainingTags[] = $tag;
            }
        }
 
        if ( !$remainingTags ) {
            // All tags were available in the cache, no need to run any queries.
            return $response;
        }
 
        $dbr = Utilities::getSafeReadDB();
        $results = $dbr->newSelectQueryBuilder()
            ->select( [ 'rt_revision' => 'MAX(rt_revision)', 'rt_type' ] )
            ->from( 'revtag' )
            ->where( [
                'rt_page' => $articleId,
                'rt_type' => $remainingTags
            ] )
            ->groupBy( 'rt_type' )
            ->caller( __METHOD__ )
            ->fetchResultSet();
 
        foreach ( $results as $row ) {
            $response[$row->rt_type] = (int)$row->rt_revision;
        }
 
        return $response;
    }
 
    public function removeTags( PageIdentity $identity, string ...$tag ): void {
        if ( !$identity->exists() ) {
            return;
        }
 
        $articleId = $identity->getId();
 
        $dbw = $this->dbProvider->getPrimaryDatabase();
        $dbw->newDeleteQueryBuilder()
            ->deleteFrom( 'revtag' )
            ->where( [
                'rt_page' => $articleId,
                'rt_type' => $tag,
            ] )
            ->caller( __METHOD__ )
            ->execute();
 
        unset( $this->tagCache[$articleId] );
    }
 
    public function isRevIdFuzzy( int $articleId, int $revisionId ): bool {
        $dbw = $this->dbProvider->getPrimaryDatabase();
        $res = $dbw->newSelectQueryBuilder()
            ->select( 'rt_type' )
            ->from( 'revtag' )
            ->where( [
                'rt_page' => $articleId,
                'rt_type' => self::FUZZY_TAG,
                'rt_revision' => $revisionId
            ] )
            ->caller( __METHOD__ )
            ->fetchField();
 
        return $res !== false;
    }
 
    public function getTransver( PageIdentity $identity, ?int $revid = null ): ?int {
        $db = Utilities::getSafeReadDB();
        $query = $db->newSelectQueryBuilder()
            ->select( 'rt_value' )
            ->from( 'revtag' )
            ->where( [
                'rt_page' => $identity->getId(),
                'rt_type' => self::TRANSVER_PROP,
            ] );
        if ( $revid !== null ) {
            $query->where( $db->expr( 'rt_revision', '<=', $revid ) );
        }
        $result = $query
            ->orderBy( 'rt_revision', SelectQueryBuilder::SORT_DESC )
            ->caller( __METHOD__ )
            ->fetchField();
        // The revtag database is defined to store a string in rt_value,
        // but tp:transver is always an integer
        return $result ? (int)$result : null;
    }
 
    public function setTransver( PageIdentity $identity, int $translationRevision, int $transver ): void {
        $dbw = $this->dbProvider->getPrimaryDatabase();
 
        $conds = [
            'rt_page' => $identity->getId(),
            'rt_type' => self::TRANSVER_PROP,
            'rt_revision' => $translationRevision,
            'rt_value' => $transver,
        ];
        $dbw->newReplaceQueryBuilder()
            ->replaceInto( 'revtag' )
            ->uniqueIndexFields( [ 'rt_type', 'rt_page', 'rt_revision' ] )
            ->row( $conds )
            ->caller( __METHOD__ )
            ->execute();
    }
 
    public static function getTranslatableBundleIds( array $revTagsLatest, array $revTagsAny = [] ): array {
        $dbr = Utilities::getSafeReadDB();
        $expr = $dbr->andExpr( [
            new RawSQLExpression( 'rt_revision = page_latest' ),
            'rt_type' => $revTagsLatest
        ] );
        if ( $revTagsAny ) {
            $expr = $dbr->orExpr( [ $expr, 'rt_type' => $revTagsAny ] );
        }
        $pageIds = $dbr->newSelectQueryBuilder()
            ->select( 'rt_page' )
            ->from( 'revtag' )
            ->join(
                'page',
                null,
                [
                    'rt_page = page_id',
                    $expr
                ]
            )
            ->groupBy( 'rt_page' )
            ->caller( __METHOD__ )
            ->fetchFieldValues();
        return array_map( intval( ... ), $pageIds );
    }
}