ApiQueryUserContribs.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Api;
 
use MediaWiki\ChangeTags\ChangeTagsStore;
use MediaWiki\CommentFormatter\CommentFormatter;
use MediaWiki\CommentStore\CommentStore;
use MediaWiki\MainConfigNames;
use MediaWiki\ParamValidator\TypeDef\UserDef;
use MediaWiki\RecentChanges\RecentChange;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Storage\NameTableAccessException;
use MediaWiki\Storage\NameTableStore;
use MediaWiki\Title\Title;
use MediaWiki\User\ActorMigration;
use MediaWiki\User\ExternalUserNames;
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserIdentityLookup;
use MediaWiki\User\UserIdentityValue;
use MediaWiki\User\UserNameUtils;
use stdClass;
use Wikimedia\IPUtils;
use Wikimedia\ParamValidator\ParamValidator;
use Wikimedia\ParamValidator\TypeDef\IntegerDef;
use Wikimedia\Rdbms\SelectQueryBuilder;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class ApiQueryUserContribs extends ApiQueryBase {
 
    public function __construct(
        ApiQuery $query,
        string $moduleName,
        private readonly CommentStore $commentStore,
        private readonly UserIdentityLookup $userIdentityLookup,
        private readonly UserNameUtils $userNameUtils,
        private readonly RevisionStore $revisionStore,
        private readonly NameTableStore $changeTagDefStore,
        private readonly ChangeTagsStore $changeTagsStore,
        private readonly ActorMigration $actorMigration,
        private readonly CommentFormatter $commentFormatter,
    ) {
        parent::__construct( $query, $moduleName, 'uc' );
    }
 
    private array $params;
    private bool $multiUserMode;
    private string $orderBy;
    private array $parentLens;
 
    private array $prop = [];
 
    public function execute() {
        // Parse some parameters
        $this->params = $this->extractRequestParams();
 
        $this->prop = array_fill_keys( $this->params['prop'], true );
 
        $dbSecondary = $this->getDB(); // any random replica DB
 
        $sort = ( $this->params['dir'] == 'newer' ?
            SelectQueryBuilder::SORT_ASC : SelectQueryBuilder::SORT_DESC );
        $op = ( $this->params['dir'] == 'older' ? '<=' : '>=' );
 
        // Create an Iterator that produces the UserIdentity objects we need, depending
        // on which of the 'userprefix', 'userids', 'iprange', or 'user' params
        // was specified.
        $this->requireOnlyOneParameter( $this->params, 'userprefix', 'userids', 'iprange', 'user' );
        if ( isset( $this->params['userprefix'] ) ) {
            $this->multiUserMode = true;
            $this->orderBy = 'name';
            $fname = __METHOD__;
 
            // Because 'userprefix' might produce a huge number of users (e.g.
            // a wiki with users "Test00000001" to "Test99999999"), use a
            // generator with batched lookup and continuation.
            $userIter = call_user_func( function () use ( $dbSecondary, $sort, $op, $fname ) {
                $fromName = false;
                if ( $this->params['continue'] !== null ) {
                    $continue = $this->parseContinueParamOrDie( $this->params['continue'],
                        [ 'string', 'string', 'string', 'int' ] );
                    $this->dieContinueUsageIf( $continue[0] !== 'name' );
                    $fromName = $continue[1];
                }
 
                $limit = 501;
                do {
                    $usersBatch = $this->userIdentityLookup
                        ->newSelectQueryBuilder()
                        ->caller( $fname )
                        ->limit( $limit )
                        ->whereUserNamePrefix( $this->params['userprefix'] )
                        ->where( $fromName !== false
                            ? $dbSecondary->buildComparison( $op, [ 'actor_name' => $fromName ] )
                            : [] )
                        ->orderByName( $sort )
                        ->fetchUserIdentities();
 
                    $count = 0;
                    $fromName = false;
                    foreach ( $usersBatch as $user ) {
                        if ( ++$count >= $limit ) {
                            $fromName = $user->getName();
                            break;
                        }
                        yield $user;
                    }
                } while ( $fromName !== false );
            } );
            // Do the actual sorting client-side, because otherwise
            // prepareQuery might try to sort by actor and confuse everything.
            $batchSize = 1;
        } elseif ( isset( $this->params['userids'] ) ) {
            if ( $this->params['userids'] === [] ) {
                $encParamName = $this->encodeParamName( 'userids' );
                $this->dieWithError( [ 'apierror-paramempty', $encParamName ], "paramempty_$encParamName" );
            }
 
            $ids = [];
            foreach ( $this->params['userids'] as $uid ) {
                if ( $uid <= 0 ) {
                    $this->dieWithError( [ 'apierror-invaliduserid', $uid ], 'invaliduserid' );
                }
                $ids[] = $uid;
            }
 
            $this->orderBy = 'actor';
            $this->multiUserMode = count( $ids ) > 1;
 
            $fromId = false;
            if ( $this->multiUserMode && $this->params['continue'] !== null ) {
                $continue = $this->parseContinueParamOrDie( $this->params['continue'],
                    [ 'string', 'int', 'string', 'int' ] );
                $this->dieContinueUsageIf( $continue[0] !== 'actor' );
                $fromId = $continue[1];
            }
 
            $userIter = $this->userIdentityLookup
                ->newSelectQueryBuilder()
                ->caller( __METHOD__ )
                ->whereUserIds( $ids )
                ->orderByUserId( $sort )
                ->where( $fromId ? $dbSecondary->buildComparison( $op, [ 'actor_id' => $fromId ] ) : [] )
                ->fetchUserIdentities();
            $batchSize = count( $ids );
        } elseif ( isset( $this->params['iprange'] ) ) {
            // Make sure it is a valid range and within the CIDR limit
            $ipRange = $this->params['iprange'];
            $contribsCIDRLimit = $this->getConfig()->get( MainConfigNames::RangeContributionsCIDRLimit );
            if ( IPUtils::isIPv4( $ipRange ) ) {
                $type = 'IPv4';
                $cidrLimit = $contribsCIDRLimit['IPv4'];
            } elseif ( IPUtils::isIPv6( $ipRange ) ) {
                $type = 'IPv6';
                $cidrLimit = $contribsCIDRLimit['IPv6'];
            } else {
                $this->dieWithError( [ 'apierror-invalidiprange', $ipRange ], 'invalidiprange' );
            }
            $range = IPUtils::parseCIDR( $ipRange )[1];
            if ( $range === false ) {
                $this->dieWithError( [ 'apierror-invalidiprange', $ipRange ], 'invalidiprange' );
            } elseif ( $range < $cidrLimit ) {
                $this->dieWithError( [ 'apierror-cidrtoobroad', $type, $cidrLimit ] );
            }
 
            $this->multiUserMode = true;
            $this->orderBy = 'name';
            $fname = __METHOD__;
 
            // Because 'iprange' might produce a huge number of ips, use a
            // generator with batched lookup and continuation.
            $userIter = call_user_func( function () use ( $dbSecondary, $sort, $op, $fname, $ipRange ) {
                [ $start, $end ] = IPUtils::parseRange( $ipRange );
                if ( $this->params['continue'] !== null ) {
                    $continue = $this->parseContinueParamOrDie( $this->params['continue'],
                        [ 'string', 'string', 'string', 'int' ] );
                    $this->dieContinueUsageIf( $continue[0] !== 'name' );
                    $fromName = $continue[1];
                    $fromIPHex = IPUtils::toHex( $fromName );
                    $this->dieContinueUsageIf( $fromIPHex === false );
                    if ( $op == '<=' ) {
                        $end = $fromIPHex;
                    } else {
                        $start = $fromIPHex;
                    }
                }
 
                $limit = 501;
 
                do {
                    $res = $dbSecondary->newSelectQueryBuilder()
                        ->select( 'ipc_hex' )
                        ->from( 'ip_changes' )
                        ->where( $dbSecondary->expr( 'ipc_hex', '>=', $start )->and( 'ipc_hex', '<=', $end ) )
                        ->groupBy( 'ipc_hex' )
                        ->orderBy( 'ipc_hex', $sort )
                        ->limit( $limit )
                        ->caller( $fname )
                        ->fetchResultSet();
 
                    $count = 0;
                    $fromName = false;
                    foreach ( $res as $row ) {
                        $ipAddr = IPUtils::formatHex( $row->ipc_hex );
                        if ( ++$count >= $limit ) {
                            $fromName = $ipAddr;
                            break;
                        }
                        yield UserIdentityValue::newAnonymous( $ipAddr );
                    }
                } while ( $fromName !== false );
            } );
            // Do the actual sorting client-side, because otherwise
            // prepareQuery might try to sort by actor and confuse everything.
            $batchSize = 1;
        } else {
            $names = [];
            if ( !count( $this->params['user'] ) ) {
                $encParamName = $this->encodeParamName( 'user' );
                $this->dieWithError(
                    [ 'apierror-paramempty', $encParamName ], "paramempty_$encParamName"
                );
            }
            foreach ( $this->params['user'] as $u ) {
                if ( $u === '' ) {
                    $encParamName = $this->encodeParamName( 'user' );
                    $this->dieWithError(
                        [ 'apierror-paramempty', $encParamName ], "paramempty_$encParamName"
                    );
                }
 
                if ( $this->userNameUtils->isIP( $u ) || ExternalUserNames::isExternal( $u ) ) {
                    $names[$u] = null;
                } else {
                    $name = $this->userNameUtils->getCanonical( $u );
                    if ( $name === false ) {
                        $encParamName = $this->encodeParamName( 'user' );
                        $this->dieWithError(
                            [ 'apierror-baduser', $encParamName, wfEscapeWikiText( $u ) ], "baduser_$encParamName"
                        );
                    }
                    $names[$name] = null;
                }
            }
 
            $this->orderBy = 'actor';
            $this->multiUserMode = count( $names ) > 1;
 
            $fromId = false;
            if ( $this->multiUserMode && $this->params['continue'] !== null ) {
                $continue = $this->parseContinueParamOrDie( $this->params['continue'],
                    [ 'string', 'int', 'string', 'int' ] );
                $this->dieContinueUsageIf( $continue[0] !== 'actor' );
                $fromId = $continue[1];
            }
 
            $userIter = $this->userIdentityLookup
                ->newSelectQueryBuilder()
                ->caller( __METHOD__ )
                ->whereUserNames( array_keys( $names ) )
                ->orderByName( $sort )
                ->where( $fromId ? $dbSecondary->buildComparison( $op, [ 'actor_id' => $fromId ] ) : [] )
                ->fetchUserIdentities();
            $batchSize = count( $names );
        }
 
        $count = 0;
        $limit = $this->params['limit'];
        $userIter->rewind();
        while ( $userIter->valid() ) {
            $users = [];
            while ( count( $users ) < $batchSize && $userIter->valid() ) {
                $users[] = $userIter->current();
                $userIter->next();
            }
 
            $hookData = [];
            $this->prepareQuery( $users, $limit - $count );
            $res = $this->select( __METHOD__, [], $hookData );
 
            if ( isset( $this->prop['title'] ) ) {
                $this->executeGenderCacheFromResultWrapper( $res, __METHOD__ );
            }
 
            if ( isset( $this->prop['sizediff'] ) ) {
                $revIds = [];
                foreach ( $res as $row ) {
                    if ( $row->rev_parent_id ) {
                        $revIds[] = (int)$row->rev_parent_id;
                    }
                }
                $this->parentLens = $this->revisionStore->getRevisionSizes( $revIds );
            }
 
            foreach ( $res as $row ) {
                if ( ++$count > $limit ) {
                    // We've reached the one extra which shows that there are
                    // additional pages to be had. Stop here...
                    $this->setContinueEnumParameter( 'continue', $this->continueStr( $row ) );
                    break 2;
                }
 
                $vals = $this->extractRowInfo( $row );
                $fit = $this->processRow( $row, $vals, $hookData ) &&
                    $this->getResult()->addValue( [ 'query', $this->getModuleName() ], null, $vals );
                if ( !$fit ) {
                    $this->setContinueEnumParameter( 'continue', $this->continueStr( $row ) );
                    break 2;
                }
            }
        }
 
        $this->getResult()->addIndexedTagName( [ 'query', $this->getModuleName() ], 'item' );
    }
 
    private function prepareQuery( array $users, $limit ) {
        $this->resetQueryParams();
        $db = $this->getDB();
 
        $queryBuilder = $this->revisionStore->newSelectQueryBuilder( $db )->joinComment()->joinPage();
        $revWhere = $this->actorMigration->getWhere( $db, 'rev_user', $users );
 
        $orderUserField = 'rev_actor';
        $userField = $this->orderBy === 'actor' ? 'rev_actor' : 'actor_name';
        $tsField = 'rev_timestamp';
        $idField = 'rev_id';
 
        $this->getQueryBuilder()->merge( $queryBuilder );
        $this->addWhere( $revWhere['conds'] );
        // Force the appropriate index to avoid bad query plans (T307815 and T307295)
        if ( isset( $revWhere['orconds']['newactor'] ) ) {
            $this->addOption( 'USE INDEX', [ 'revision' => 'rev_actor_timestamp' ] );
        }
 
        // Handle continue parameter
        if ( $this->params['continue'] !== null ) {
            if ( $this->multiUserMode ) {
                $continue = $this->parseContinueParamOrDie( $this->params['continue'],
                    [ 'string', 'string', 'timestamp', 'int' ] );
                $modeFlag = array_shift( $continue );
                $this->dieContinueUsageIf( $modeFlag !== $this->orderBy );
                $encUser = array_shift( $continue );
            } else {
                $continue = $this->parseContinueParamOrDie( $this->params['continue'],
                    [ 'timestamp', 'int' ] );
            }
            $op = ( $this->params['dir'] == 'older' ? '<=' : '>=' );
            if ( $this->multiUserMode ) {
                $this->addWhere( $db->buildComparison( $op, [
                    // @phan-suppress-next-line PhanPossiblyUndeclaredVariable encUser is set when used
                    $userField => $encUser,
                    $tsField => $db->timestamp( $continue[0] ),
                    $idField => $continue[1],
                ] ) );
            } else {
                $this->addWhere( $db->buildComparison( $op, [
                    $tsField => $db->timestamp( $continue[0] ),
                    $idField => $continue[1],
                ] ) );
            }
        }
 
        // Don't include any revisions where we're not supposed to be able to
        // see the username.
        if ( !$this->getAuthority()->isAllowed( 'deletedhistory' ) ) {
            $bitmask = RevisionRecord::DELETED_USER;
        } elseif ( !$this->getAuthority()->isAllowedAny( 'suppressrevision', 'viewsuppressed' ) ) {
            $bitmask = RevisionRecord::DELETED_USER | RevisionRecord::DELETED_RESTRICTED;
        } else {
            $bitmask = 0;
        }
        if ( $bitmask ) {
            $this->addWhere( $db->bitAnd( 'rev_deleted', $bitmask ) . " != $bitmask" );
        }
 
        // Add the user field to ORDER BY if there are multiple users
        if ( count( $users ) > 1 ) {
            $this->addWhereRange( $orderUserField, $this->params['dir'], null, null );
        }
 
        // Then timestamp
        $this->addTimestampWhereRange( $tsField,
            $this->params['dir'], $this->params['start'], $this->params['end'] );
 
        // Then rev_id for a total ordering
        $this->addWhereRange( $idField, $this->params['dir'], null, null );
 
        $this->addWhereFld( 'page_namespace', $this->params['namespace'] );
 
        $show = $this->params['show'];
        if ( $this->params['toponly'] ) { // deprecated/old param
            $show[] = 'top';
        }
        if ( $show !== null ) {
            $show = array_fill_keys( $show, true );
 
            foreach ( $show as $key => $_ ) {
                // If there is a negated and non-negated option the same time
                if ( str_starts_with( $key, '!' ) && isset( $show[substr( $key, 1 )] ) ) {
                    $this->dieWithError( 'apierror-show' );
                }
            }
            if ( isset( $show['autopatrolled'] ) && isset( $show['!patrolled'] ) ) {
                $this->dieWithError( 'apierror-show' );
            }
 
            $this->addWhereIf( [ 'rev_minor_edit' => 0 ], isset( $show['!minor'] ) );
            $this->addWhereIf( $db->expr( 'rev_minor_edit', '!=', 0 ), isset( $show['minor'] ) );
            $this->addWhereIf(
                [ 'rc_patrolled' => RecentChange::PRC_UNPATROLLED ],
                isset( $show['!patrolled'] )
            );
            $this->addWhereIf(
                $db->expr( 'rc_patrolled', '!=', RecentChange::PRC_UNPATROLLED ),
                isset( $show['patrolled'] )
            );
            $this->addWhereIf(
                $db->expr( 'rc_patrolled', '!=', RecentChange::PRC_AUTOPATROLLED ),
                isset( $show['!autopatrolled'] )
            );
            $this->addWhereIf(
                [ 'rc_patrolled' => RecentChange::PRC_AUTOPATROLLED ],
                isset( $show['autopatrolled'] )
            );
            $this->addWhereIf( $idField . ' != page_latest', isset( $show['!top'] ) );
            $this->addWhereIf( $idField . ' = page_latest', isset( $show['top'] ) );
            $this->addWhereIf( $db->expr( 'rev_parent_id', '!=', 0 ), isset( $show['!new'] ) );
            $this->addWhereIf( [ 'rev_parent_id' => 0 ], isset( $show['new'] ) );
        }
        $this->addOption( 'LIMIT', $limit + 1 );
 
        if ( isset( $show['patrolled'] ) || isset( $show['!patrolled'] ) ||
            isset( $show['autopatrolled'] ) || isset( $show['!autopatrolled'] ) ||
            isset( $this->prop['patrolled'] )
        ) {
            $user = $this->getUser();
            if ( !$user->useRCPatrol() && !$user->useNPPatrol() ) {
                $this->dieWithError( 'apierror-permissiondenied-patrolflag', 'permissiondenied' );
            }
 
            $isFilterset = isset( $show['patrolled'] ) || isset( $show['!patrolled'] ) ||
                isset( $show['autopatrolled'] ) || isset( $show['!autopatrolled'] );
            $this->addTables( 'recentchanges' );
            $this->addJoinConds( [ 'recentchanges' => [
                $isFilterset ? 'JOIN' : 'LEFT JOIN',
                [ 'rc_this_oldid = ' . $idField ]
            ] ] );
        }
 
        $this->addFieldsIf( 'rc_patrolled', isset( $this->prop['patrolled'] ) );
 
        if ( isset( $this->prop['tags'] ) ) {
            $this->addFields( [
                'ts_tags' => $this->changeTagsStore->makeTagSummarySubquery( 'revision' )
            ] );
        }
 
        if ( isset( $this->params['tag'] ) ) {
            $this->addTables( 'change_tag' );
            $this->addJoinConds(
                [ 'change_tag' => [ 'JOIN', [ $idField . ' = ct_rev_id' ] ] ]
            );
            try {
                $this->addWhereFld( 'ct_tag_id', $this->changeTagDefStore->getId( $this->params['tag'] ) );
            } catch ( NameTableAccessException ) {
                // Return nothing.
                $this->addWhere( '1=0' );
            }
        }
        $this->addOption(
            'MAX_EXECUTION_TIME',
            $this->getConfig()->get( MainConfigNames::MaxExecutionTimeForExpensiveQueries )
        );
    }
 
    private function extractRowInfo( $row ) {
        $vals = [];
        $anyHidden = false;
 
        if ( $row->rev_deleted & RevisionRecord::DELETED_TEXT ) {
            $vals['texthidden'] = true;
            $anyHidden = true;
        }
 
        // Any rows where we can't view the user were filtered out in the query.
        $vals['userid'] = (int)$row->rev_user;
        $vals['user'] = $row->rev_user_text;
        if ( $row->rev_deleted & RevisionRecord::DELETED_USER ) {
            $vals['userhidden'] = true;
            $anyHidden = true;
        }
        if ( $this->prop['ids'] ?? false ) {
            $vals['pageid'] = (int)$row->rev_page;
            $vals['revid'] = (int)$row->rev_id;
 
            if ( $row->rev_parent_id !== null ) {
                $vals['parentid'] = (int)$row->rev_parent_id;
            }
        }
 
        $title = Title::makeTitle( $row->page_namespace, $row->page_title );
 
        if ( isset( $this->prop['title'] ) ) {
            ApiQueryBase::addTitleInfo( $vals, $title );
        }
 
        if ( isset( $this->prop['timestamp'] ) ) {
            $vals['timestamp'] = wfTimestamp( TS::ISO_8601, $row->rev_timestamp );
        }
 
        if ( isset( $this->prop['flags'] ) ) {
            $vals['new'] = $row->rev_parent_id == 0 && $row->rev_parent_id !== null;
            $vals['minor'] = (bool)$row->rev_minor_edit;
            $vals['top'] = $row->page_latest == $row->rev_id;
        }
 
        if ( isset( $this->prop['comment'] ) || isset( $this->prop['parsedcomment'] ) ) {
            if ( $row->rev_deleted & RevisionRecord::DELETED_COMMENT ) {
                $vals['commenthidden'] = true;
                $anyHidden = true;
            }
 
            $userCanView = RevisionRecord::userCanBitfield(
                $row->rev_deleted,
                RevisionRecord::DELETED_COMMENT, $this->getAuthority()
            );
 
            if ( $userCanView ) {
                $comment = $this->commentStore->getComment( 'rev_comment', $row )->text;
                if ( isset( $this->prop['comment'] ) ) {
                    $vals['comment'] = $comment;
                }
 
                if ( isset( $this->prop['parsedcomment'] ) ) {
                    $vals['parsedcomment'] = $this->commentFormatter->format( $comment, $title );
                }
            }
        }
 
        if ( isset( $this->prop['patrolled'] ) ) {
            $vals['patrolled'] = $row->rc_patrolled != RecentChange::PRC_UNPATROLLED;
            $vals['autopatrolled'] = $row->rc_patrolled == RecentChange::PRC_AUTOPATROLLED;
        }
 
        if ( isset( $this->prop['size'] ) && $row->rev_len !== null ) {
            $vals['size'] = (int)$row->rev_len;
        }
 
        if ( isset( $this->prop['sizediff'] )
            && $row->rev_len !== null
            && $row->rev_parent_id !== null
        ) {
            $parentLen = $this->parentLens[$row->rev_parent_id] ?? 0;
            $vals['sizediff'] = (int)$row->rev_len - $parentLen;
        }
 
        if ( isset( $this->prop['tags'] ) ) {
            if ( $row->ts_tags ) {
                $tags = explode( ',', $row->ts_tags );
                ApiResult::setIndexedTagName( $tags, 'tag' );
                $vals['tags'] = $tags;
            } else {
                $vals['tags'] = [];
            }
        }
 
        if ( $anyHidden && ( $row->rev_deleted & RevisionRecord::DELETED_RESTRICTED ) ) {
            $vals['suppressed'] = true;
        }
 
        return $vals;
    }
 
    private function continueStr( \stdClass $row ): string {
        if ( $this->multiUserMode ) {
            switch ( $this->orderBy ) {
                case 'name':
                    return "name|$row->rev_user_text|$row->rev_timestamp|$row->rev_id";
                case 'actor':
                    return "actor|$row->rev_actor|$row->rev_timestamp|$row->rev_id";
            }
        } else {
            return "$row->rev_timestamp|$row->rev_id";
        }
    }
 
    public function getCacheMode( $params ) {
        // This module provides access to deleted revisions and patrol flags if
        // the requester is logged in
        return 'anon-public-user-private';
    }
 
    public function getAllowedParams() {
        return [
            'limit' => [
                ParamValidator::PARAM_DEFAULT => 10,
                ParamValidator::PARAM_TYPE => 'limit',
                IntegerDef::PARAM_MIN => 1,
                IntegerDef::PARAM_MAX => ApiBase::LIMIT_BIG1,
                IntegerDef::PARAM_MAX2 => ApiBase::LIMIT_BIG2
            ],
            'start' => [
                ParamValidator::PARAM_TYPE => 'timestamp'
            ],
            'end' => [
                ParamValidator::PARAM_TYPE => 'timestamp'
            ],
            'continue' => [
                ApiBase::PARAM_HELP_MSG => 'api-help-param-continue',
            ],
            'user' => [
                ParamValidator::PARAM_TYPE => 'user',
                UserDef::PARAM_ALLOWED_USER_TYPES => [ 'name', 'ip', 'temp', 'interwiki' ],
                ParamValidator::PARAM_ISMULTI => true
            ],
            'userids' => [
                ParamValidator::PARAM_TYPE => 'integer',
                ParamValidator::PARAM_ISMULTI => true
            ],
            'userprefix' => null,
            'iprange' => null,
            'dir' => [
                ParamValidator::PARAM_DEFAULT => 'older',
                ParamValidator::PARAM_TYPE => [
                    'newer',
                    'older'
                ],
                ApiBase::PARAM_HELP_MSG => 'api-help-param-direction',
                ApiBase::PARAM_HELP_MSG_PER_VALUE => [
                    'newer' => 'api-help-paramvalue-direction-newer',
                    'older' => 'api-help-paramvalue-direction-older',
                ],
            ],
            'namespace' => [
                ParamValidator::PARAM_ISMULTI => true,
                ParamValidator::PARAM_TYPE => 'namespace'
            ],
            'prop' => [
                ParamValidator::PARAM_ISMULTI => true,
                ParamValidator::PARAM_DEFAULT => 'ids|title|timestamp|comment|size|flags',
                ParamValidator::PARAM_TYPE => [
                    'ids',
                    'title',
                    'timestamp',
                    'comment',
                    'parsedcomment',
                    'size',
                    'sizediff',
                    'flags',
                    'patrolled',
                    'tags'
                ],
                ApiBase::PARAM_HELP_MSG_PER_VALUE => [],
            ],
            'show' => [
                ParamValidator::PARAM_ISMULTI => true,
                ParamValidator::PARAM_TYPE => [
                    'minor',
                    '!minor',
                    'patrolled',
                    '!patrolled',
                    'autopatrolled',
                    '!autopatrolled',
                    'top',
                    '!top',
                    'new',
                    '!new',
                ],
                ApiBase::PARAM_HELP_MSG => [
                    'apihelp-query+usercontribs-param-show',
                    $this->getConfig()->get( MainConfigNames::RCMaxAge )
                ],
            ],
            'tag' => null,
            'toponly' => [
                ParamValidator::PARAM_DEFAULT => false,
                ParamValidator::PARAM_DEPRECATED => true,
            ],
        ];
    }
 
    protected function getExamplesMessages() {
        return [
            'action=query&list=usercontribs&ucuser=Example'
                => 'apihelp-query+usercontribs-example-user',
            'action=query&list=usercontribs&ucuserprefix=192.0.2.'
                => 'apihelp-query+usercontribs-example-ipprefix',
        ];
    }
 
    public function getHelpUrls() {
        return 'https://www.mediawiki.org/wiki/Special:MyLanguage/API:Usercontribs';
    }
}
 
class_alias( ApiQueryUserContribs::class, 'ApiQueryUserContribs' );