QueryMessageGroupsActionApi.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\MessageGroupProcessing;
 
use AggregateMessageGroup;
use MediaWiki\Api\ApiBase;
use MediaWiki\Api\ApiQuery;
use MediaWiki\Api\ApiQueryBase;
use MediaWiki\Extension\Translate\HookRunner;
use MediaWiki\Extension\Translate\MessageProcessing\MessageGroupMetadata;
use MediaWiki\Extension\Translate\MessageProcessing\StringMatcher;
use MediaWiki\Extension\Translate\Utilities\Utilities;
use MessageGroup;
use Wikimedia\ParamValidator\ParamValidator;
use function array_key_exists;
 
class QueryMessageGroupsActionApi extends ApiQueryBase {
 
    public function __construct(
        ApiQuery $query,
        string $moduleName,
        private readonly HookRunner $hookRunner,
        private readonly MessageGroupMetadata $messageGroupMetadata,
        private readonly MessageGroupSubscription $groupSubscription,
    ) {
        parent::__construct( $query, $moduleName, 'mg' );
    }
 
    public function execute(): void {
        $params = $this->extractRequestParams();
        $filter = $params['filter'];
 
        $groups = [];
        $props = array_flip( $params['prop'] );
 
        $needsMetadata = isset( $props['prioritylangs'] ) || isset( $props['priorityforce'] );
 
        if ( $params['format'] === 'flat' ) {
            if ( $params['root'] !== '' ) {
                $group = MessageGroups::getGroup( $params['root'] );
                if ( $group ) {
                    $groups[$params['root']] = $group;
                }
            } else {
                $groups = MessageGroups::getAllGroups();
                usort( $groups, [ MessageGroups::class, 'groupLabelSort' ] );
            }
        } elseif ( $params['root'] !== '' ) {
            // format=tree from now on, as it is the only other valid option
            $group = MessageGroups::getGroup( $params['root'] );
            if ( $group instanceof AggregateMessageGroup ) {
                $childIds = [];
                $groups = MessageGroups::subGroups( $group, $childIds );
                // The parent group is the first, ignore it
                array_shift( $groups );
            }
        } else {
            $groups = MessageGroups::getGroupStructure();
        }
 
        if ( $params['root'] === '' ) {
            $dynamicGroups = [];
            foreach ( array_keys( MessageGroups::getDynamicGroups() ) as $id ) {
                $dynamicGroups[$id] = MessageGroups::getGroup( $id );
            }
            // Have dynamic groups appear first in the list
            $groups = $dynamicGroups + $groups;
        }
        '@phan-var (MessageGroup|array)[] $groups';
 
        // Do not list the sandbox group. The code that knows it
        // exists can access it directly.
        if ( isset( $groups['!sandbox'] ) ) {
            unset( $groups['!sandbox'] );
        }
 
        $result = $this->getResult();
        $matcher = new StringMatcher( '', $filter );
        foreach ( $groups as $index => $mixed ) {
            // array when Format = tree
            $group = is_array( $mixed ) ? reset( $mixed ) : $mixed;
            if ( $filter !== [] && !$matcher->matches( $group->getId() ) ) {
                unset( $groups[$index] );
                continue;
            }
 
            if (
                $params['languageFilter'] !== '' &&
                $this->messageGroupMetadata->isExcluded( $group, $params['languageFilter'] )
            ) {
                unset( $groups[$index] );
            }
        }
 
        if ( $needsMetadata && $groups ) {
            // Collect all message group ids. Handles tree format and removes duplicates.
            // This is one of the few cases where array_walk_recursive actually does what we want.
            $messageGroupIds = [];
            array_walk_recursive(
                array: $groups,
                callback: static function ( MessageGroup $value ) use ( &$messageGroupIds ) {
                    $messageGroupIds[$value->getId()] = true;
                }
            );
            $this->messageGroupMetadata->preloadGroups( array_keys( $messageGroupIds ), __METHOD__ );
        }
 
        $subscriptions = [];
        if ( isset( $props['subscription'] ) ) {
            $subscriptions = array_flip( $this->groupSubscription->getUserSubscriptions( $this->getUser() ) );
        }
 
        foreach ( $groups as $index => $mixed ) {
            $a = $this->formatGroup( $mixed, $props, $subscriptions );
 
            $result->setIndexedTagName( $a, 'group' );
 
            // @todo Add a continue?
            $fit = $result->addValue( [ 'query', $this->getModuleName() ], null, $a );
            if ( !$fit ) {
                // Even if we're not going to give a continue, no point carrying on
                // if the result is full
                break;
            }
        }
 
        $result->addIndexedTagName( [ 'query', $this->getModuleName() ], 'group' );
    }
 
    protected function formatGroup( $mixed, array $props, array $subscriptions, int $depth = 0 ): array {
        $params = $this->extractRequestParams();
        $context = $this->getContext();
 
        // Default
        $g = $mixed;
        $subgroups = [];
 
        // Format = tree and has subgroups
        if ( is_array( $mixed ) ) {
            $g = array_shift( $mixed );
            $subgroups = $mixed;
        }
 
        $a = [];
 
        $groupId = $g->getId();
 
        if ( isset( $props['id'] ) ) {
            $a['id'] = $groupId;
        }
 
        if ( isset( $props['label'] ) ) {
            $a['label'] = $g->getLabel( $context );
        }
 
        if ( isset( $props['description'] ) ) {
            $a['description'] = $g->getDescription( $context );
        }
 
        if ( isset( $props['class'] ) ) {
            $a['class'] = get_class( $g );
        }
 
        if ( isset( $props['namespace'] ) ) {
            $a['namespace'] = $g->getNamespace();
        }
 
        if ( isset( $props['exists'] ) ) {
            $a['exists'] = $g->exists();
        }
 
        if ( isset( $props['icon'] ) ) {
            $formats = Utilities::getIcon( $g, $params['iconsize'] );
            if ( $formats ) {
                $a['icon'] = $formats;
            }
        }
 
        if ( isset( $props['priority'] ) ) {
            $priority = MessageGroups::getPriority( $g );
            $a['priority'] = $priority ?: 'default';
        }
 
        if ( isset( $props['prioritylangs'] ) ) {
            $prioritylangs = $this->messageGroupMetadata->get( $groupId, 'prioritylangs' );
            $a['prioritylangs'] = $prioritylangs ? explode( ',', $prioritylangs ) : false;
        }
 
        if ( isset( $props['priorityforce'] ) ) {
            $a['priorityforce'] = ( $this->messageGroupMetadata->get( $groupId, 'priorityforce' ) === 'on' );
        }
 
        if ( isset( $props['workflowstates'] ) ) {
            $a['workflowstates'] = $this->getWorkflowStates( $g );
        }
 
        if ( isset( $props['sourcelanguage'] ) ) {
            $a['sourcelanguage'] = $g->getSourceLanguage();
        }
 
        if (
            isset( $props['subscription'] ) &&
            $this->groupSubscription->canUserSubscribeToGroup( $g, $this->getUser() )->isOK()
        ) {
            $a['subscription'] = array_key_exists( $groupId, $subscriptions );
        }
 
        $this->hookRunner->onTranslateProcessAPIMessageGroupsProperties( $a, $props, $params, $g );
 
        // Depth only applies to tree format
        if ( $depth >= $params['depth'] && $params['format'] === 'tree' ) {
            $a['groupcount'] = count( $subgroups );
 
            // Prevent going further down in the three
            return $a;
        }
 
        // Always empty array for flat format, only sometimes for tree format
        if ( $subgroups !== [] ) {
            foreach ( $subgroups as $sg ) {
                $a['groups'][] = $this->formatGroup( $sg, $props, $subscriptions, $depth + 1 );
            }
            $result = $this->getResult();
            $result->setIndexedTagName( $a['groups'], 'group' );
        }
 
        return $a;
    }
 
    private function getWorkflowStates( MessageGroup $group ) {
        if ( MessageGroups::isDynamic( $group ) ) {
            return false;
        }
 
        $stateConfig = $group->getMessageGroupStates()->getStates();
 
        if ( !is_array( $stateConfig ) || $stateConfig === [] ) {
            return false;
        }
 
        $user = $this->getUser();
 
        foreach ( $stateConfig as $state => $config ) {
            if ( is_array( $config ) ) {
                // Check if user is allowed to change states generally
                $allowed = $user->isAllowed( 'translate-groupreview' );
                // Check further restrictions
                if ( $allowed && isset( $config['right'] ) ) {
                    $allowed = $user->isAllowed( $config['right'] );
                }
 
                if ( $allowed ) {
                    $stateConfig[$state]['canchange'] = 1;
                }
 
                $stateConfig[$state]['name'] =
                    $this->msg( "translate-workflow-state-$state" )->text();
            }
        }
 
        return $stateConfig;
    }
 
    protected function getAllowedParams(): array {
        $allowedParams = [
            'depth' => [
                ParamValidator::PARAM_TYPE => 'integer',
                ParamValidator::PARAM_DEFAULT => 100,
            ],
            'filter' => [
                ParamValidator::PARAM_TYPE => 'string',
                ParamValidator::PARAM_DEFAULT => '',
                ParamValidator::PARAM_ISMULTI => true,
            ],
            'format' => [
                ParamValidator::PARAM_TYPE => [ 'flat', 'tree' ],
                ParamValidator::PARAM_DEFAULT => 'flat',
            ],
            'iconsize' => [
                ParamValidator::PARAM_TYPE => 'integer',
                ParamValidator::PARAM_DEFAULT => 64,
            ],
            'prop' => [
                ParamValidator::PARAM_TYPE => array_keys( $this->getPropertyList() ),
                ParamValidator::PARAM_DEFAULT => 'id|label|description|class|exists',
                ParamValidator::PARAM_ISMULTI => true,
                ApiBase::PARAM_HELP_MSG_PER_VALUE => [],
            ],
            'root' => [
                ParamValidator::PARAM_TYPE => 'string',
                ParamValidator::PARAM_DEFAULT => '',
            ],
            'languageFilter' => [
                ParamValidator::PARAM_TYPE => 'string',
                ParamValidator::PARAM_DEFAULT => '',
            ]
        ];
 
        return $allowedParams;
    }
 
    private function getPropertyList(): array {
        $properties = array_flip( [
            'id',
            'label',
            'description',
            'class',
            'namespace',
            'exists',
            'icon',
            'priority',
            'prioritylangs',
            'priorityforce',
            'workflowstates',
            'sourcelanguage',
            'subscription'
        ] );
 
        return $properties;
    }
 
    protected function getExamplesMessages(): array {
        return [
            'action=query&meta=messagegroups' => 'apihelp-query+messagegroups-example-1',
        ];
    }
}