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;
 
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 IConnectionProvider $connectionProvider;
    private $tagCache = [];
 
    public function __construct( IConnectionProvider $connectionProvider ) {
        $this->connectionProvider = $connectionProvider;
    }
 
    public function replaceTag(
        PageIdentity $identity,
        string $tag,
        int $revisionId,
        ?array $value = null
    ): void {
        if ( !$identity->exists() ) {
            return;
        }
 
        $articleId = $identity->getId();
 
        $dbw = $this->connectionProvider->getPrimaryDatabase();
        $conds = [
            'rt_page' => $articleId,
            'rt_type' => $tag
        ];
        $dbw->delete( 'revtag', $conds, __METHOD__ );
 
        if ( $value !== null ) {
            $conds['rt_value'] = serialize( implode( '|', $value ) );
        }
 
        $conds['rt_revision'] = $revisionId;
        $dbw->insert( 'revtag', $conds, __METHOD__ );
 
        $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( [ 'MAX(rt_revision) AS 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->connectionProvider->getPrimaryDatabase();
        $conds = [
            'rt_page' => $articleId,
            'rt_type' => $tag,
        ];
        $dbw->delete( 'revtag', $conds, __METHOD__ );
 
        unset( $this->tagCache[$articleId] );
    }
 
    public static function getTranslatableBundleIds( string ...$revTags ): array {
        $dbr = Utilities::getSafeReadDB();
 
        $tables = [ 'revtag', 'page' ];
        $fields = 'rt_page';
        $conds = [
            'rt_page = page_id',
            'rt_revision = page_latest',
            'rt_type' => $revTags,
        ];
        $options = [ 'GROUP BY' => 'rt_page' ];
 
        $res = $dbr->select( $tables, $fields, $conds, __METHOD__, $options );
        $results = [];
        foreach ( $res as $row ) {
            $results[$row->rt_page] = true;
        }
 
        return $results;
    }
}