MessageGroupStatsTable.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\Statistics;
 
use Html;
use Language;
use MediaWiki\Extension\Translate\Utilities\Utilities;
use MediaWiki\Linker\LinkRenderer;
use MessageGroup;
use MessageGroupStats;
use MessageLocalizer;
use SpecialPage;
use Title;
use TranslateMetadata;
use Wikimedia\Rdbms\ILoadBalancer;
 
class MessageGroupStatsTable {
    private ILoadBalancer $loadBalancer;
    private LinkRenderer $linkRenderer;
    private MessageLocalizer $localizer;
    private Language $interfaceLanguage;
    private StatsTable $table;
    private bool $incompleteStats;
    private array $languageNames;
    private Title $translateTitle;
    private array $states;
    private bool $haveTranslateWorkflowStates;
 
    public function __construct(
        StatsTable $table,
        ILoadBalancer $loadBalancer,
        LinkRenderer $linkRenderer,
        MessageLocalizer $localizer,
        Language $interfaceLanguage,
        bool $haveTranslateWorkflowStates
    ) {
        $this->table = $table;
        $this->loadBalancer = $loadBalancer;
        $this->linkRenderer = $linkRenderer;
        $this->incompleteStats = false;
        $this->localizer = $localizer;
        $this->interfaceLanguage = $interfaceLanguage;
        $this->haveTranslateWorkflowStates = $haveTranslateWorkflowStates;
        $this->languageNames = Utilities::getLanguageNames( $this->interfaceLanguage->getCode() );
        $this->translateTitle = SpecialPage::getTitleFor( 'Translate' );
    }
 
    public function get(
        array $stats,
        MessageGroup $group,
        bool $noComplete,
        bool $noEmpty
    ): ?string {
        $out = '';
        $rowCount = 0;
        $totals = MessageGroupStats::getEmptyStats();
        $groupId = $group->getId();
 
        $languages = array_keys(
            Utilities::getLanguageNames( $this->interfaceLanguage->getCode() )
        );
        sort( $languages );
        $this->filterPriorityLangs( $languages, $groupId, $stats );
 
        // If workflow states are configured, adds a workflow states column
        if ( $this->haveTranslateWorkflowStates ) {
            $this->table->addExtraColumn( $this->localizer->msg( 'translate-stats-workflow' ) );
        }
 
        foreach ( $languages as $code ) {
            if ( $this->table->isExcluded( $group, $code ) ) {
                continue;
            }
 
            $languageStats = $stats[$code];
            $row = $this->makeRow(
                $this->table,
                $code,
                $languageStats,
                $group,
                $rowCount,
                $noComplete,
                $noEmpty
            );
            if ( $row ) {
                $rowCount += 1;
                $out .= $row;
                $totals = MessageGroupStats::multiAdd( $totals, $languageStats );
            }
        }
 
        if ( $out ) {
            $this->table->setMainColumnHeader( $this->localizer->msg( 'translate-mgs-column-language' ) );
            $out = $this->table->createHeader() . "\n" . $out;
            $out .= Html::closeElement( 'tbody' );
 
            $out .= Html::openElement( 'tfoot' );
            $out .= $this->table->makeTotalRow(
                $this->localizer->msg( 'translate-mgs-totals' )->numParams( $rowCount ),
                $totals
            );
            $out .= Html::closeElement( 'tfoot' );
 
            $out .= Html::closeElement( 'table' );
 
            return $out;
        } else {
            return null;
        }
    }
 
    public function areStatsIncomplete(): bool {
        return $this->incompleteStats;
    }
 
    private function getWorkflowStates( string $groupId ): array {
        $db = $this->loadBalancer->getConnection( DB_REPLICA );
        $res = $db->select(
            'translate_groupreviews',
            [ 'tgr_state', 'tgr_lang' ],
            [ 'tgr_group' => $groupId ],
            __METHOD__
        );
 
        $states = [];
        foreach ( $res as $row ) {
            $states[$row->tgr_lang] = $row->tgr_state;
        }
 
        return $states;
    }
 
    private function makeRow(
        StatsTable $table,
        string $languageCode,
        array $stats,
        MessageGroup $group,
        int $rowCount,
        bool $noComplete,
        bool $noEmpty
    ): ?string {
        $total = $stats[MessageGroupStats::TOTAL];
        $translated = $stats[MessageGroupStats::TRANSLATED];
        $fuzzy = $stats[MessageGroupStats::FUZZY];
        $extra = [];
 
        if ( $total === null ) {
            $this->incompleteStats = true;
        } else {
            if ( $noComplete && $fuzzy === 0 && $translated === $total ) {
                return null;
            }
 
            if ( $noEmpty && $translated === 0 && $fuzzy === 0 ) {
                return null;
            }
 
            // Skip below 2% if "don't show without translations" is checked.
            if ( $noEmpty && ( $translated / $total ) < 0.02 ) {
                return null;
            }
 
            if ( $translated === $total ) {
                $extra = [ 'action' => 'proofread' ];
            }
        }
 
        $rowParams = [];
        if ( $rowCount % 2 === 0 ) {
            $rowParams[ 'class' ] = 'tux-statstable-even';
        }
 
        $out = "\t" . Html::openElement( 'tr', $rowParams );
        $out .= "\n\t\t" . $this->getMainColumnCell( $languageCode, $extra, $group->getId() );
        $out .= $table->makeNumberColumns( $stats );
        $out .= $this->getWorkflowStateCell( $table, $languageCode, $group );
 
        $out .= "\n\t" . Html::closeElement( 'tr' ) . "\n";
 
        return $out;
    }
 
    private function getMainColumnCell( string $code, array $params, string $groupId ): string {
        if ( isset( $this->languageNames[$code] ) ) {
            $text = "$code: {$this->languageNames[$code]}";
        } else {
            $text = $code;
        }
 
        // Do not render links when generating table for MessagePrefixMessageGroup
        // as this is a dynamic group whose contents are based on user input
        if ( $groupId === '!prefix' ) {
            return Html::rawElement( 'td', [], $text );
        }
 
        $queryParameters = $params + [
            'group' => $groupId,
            'language' => $code
        ];
 
        $link = $this->linkRenderer->makeKnownLink(
            $this->translateTitle,
            $text,
            [],
            $queryParameters
        );
 
        return Html::rawElement( 'td', [], $link );
    }
 
    private function getWorkflowStateCell( StatsTable $table, string $language, MessageGroup $group ): string {
        if ( !$this->haveTranslateWorkflowStates ) {
            return '';
        }
 
        $this->states ??= $this->getWorkflowStates( $group->getId() );
        return $table->makeWorkflowStateCell( $this->states[$language] ?? null, $group, $language );
    }
 
    private function filterPriorityLangs( array &$languages, string $group, array $cache ): void {
        $filterLangs = TranslateMetadata::get( $group, 'prioritylangs' );
        if ( $filterLangs === false || strlen( $filterLangs ) === 0 ) {
            // No restrictions, keep everything
            return;
        }
        $filter = array_flip( explode( ',', $filterLangs ) );
        foreach ( $languages as $id => $code ) {
            if ( isset( $filter[$code] ) ) {
                continue;
            }
            $translated = $cache[$code][1];
            if ( $translated === 0 ) {
                unset( $languages[$id] );
            }
        }
    }
}