ApiBase.php

Go to the documentation of this file.

<?php
abstract class ApiBase extends ContextSource {

    const PARAM_DFLT = 0;

    const PARAM_ISMULTI = 1;

    const PARAM_TYPE = 2;

    const PARAM_MAX = 3;

    const PARAM_MAX2 = 4;

    const PARAM_MIN = 5;

    const PARAM_ALLOW_DUPLICATES = 6;

    const PARAM_DEPRECATED = 7;

    const PARAM_REQUIRED = 8;

    const PARAM_RANGE_ENFORCE = 9;

    const PARAM_HELP_MSG = 10;

    const PARAM_HELP_MSG_APPEND = 11;

    const PARAM_HELP_MSG_INFO = 12;

    const PARAM_VALUE_LINKS = 13;

    const PARAM_HELP_MSG_PER_VALUE = 14;

    const PARAM_SUBMODULE_MAP = 15;

    const PARAM_SUBMODULE_PARAM_PREFIX = 16;

    const LIMIT_BIG1 = 500;
    const LIMIT_BIG2 = 5000;
    const LIMIT_SML1 = 50;
    const LIMIT_SML2 = 500;

    const GET_VALUES_FOR_HELP = 1;

    private static $extensionInfo = null;

    private $mMainModule;
    private $mModuleName, $mModulePrefix;
    private $mSlaveDB = null;
    private $mParamCache = [];
    private $mModuleSource = false;

    public function __construct( ApiMain $mainModule, $moduleName, $modulePrefix = '' ) {
        $this->mMainModule = $mainModule;
        $this->mModuleName = $moduleName;
        $this->mModulePrefix = $modulePrefix;

        if ( !$this->isMain() ) {
            $this->setContext( $mainModule->getContext() );
        }
    }

    /************************************************************************/
    abstract public function execute();

    public function getModuleManager() {
        return null;
    }

    public function getCustomPrinter() {
        return null;
    }

    protected function getExamplesMessages() {
        // Fall back to old non-localised method
        $ret = [];

        $examples = $this->getExamples();
        if ( $examples ) {
            if ( !is_array( $examples ) ) {
                $examples = [ $examples ];
            } elseif ( $examples && ( count( $examples ) & 1 ) == 0 &&
                array_keys( $examples ) === range( 0, count( $examples ) - 1 ) &&
                !preg_match( '/^\s*api\.php\?/', $examples[0] )
            ) {
                // Fix up the ugly "even numbered elements are description, odd
                // numbered elemts are the link" format (see doc for self::getExamples)
                $tmp = [];
                $examplesCount = count( $examples );
                for ( $i = 0; $i < $examplesCount; $i += 2 ) {
                    $tmp[$examples[$i + 1]] = $examples[$i];
                }
                $examples = $tmp;
            }

            foreach ( $examples as $k => $v ) {
                if ( is_numeric( $k ) ) {
                    $qs = $v;
                    $msg = '';
                } else {
                    $qs = $k;
                    $msg = self::escapeWikiText( $v );
                    if ( is_array( $msg ) ) {
                        $msg = implode( ' ', $msg );
                    }
                }

                $qs = preg_replace( '/^\s*api\.php\?/', '', $qs );
                $ret[$qs] = $this->msg( 'api-help-fallback-example', [ $msg ] );
            }
        }

        return $ret;
    }

    public function getHelpUrls() {
        return [];
    }

    protected function getAllowedParams( /* $flags = 0 */ ) {
        // int $flags is not declared because it causes "Strict standards"
        // warning. Most derived classes do not implement it.
        return [];
    }

    public function shouldCheckMaxlag() {
        return true;
    }

    public function isReadMode() {
        return true;
    }

    public function isWriteMode() {
        return false;
    }

    public function mustBePosted() {
        return $this->needsToken() !== false;
    }

    public function isDeprecated() {
        return false;
    }

    public function isInternal() {
        return false;
    }

    public function needsToken() {
        return false;
    }

    protected function getWebUITokenSalt( array $params ) {
        return null;
    }

    public function getConditionalRequestData( $condition ) {
        return null;
    }

    /************************************************************************/
    public function getModuleName() {
        return $this->mModuleName;
    }

    public function getModulePrefix() {
        return $this->mModulePrefix;
    }

    public function getMain() {
        return $this->mMainModule;
    }

    public function isMain() {
        return $this === $this->mMainModule;
    }

    public function getParent() {
        return $this->isMain() ? null : $this->getMain();
    }

    public function lacksSameOriginSecurity() {
        // Main module has this method overridden
        // Safety - avoid infinite loop:
        if ( $this->isMain() ) {
            ApiBase::dieDebug( __METHOD__, 'base method was called on main module.' );
        }

        return $this->getMain()->lacksSameOriginSecurity();
    }

    public function getModulePath() {
        if ( $this->isMain() ) {
            return 'main';
        } elseif ( $this->getParent()->isMain() ) {
            return $this->getModuleName();
        } else {
            return $this->getParent()->getModulePath() . '+' . $this->getModuleName();
        }
    }

    public function getModuleFromPath( $path ) {
        $module = $this->getMain();
        if ( $path === 'main' ) {
            return $module;
        }

        $parts = explode( '+', $path );
        if ( count( $parts ) === 1 ) {
            // In case the '+' was typed into URL, it resolves as a space
            $parts = explode( ' ', $path );
        }

        $count = count( $parts );
        for ( $i = 0; $i < $count; $i++ ) {
            $parent = $module;
            $manager = $parent->getModuleManager();
            if ( $manager === null ) {
                $errorPath = implode( '+', array_slice( $parts, 0, $i ) );
                $this->dieUsage( "The module \"$errorPath\" has no submodules", 'badmodule' );
            }
            $module = $manager->getModule( $parts[$i] );

            if ( $module === null ) {
                $errorPath = $i ? implode( '+', array_slice( $parts, 0, $i ) ) : $parent->getModuleName();
                $this->dieUsage(
                    "The module \"$errorPath\" does not have a submodule \"{$parts[$i]}\"",
                    'badmodule'
                );
            }
        }

        return $module;
    }

    public function getResult() {
        // Main module has getResult() method overridden
        // Safety - avoid infinite loop:
        if ( $this->isMain() ) {
            ApiBase::dieDebug( __METHOD__, 'base method was called on main module. ' );
        }

        return $this->getMain()->getResult();
    }

    public function getErrorFormatter() {
        // Main module has getErrorFormatter() method overridden
        // Safety - avoid infinite loop:
        if ( $this->isMain() ) {
            ApiBase::dieDebug( __METHOD__, 'base method was called on main module. ' );
        }

        return $this->getMain()->getErrorFormatter();
    }

    protected function getDB() {
        if ( !isset( $this->mSlaveDB ) ) {
            $this->mSlaveDB = wfGetDB( DB_REPLICA, 'api' );
        }

        return $this->mSlaveDB;
    }

    public function getContinuationManager() {
        // Main module has getContinuationManager() method overridden
        // Safety - avoid infinite loop:
        if ( $this->isMain() ) {
            ApiBase::dieDebug( __METHOD__, 'base method was called on main module. ' );
        }

        return $this->getMain()->getContinuationManager();
    }

    public function setContinuationManager( $manager ) {
        // Main module has setContinuationManager() method overridden
        // Safety - avoid infinite loop:
        if ( $this->isMain() ) {
            ApiBase::dieDebug( __METHOD__, 'base method was called on main module. ' );
        }

        $this->getMain()->setContinuationManager( $manager );
    }

    /************************************************************************/
    public function dynamicParameterDocumentation() {
        return null;
    }

    public function encodeParamName( $paramName ) {
        return $this->mModulePrefix . $paramName;
    }

    public function extractRequestParams( $parseLimit = true ) {
        // Cache parameters, for performance and to avoid bug 24564.
        if ( !isset( $this->mParamCache[$parseLimit] ) ) {
            $params = $this->getFinalParams();
            $results = [];

            if ( $params ) { // getFinalParams() can return false
                foreach ( $params as $paramName => $paramSettings ) {
                    $results[$paramName] = $this->getParameterFromSettings(
                        $paramName, $paramSettings, $parseLimit );
                }
            }
            $this->mParamCache[$parseLimit] = $results;
        }

        return $this->mParamCache[$parseLimit];
    }

    protected function getParameter( $paramName, $parseLimit = true ) {
        $paramSettings = $this->getFinalParams()[$paramName];

        return $this->getParameterFromSettings( $paramName, $paramSettings, $parseLimit );
    }

    public function requireOnlyOneParameter( $params, $required /*...*/ ) {
        $required = func_get_args();
        array_shift( $required );
        $p = $this->getModulePrefix();

        $intersection = array_intersect( array_keys( array_filter( $params,
            [ $this, 'parameterNotEmpty' ] ) ), $required );

        if ( count( $intersection ) > 1 ) {
            $this->dieUsage(
                "The parameters {$p}" . implode( ", {$p}", $intersection ) . ' can not be used together',
                'invalidparammix' );
        } elseif ( count( $intersection ) == 0 ) {
            $this->dieUsage(
                "One of the parameters {$p}" . implode( ", {$p}", $required ) . ' is required',
                'missingparam'
            );
        }
    }

    public function requireMaxOneParameter( $params, $required /*...*/ ) {
        $required = func_get_args();
        array_shift( $required );
        $p = $this->getModulePrefix();

        $intersection = array_intersect( array_keys( array_filter( $params,
            [ $this, 'parameterNotEmpty' ] ) ), $required );

        if ( count( $intersection ) > 1 ) {
            $this->dieUsage(
                "The parameters {$p}" . implode( ", {$p}", $intersection ) . ' can not be used together',
                'invalidparammix'
            );
        }
    }

    public function requireAtLeastOneParameter( $params, $required /*...*/ ) {
        $required = func_get_args();
        array_shift( $required );
        $p = $this->getModulePrefix();

        $intersection = array_intersect(
            array_keys( array_filter( $params, [ $this, 'parameterNotEmpty' ] ) ),
            $required
        );

        if ( count( $intersection ) == 0 ) {
            $this->dieUsage( "At least one of the parameters {$p}" .
                implode( ", {$p}", $required ) . ' is required', "{$p}missingparam" );
        }
    }

    public function requirePostedParameters( $params, $prefix = 'prefix' ) {
        // Skip if $wgDebugAPI is set or we're in internal mode
        if ( $this->getConfig()->get( 'DebugAPI' ) || $this->getMain()->isInternalMode() ) {
            return;
        }

        $queryValues = $this->getRequest()->getQueryValues();
        $badParams = [];
        foreach ( $params as $param ) {
            if ( $prefix !== 'noprefix' ) {
                $param = $this->encodeParamName( $param );
            }
            if ( array_key_exists( $param, $queryValues ) ) {
                $badParams[] = $param;
            }
        }

        if ( $badParams ) {
            $this->dieUsage(
                'The following parameters were found in the query string, but must be in the POST body: '
                    . join( ', ', $badParams ),
                'mustpostparams'
            );
        }
    }

    private function parameterNotEmpty( $x ) {
        return !is_null( $x ) && $x !== false;
    }

    public function getTitleOrPageId( $params, $load = false ) {
        $this->requireOnlyOneParameter( $params, 'title', 'pageid' );

        $pageObj = null;
        if ( isset( $params['title'] ) ) {
            $titleObj = Title::newFromText( $params['title'] );
            if ( !$titleObj || $titleObj->isExternal() ) {
                $this->dieUsageMsg( [ 'invalidtitle', $params['title'] ] );
            }
            if ( !$titleObj->canExist() ) {
                $this->dieUsage( "Namespace doesn't allow actual pages", 'pagecannotexist' );
            }
            $pageObj = WikiPage::factory( $titleObj );
            if ( $load !== false ) {
                $pageObj->loadPageData( $load );
            }
        } elseif ( isset( $params['pageid'] ) ) {
            if ( $load === false ) {
                $load = 'fromdb';
            }
            $pageObj = WikiPage::newFromID( $params['pageid'], $load );
            if ( !$pageObj ) {
                $this->dieUsageMsg( [ 'nosuchpageid', $params['pageid'] ] );
            }
        }

        return $pageObj;
    }

    protected function getWatchlistValue( $watchlist, $titleObj, $userOption = null ) {

        $userWatching = $this->getUser()->isWatched( $titleObj, User::IGNORE_USER_RIGHTS );

        switch ( $watchlist ) {
            case 'watch':
                return true;

            case 'unwatch':
                return false;

            case 'preferences':
                # If the user is already watching, don't bother checking
                if ( $userWatching ) {
                    return true;
                }
                # If no user option was passed, use watchdefault and watchcreations
                if ( is_null( $userOption ) ) {
                    return $this->getUser()->getBoolOption( 'watchdefault' ) ||
                        $this->getUser()->getBoolOption( 'watchcreations' ) && !$titleObj->exists();
                }

                # Watch the article based on the user preference
                return $this->getUser()->getBoolOption( $userOption );

            case 'nochange':
                return $userWatching;

            default:
                return $userWatching;
        }
    }

    protected function getParameterFromSettings( $paramName, $paramSettings, $parseLimit ) {
        // Some classes may decide to change parameter names
        $encParamName = $this->encodeParamName( $paramName );

        if ( !is_array( $paramSettings ) ) {
            $default = $paramSettings;
            $multi = false;
            $type = gettype( $paramSettings );
            $dupes = false;
            $deprecated = false;
            $required = false;
        } else {
            $default = isset( $paramSettings[self::PARAM_DFLT] )
                ? $paramSettings[self::PARAM_DFLT]
                : null;
            $multi = isset( $paramSettings[self::PARAM_ISMULTI] )
                ? $paramSettings[self::PARAM_ISMULTI]
                : false;
            $type = isset( $paramSettings[self::PARAM_TYPE] )
                ? $paramSettings[self::PARAM_TYPE]
                : null;
            $dupes = isset( $paramSettings[self::PARAM_ALLOW_DUPLICATES] )
                ? $paramSettings[self::PARAM_ALLOW_DUPLICATES]
                : false;
            $deprecated = isset( $paramSettings[self::PARAM_DEPRECATED] )
                ? $paramSettings[self::PARAM_DEPRECATED]
                : false;
            $required = isset( $paramSettings[self::PARAM_REQUIRED] )
                ? $paramSettings[self::PARAM_REQUIRED]
                : false;

            // When type is not given, and no choices, the type is the same as $default
            if ( !isset( $type ) ) {
                if ( isset( $default ) ) {
                    $type = gettype( $default );
                } else {
                    $type = 'NULL'; // allow everything
                }
            }
        }

        if ( $type == 'boolean' ) {
            if ( isset( $default ) && $default !== false ) {
                // Having a default value of anything other than 'false' is not allowed
                ApiBase::dieDebug(
                    __METHOD__,
                    "Boolean param $encParamName's default is set to '$default'. " .
                        'Boolean parameters must default to false.'
                );
            }

            $value = $this->getMain()->getCheck( $encParamName );
        } elseif ( $type == 'upload' ) {
            if ( isset( $default ) ) {
                // Having a default value is not allowed
                ApiBase::dieDebug(
                    __METHOD__,
                    "File upload param $encParamName's default is set to " .
                        "'$default'. File upload parameters may not have a default." );
            }
            if ( $multi ) {
                ApiBase::dieDebug( __METHOD__, "Multi-values not supported for $encParamName" );
            }
            $value = $this->getMain()->getUpload( $encParamName );
            if ( !$value->exists() ) {
                // This will get the value without trying to normalize it
                // (because trying to normalize a large binary file
                // accidentally uploaded as a field fails spectacularly)
                $value = $this->getMain()->getRequest()->unsetVal( $encParamName );
                if ( $value !== null ) {
                    $this->dieUsage(
                        "File upload param $encParamName is not a file upload; " .
                            'be sure to use multipart/form-data for your POST and include ' .
                            'a filename in the Content-Disposition header.',
                        "badupload_{$encParamName}"
                    );
                }
            }
        } else {
            $value = $this->getMain()->getVal( $encParamName, $default );

            if ( isset( $value ) && $type == 'namespace' ) {
                $type = MWNamespace::getValidNamespaces();
            }
            if ( isset( $value ) && $type == 'submodule' ) {
                if ( isset( $paramSettings[self::PARAM_SUBMODULE_MAP] ) ) {
                    $type = array_keys( $paramSettings[self::PARAM_SUBMODULE_MAP] );
                } else {
                    $type = $this->getModuleManager()->getNames( $paramName );
                }
            }

            $request = $this->getMain()->getRequest();
            $rawValue = $request->getRawVal( $encParamName );
            if ( $rawValue === null ) {
                $rawValue = $default;
            }

            // Preserve U+001F for self::parseMultiValue(), or error out if that won't be called
            if ( isset( $value ) && substr( $rawValue, 0, 1 ) === "\x1f" ) {
                if ( $multi ) {
                    // This loses the potential $wgContLang->checkTitleEncoding() transformation
                    // done by WebRequest for $_GET. Let's call that a feature.
                    $value = join( "\x1f", $request->normalizeUnicode( explode( "\x1f", $rawValue ) ) );
                } else {
                    $this->dieUsage(
                        "U+001F multi-value separation may only be used for multi-valued parameters.",
                        'badvalue_notmultivalue'
                    );
                }
            }

            // Check for NFC normalization, and warn
            if ( $rawValue !== $value ) {
                $this->handleParamNormalization( $paramName, $value, $rawValue );
            }
        }

        if ( isset( $value ) && ( $multi || is_array( $type ) ) ) {
            $value = $this->parseMultiValue(
                $encParamName,
                $value,
                $multi,
                is_array( $type ) ? $type : null
            );
        }

        // More validation only when choices were not given
        // choices were validated in parseMultiValue()
        if ( isset( $value ) ) {
            if ( !is_array( $type ) ) {
                switch ( $type ) {
                    case 'NULL': // nothing to do
                        break;
                    case 'string':
                    case 'text':
                    case 'password':
                        if ( $required && $value === '' ) {
                            $this->dieUsageMsg( [ 'missingparam', $paramName ] );
                        }
                        break;
                    case 'integer': // Force everything using intval() and optionally validate limits
                        $min = isset( $paramSettings[self::PARAM_MIN] ) ? $paramSettings[self::PARAM_MIN] : null;
                        $max = isset( $paramSettings[self::PARAM_MAX] ) ? $paramSettings[self::PARAM_MAX] : null;
                        $enforceLimits = isset( $paramSettings[self::PARAM_RANGE_ENFORCE] )
                            ? $paramSettings[self::PARAM_RANGE_ENFORCE] : false;

                        if ( is_array( $value ) ) {
                            $value = array_map( 'intval', $value );
                            if ( !is_null( $min ) || !is_null( $max ) ) {
                                foreach ( $value as &$v ) {
                                    $this->validateLimit( $paramName, $v, $min, $max, null, $enforceLimits );
                                }
                            }
                        } else {
                            $value = intval( $value );
                            if ( !is_null( $min ) || !is_null( $max ) ) {
                                $this->validateLimit( $paramName, $value, $min, $max, null, $enforceLimits );
                            }
                        }
                        break;
                    case 'limit':
                        if ( !$parseLimit ) {
                            // Don't do any validation whatsoever
                            break;
                        }
                        if ( !isset( $paramSettings[self::PARAM_MAX] )
                            || !isset( $paramSettings[self::PARAM_MAX2] )
                        ) {
                            ApiBase::dieDebug(
                                __METHOD__,
                                "MAX1 or MAX2 are not defined for the limit $encParamName"
                            );
                        }
                        if ( $multi ) {
                            ApiBase::dieDebug( __METHOD__, "Multi-values not supported for $encParamName" );
                        }
                        $min = isset( $paramSettings[self::PARAM_MIN] ) ? $paramSettings[self::PARAM_MIN] : 0;
                        if ( $value == 'max' ) {
                            $value = $this->getMain()->canApiHighLimits()
                                ? $paramSettings[self::PARAM_MAX2]
                                : $paramSettings[self::PARAM_MAX];
                            $this->getResult()->addParsedLimit( $this->getModuleName(), $value );
                        } else {
                            $value = intval( $value );
                            $this->validateLimit(
                                $paramName,
                                $value,
                                $min,
                                $paramSettings[self::PARAM_MAX],
                                $paramSettings[self::PARAM_MAX2]
                            );
                        }
                        break;
                    case 'boolean':
                        if ( $multi ) {
                            ApiBase::dieDebug( __METHOD__, "Multi-values not supported for $encParamName" );
                        }
                        break;
                    case 'timestamp':
                        if ( is_array( $value ) ) {
                            foreach ( $value as $key => $val ) {
                                $value[$key] = $this->validateTimestamp( $val, $encParamName );
                            }
                        } else {
                            $value = $this->validateTimestamp( $value, $encParamName );
                        }
                        break;
                    case 'user':
                        if ( is_array( $value ) ) {
                            foreach ( $value as $key => $val ) {
                                $value[$key] = $this->validateUser( $val, $encParamName );
                            }
                        } else {
                            $value = $this->validateUser( $value, $encParamName );
                        }
                        break;
                    case 'upload': // nothing to do
                        break;
                    case 'tags':
                        // If change tagging was requested, check that the tags are valid.
                        if ( !is_array( $value ) && !$multi ) {
                            $value = [ $value ];
                        }
                        $tagsStatus = ChangeTags::canAddTagsAccompanyingChange( $value );
                        if ( !$tagsStatus->isGood() ) {
                            $this->dieStatus( $tagsStatus );
                        }
                        break;
                    default:
                        ApiBase::dieDebug( __METHOD__, "Param $encParamName's type is unknown - $type" );
                }
            }

            // Throw out duplicates if requested
            if ( !$dupes && is_array( $value ) ) {
                $value = array_unique( $value );
            }

            // Set a warning if a deprecated parameter has been passed
            if ( $deprecated && $value !== false ) {
                $this->setWarning( "The $encParamName parameter has been deprecated." );

                $feature = $encParamName;
                $m = $this;
                while ( !$m->isMain() ) {
                    $p = $m->getParent();
                    $name = $m->getModuleName();
                    $param = $p->encodeParamName( $p->getModuleManager()->getModuleGroup( $name ) );
                    $feature = "{$param}={$name}&{$feature}";
                    $m = $p;
                }
                $this->logFeatureUsage( $feature );
            }
        } elseif ( $required ) {
            $this->dieUsageMsg( [ 'missingparam', $paramName ] );
        }

        return $value;
    }

    protected function handleParamNormalization( $paramName, $value, $rawValue ) {
        $encParamName = $this->encodeParamName( $paramName );
        $this->setWarning(
            "The value passed for '$encParamName' contains invalid or non-normalized data. "
            . 'Textual data should be valid, NFC-normalized Unicode without '
            . 'C0 control characters other than HT (\\t), LF (\\n), and CR (\\r).'
        );
    }

    protected function explodeMultiValue( $value, $limit ) {
        if ( substr( $value, 0, 1 ) === "\x1f" ) {
            $sep = "\x1f";
            $value = substr( $value, 1 );
        } else {
            $sep = '|';
        }

        return explode( $sep, $value, $limit );
    }

    protected function parseMultiValue( $valueName, $value, $allowMultiple, $allowedValues ) {
        if ( ( trim( $value ) === '' || trim( $value ) === "\x1f" ) && $allowMultiple ) {
            return [];
        }

        // This is a bit awkward, but we want to avoid calling canApiHighLimits()
        // because it unstubs $wgUser
        $valuesList = $this->explodeMultiValue( $value, self::LIMIT_SML2 + 1 );
        $sizeLimit = count( $valuesList ) > self::LIMIT_SML1 && $this->mMainModule->canApiHighLimits()
            ? self::LIMIT_SML2
            : self::LIMIT_SML1;

        if ( self::truncateArray( $valuesList, $sizeLimit ) ) {
            $this->logFeatureUsage( "too-many-$valueName-for-{$this->getModulePath()}" );
            $this->setWarning( "Too many values supplied for parameter '$valueName': " .
                "the limit is $sizeLimit" );
        }

        if ( !$allowMultiple && count( $valuesList ) != 1 ) {
            // Bug 33482 - Allow entries with | in them for non-multiple values
            if ( in_array( $value, $allowedValues, true ) ) {
                return $value;
            }

            $possibleValues = is_array( $allowedValues )
                ? "of '" . implode( "', '", $allowedValues ) . "'"
                : '';
            $this->dieUsage(
                "Only one $possibleValues is allowed for parameter '$valueName'",
                "multival_$valueName"
            );
        }

        if ( is_array( $allowedValues ) ) {
            // Check for unknown values
            $unknown = array_diff( $valuesList, $allowedValues );
            if ( count( $unknown ) ) {
                if ( $allowMultiple ) {
                    $s = count( $unknown ) > 1 ? 's' : '';
                    $vals = implode( ', ', $unknown );
                    $this->setWarning( "Unrecognized value$s for parameter '$valueName': $vals" );
                } else {
                    $this->dieUsage(
                        "Unrecognized value for parameter '$valueName': {$valuesList[0]}",
                        "unknown_$valueName"
                    );
                }
            }
            // Now throw them out
            $valuesList = array_intersect( $valuesList, $allowedValues );
        }

        return $allowMultiple ? $valuesList : $valuesList[0];
    }

    protected function validateLimit( $paramName, &$value, $min, $max, $botMax = null,
        $enforceLimits = false
    ) {
        if ( !is_null( $min ) && $value < $min ) {
            $msg = $this->encodeParamName( $paramName ) . " may not be less than $min (set to $value)";
            $this->warnOrDie( $msg, $enforceLimits );
            $value = $min;
        }

        // Minimum is always validated, whereas maximum is checked only if not
        // running in internal call mode
        if ( $this->getMain()->isInternalMode() ) {
            return;
        }

        // Optimization: do not check user's bot status unless really needed -- skips db query
        // assumes $botMax >= $max
        if ( !is_null( $max ) && $value > $max ) {
            if ( !is_null( $botMax ) && $this->getMain()->canApiHighLimits() ) {
                if ( $value > $botMax ) {
                    $msg = $this->encodeParamName( $paramName ) .
                        " may not be over $botMax (set to $value) for bots or sysops";
                    $this->warnOrDie( $msg, $enforceLimits );
                    $value = $botMax;
                }
            } else {
                $msg = $this->encodeParamName( $paramName ) . " may not be over $max (set to $value) for users";
                $this->warnOrDie( $msg, $enforceLimits );
                $value = $max;
            }
        }
    }

    protected function validateTimestamp( $value, $encParamName ) {
        // Confusing synonyms for the current time accepted by wfTimestamp()
        // (wfTimestamp() also accepts various non-strings and the string of 14
        // ASCII NUL bytes, but those can't get here)
        if ( !$value ) {
            $this->logFeatureUsage( 'unclear-"now"-timestamp' );
            $this->setWarning(
                "Passing '$value' for timestamp parameter $encParamName has been deprecated." .
                    ' If for some reason you need to explicitly specify the current time without' .
                    ' calculating it client-side, use "now".'
            );
            return wfTimestamp( TS_MW );
        }

        // Explicit synonym for the current time
        if ( $value === 'now' ) {
            return wfTimestamp( TS_MW );
        }

        $unixTimestamp = wfTimestamp( TS_UNIX, $value );
        if ( $unixTimestamp === false ) {
            $this->dieUsage(
                "Invalid value '$value' for timestamp parameter $encParamName",
                "badtimestamp_{$encParamName}"
            );
        }

        return wfTimestamp( TS_MW, $unixTimestamp );
    }

    final public function validateToken( $token, array $params ) {
        $tokenType = $this->needsToken();
        $salts = ApiQueryTokens::getTokenTypeSalts();
        if ( !isset( $salts[$tokenType] ) ) {
            throw new MWException(
                "Module '{$this->getModuleName()}' tried to use token type '$tokenType' " .
                    'without registering it'
            );
        }

        $tokenObj = ApiQueryTokens::getToken(
            $this->getUser(), $this->getRequest()->getSession(), $salts[$tokenType]
        );
        if ( $tokenObj->match( $token ) ) {
            return true;
        }

        $webUiSalt = $this->getWebUITokenSalt( $params );
        if ( $webUiSalt !== null && $this->getUser()->matchEditToken(
            $token,
            $webUiSalt,
            $this->getRequest()
        ) ) {
            return true;
        }

        return false;
    }

    private function validateUser( $value, $encParamName ) {
        $title = Title::makeTitleSafe( NS_USER, $value );
        if ( $title === null || $title->hasFragment() ) {
            $this->dieUsage(
                "Invalid value '$value' for user parameter $encParamName",
                "baduser_{$encParamName}"
            );
        }

        return $title->getText();
    }

    /************************************************************************/
    protected function setWatch( $watch, $titleObj, $userOption = null ) {
        $value = $this->getWatchlistValue( $watch, $titleObj, $userOption );
        if ( $value === null ) {
            return;
        }

        WatchAction::doWatchOrUnwatch( $value, $titleObj, $this->getUser() );
    }

    public static function truncateArray( &$arr, $limit ) {
        $modified = false;
        while ( count( $arr ) > $limit ) {
            array_pop( $arr );
            $modified = true;
        }

        return $modified;
    }

    public function getWatchlistUser( $params ) {
        if ( !is_null( $params['owner'] ) && !is_null( $params['token'] ) ) {
            $user = User::newFromName( $params['owner'], false );
            if ( !( $user && $user->getId() ) ) {
                $this->dieUsage( 'Specified user does not exist', 'bad_wlowner' );
            }
            $token = $user->getOption( 'watchlisttoken' );
            if ( $token == '' || !hash_equals( $token, $params['token'] ) ) {
                $this->dieUsage(
                    'Incorrect watchlist token provided -- please set a correct token in Special:Preferences',
                    'bad_wltoken'
                );
            }
        } else {
            if ( !$this->getUser()->isLoggedIn() ) {
                $this->dieUsage( 'You must be logged-in to have a watchlist', 'notloggedin' );
            }
            if ( !$this->getUser()->isAllowed( 'viewmywatchlist' ) ) {
                $this->dieUsage( 'You don\'t have permission to view your watchlist', 'permissiondenied' );
            }
            $user = $this->getUser();
        }

        return $user;
    }

    private static function escapeWikiText( $v ) {
        if ( is_array( $v ) ) {
            return array_map( 'self::escapeWikiText', $v );
        } else {
            return strtr( $v, [
                '__' => '_&#95;', '{' => '&#123;', '}' => '&#125;',
                '[[Category:' => '[[:Category:',
                '[[File:' => '[[:File:', '[[Image:' => '[[:Image:',
            ] );
        }
    }

    public static function makeMessage( $msg, IContextSource $context, array $params = null ) {
        if ( is_string( $msg ) ) {
            $msg = wfMessage( $msg );
        } elseif ( is_array( $msg ) ) {
            $msg = call_user_func_array( 'wfMessage', $msg );
        }
        if ( !$msg instanceof Message ) {
            return null;
        }

        $msg->setContext( $context );
        if ( $params ) {
            $msg->params( $params );
        }

        return $msg;
    }

    /************************************************************************/
    public function setWarning( $warning ) {
        $msg = new ApiRawMessage( $warning, 'warning' );
        $this->getErrorFormatter()->addWarning( $this->getModuleName(), $msg );
    }

    private function warnOrDie( $msg, $enforceLimits = false ) {
        if ( $enforceLimits ) {
            $this->dieUsage( $msg, 'integeroutofrange' );
        }

        $this->setWarning( $msg );
    }

    public function dieUsage( $description, $errorCode, $httpRespCode = 0, $extradata = null ) {
        throw new UsageException(
            $description,
            $this->encodeParamName( $errorCode ),
            $httpRespCode,
            $extradata
        );
    }

    public function dieBlocked( Block $block ) {
        // Die using the appropriate message depending on block type
        if ( $block->getType() == Block::TYPE_AUTO ) {
            $this->dieUsage(
                'Your IP address has been blocked automatically, because it was used by a blocked user',
                'autoblocked',
                0,
                [ 'blockinfo' => ApiQueryUserInfo::getBlockInfo( $block ) ]
            );
        } else {
            $this->dieUsage(
                'You have been blocked from editing',
                'blocked',
                0,
                [ 'blockinfo' => ApiQueryUserInfo::getBlockInfo( $block ) ]
            );
        }
    }

    public function getErrorFromStatus( $status, &$extraData = null ) {
        if ( $status->isGood() ) {
            throw new MWException( 'Successful status passed to ApiBase::dieStatus' );
        }

        $errors = $status->getErrorsByType( 'error' );
        if ( !$errors ) {
            // No errors? Assume the warnings should be treated as errors
            $errors = $status->getErrorsByType( 'warning' );
        }
        if ( !$errors ) {
            // Still no errors? Punt
            $errors = [ [ 'message' => 'unknownerror-nocode', 'params' => [] ] ];
        }

        // Cannot use dieUsageMsg() because extensions might return custom
        // error messages.
        if ( $errors[0]['message'] instanceof Message ) {
            $msg = $errors[0]['message'];
            if ( $msg instanceof IApiMessage ) {
                $extraData = $msg->getApiData();
                $code = $msg->getApiCode();
            } else {
                $code = $msg->getKey();
            }
        } else {
            $code = $errors[0]['message'];
            $msg = wfMessage( $code, $errors[0]['params'] );
        }
        if ( isset( ApiBase::$messageMap[$code] ) ) {
            // Translate message to code, for backwards compatibility
            $code = ApiBase::$messageMap[$code]['code'];
        }

        return [ $code, $msg->inLanguage( 'en' )->useDatabase( false )->plain() ];
    }

    public function dieStatus( $status ) {
        $extraData = null;
        list( $code, $msg ) = $this->getErrorFromStatus( $status, $extraData );
        $this->dieUsage( $msg, $code, 0, $extraData );
    }

    // @codingStandardsIgnoreStart Allow long lines. Cannot split these.
    public static $messageMap = [
        // This one MUST be present, or dieUsageMsg() will recurse infinitely
        'unknownerror' => [ 'code' => 'unknownerror', 'info' => "Unknown error: \"\$1\"" ],
        'unknownerror-nocode' => [ 'code' => 'unknownerror', 'info' => 'Unknown error' ],

        // Messages from Title::getUserPermissionsErrors()
        'ns-specialprotected' => [
            'code' => 'unsupportednamespace',
            'info' => "Pages in the Special namespace can't be edited"
        ],
        'protectedinterface' => [
            'code' => 'protectednamespace-interface',
            'info' => "You're not allowed to edit interface messages"
        ],
        'namespaceprotected' => [
            'code' => 'protectednamespace',
            'info' => "You're not allowed to edit pages in the \"\$1\" namespace"
        ],
        'customcssprotected' => [
            'code' => 'customcssprotected',
            'info' => "You're not allowed to edit custom CSS pages"
        ],
        'customjsprotected' => [
            'code' => 'customjsprotected',
            'info' => "You're not allowed to edit custom JavaScript pages"
        ],
        'cascadeprotected' => [
            'code' => 'cascadeprotected',
            'info' => "The page you're trying to edit is protected because it's included in a cascade-protected page"
        ],
        'protectedpagetext' => [
            'code' => 'protectedpage',
            'info' => "The \"\$1\" right is required to edit this page"
        ],
        'protect-cantedit' => [
            'code' => 'cantedit',
            'info' => "You can't protect this page because you can't edit it"
        ],
        'deleteprotected' => [
            'code' => 'cantedit',
            'info' => "You can't delete this page because it has been protected"
        ],
        'badaccess-group0' => [
            'code' => 'permissiondenied',
            'info' => 'Permission denied'
        ], // Generic permission denied message
        'badaccess-groups' => [
            'code' => 'permissiondenied',
            'info' => 'Permission denied'
        ],
        'titleprotected' => [
            'code' => 'protectedtitle',
            'info' => 'This title has been protected from creation'
        ],
        'nocreate-loggedin' => [
            'code' => 'cantcreate',
            'info' => "You don't have permission to create new pages"
        ],
        'nocreatetext' => [
            'code' => 'cantcreate-anon',
            'info' => "Anonymous users can't create new pages"
        ],
        'movenologintext' => [
            'code' => 'cantmove-anon',
            'info' => "Anonymous users can't move pages"
        ],
        'movenotallowed' => [
            'code' => 'cantmove',
            'info' => "You don't have permission to move pages"
        ],
        'confirmedittext' => [
            'code' => 'confirmemail',
            'info' => 'You must confirm your email address before you can edit'
        ],
        'blockedtext' => [
            'code' => 'blocked',
            'info' => 'You have been blocked from editing'
        ],
        'autoblockedtext' => [
            'code' => 'autoblocked',
            'info' => 'Your IP address has been blocked automatically, because it was used by a blocked user'
        ],

        // Miscellaneous interface messages
        'actionthrottledtext' => [
            'code' => 'ratelimited',
            'info' => "You've exceeded your rate limit. Please wait some time and try again"
        ],
        'alreadyrolled' => [
            'code' => 'alreadyrolled',
            'info' => 'The page you tried to rollback was already rolled back'
        ],
        'cantrollback' => [
            'code' => 'onlyauthor',
            'info' => 'The page you tried to rollback only has one author'
        ],
        'readonlytext' => [
            'code' => 'readonly',
            'info' => 'The wiki is currently in read-only mode'
        ],
        'sessionfailure' => [
            'code' => 'badtoken',
            'info' => 'Invalid token' ],
        'cannotdelete' => [
            'code' => 'cantdelete',
            'info' => "Couldn't delete \"\$1\". Maybe it was deleted already by someone else"
        ],
        'notanarticle' => [
            'code' => 'missingtitle',
            'info' => "The page you requested doesn't exist"
        ],
        'selfmove' => [ 'code' => 'selfmove', 'info' => "Can't move a page to itself"
        ],
        'immobile_namespace' => [
            'code' => 'immobilenamespace',
            'info' => 'You tried to move pages from or to a namespace that is protected from moving'
        ],
        'articleexists' => [
            'code' => 'articleexists',
            'info' => 'The destination article already exists and is not a redirect to the source article'
        ],
        'protectedpage' => [
            'code' => 'protectedpage',
            'info' => "You don't have permission to perform this move"
        ],
        'hookaborted' => [
            'code' => 'hookaborted',
            'info' => 'The modification you tried to make was aborted by an extension hook'
        ],
        'cantmove-titleprotected' => [
            'code' => 'protectedtitle',
            'info' => 'The destination article has been protected from creation'
        ],
        'imagenocrossnamespace' => [
            'code' => 'nonfilenamespace',
            'info' => "Can't move a file to a non-file namespace"
        ],
        'imagetypemismatch' => [
            'code' => 'filetypemismatch',
            'info' => "The new file extension doesn't match its type"
        ],
        // 'badarticleerror' => shouldn't happen
        // 'badtitletext' => shouldn't happen
        'ip_range_invalid' => [ 'code' => 'invalidrange', 'info' => 'Invalid IP range' ],
        'range_block_disabled' => [
            'code' => 'rangedisabled',
            'info' => 'Blocking IP ranges has been disabled'
        ],
        'nosuchusershort' => [
            'code' => 'nosuchuser',
            'info' => "The user you specified doesn't exist"
        ],
        'badipaddress' => [ 'code' => 'invalidip', 'info' => 'Invalid IP address specified' ],
        'ipb_expiry_invalid' => [ 'code' => 'invalidexpiry', 'info' => 'Invalid expiry time' ],
        'ipb_already_blocked' => [
            'code' => 'alreadyblocked',
            'info' => 'The user you tried to block was already blocked'
        ],
        'ipb_blocked_as_range' => [
            'code' => 'blockedasrange',
            'info' => "IP address \"\$1\" was blocked as part of range \"\$2\". You can't unblock the IP individually, but you can unblock the range as a whole."
        ],
        'ipb_cant_unblock' => [
            'code' => 'cantunblock',
            'info' => 'The block you specified was not found. It may have been unblocked already'
        ],
        'mailnologin' => [
            'code' => 'cantsend',
            'info' => 'You are not logged in, you do not have a confirmed email address, or you are not allowed to send email to other users, so you cannot send email'
        ],
        'ipbblocked' => [
            'code' => 'ipbblocked',
            'info' => 'You cannot block or unblock users while you are yourself blocked'
        ],
        'ipbnounblockself' => [
            'code' => 'ipbnounblockself',
            'info' => 'You are not allowed to unblock yourself'
        ],
        'usermaildisabled' => [
            'code' => 'usermaildisabled',
            'info' => 'User email has been disabled'
        ],
        'blockedemailuser' => [
            'code' => 'blockedfrommail',
            'info' => 'You have been blocked from sending email'
        ],
        'notarget' => [
            'code' => 'notarget',
            'info' => 'You have not specified a valid target for this action'
        ],
        'noemail' => [
            'code' => 'noemail',
            'info' => 'The user has not specified a valid email address, or has chosen not to receive email from other users'
        ],
        'rcpatroldisabled' => [
            'code' => 'patroldisabled',
            'info' => 'Patrolling is disabled on this wiki'
        ],
        'markedaspatrollederror-noautopatrol' => [
            'code' => 'noautopatrol',
            'info' => "You don't have permission to patrol your own changes"
        ],
        'delete-toobig' => [
            'code' => 'bigdelete',
            'info' => "You can't delete this page because it has more than \$1 revisions"
        ],
        'movenotallowedfile' => [
            'code' => 'cantmovefile',
            'info' => "You don't have permission to move files"
        ],
        'userrights-no-interwiki' => [
            'code' => 'nointerwikiuserrights',
            'info' => "You don't have permission to change user rights on other wikis"
        ],
        'userrights-nodatabase' => [
            'code' => 'nosuchdatabase',
            'info' => "Database \"\$1\" does not exist or is not local"
        ],
        'nouserspecified' => [ 'code' => 'invaliduser', 'info' => "Invalid username \"\$1\"" ],
        'noname' => [ 'code' => 'invaliduser', 'info' => "Invalid username \"\$1\"" ],
        'summaryrequired' => [ 'code' => 'summaryrequired', 'info' => 'Summary required' ],
        'import-rootpage-invalid' => [
            'code' => 'import-rootpage-invalid',
            'info' => 'Root page is an invalid title'
        ],
        'import-rootpage-nosubpage' => [
            'code' => 'import-rootpage-nosubpage',
            'info' => 'Namespace "$1" of the root page does not allow subpages'
        ],

        // API-specific messages
        'readrequired' => [
            'code' => 'readapidenied',
            'info' => 'You need read permission to use this module'
        ],
        'writedisabled' => [
            'code' => 'noapiwrite',
            'info' => "Editing of this wiki through the API is disabled. Make sure the \$wgEnableWriteAPI=true; statement is included in the wiki's LocalSettings.php file"
        ],
        'writerequired' => [
            'code' => 'writeapidenied',
            'info' => "You're not allowed to edit this wiki through the API"
        ],
        'missingparam' => [ 'code' => 'no$1', 'info' => "The \$1 parameter must be set" ],
        'invalidtitle' => [ 'code' => 'invalidtitle', 'info' => "Bad title \"\$1\"" ],
        'nosuchpageid' => [ 'code' => 'nosuchpageid', 'info' => "There is no page with ID \$1" ],
        'nosuchrevid' => [ 'code' => 'nosuchrevid', 'info' => "There is no revision with ID \$1" ],
        'nosuchuser' => [ 'code' => 'nosuchuser', 'info' => "User \"\$1\" doesn't exist" ],
        'invaliduser' => [ 'code' => 'invaliduser', 'info' => "Invalid username \"\$1\"" ],
        'invalidexpiry' => [ 'code' => 'invalidexpiry', 'info' => "Invalid expiry time \"\$1\"" ],
        'pastexpiry' => [ 'code' => 'pastexpiry', 'info' => "Expiry time \"\$1\" is in the past" ],
        'create-titleexists' => [
            'code' => 'create-titleexists',
            'info' => "Existing titles can't be protected with 'create'"
        ],
        'missingtitle-createonly' => [
            'code' => 'missingtitle-createonly',
            'info' => "Missing titles can only be protected with 'create'"
        ],
        'cantblock' => [ 'code' => 'cantblock',
            'info' => "You don't have permission to block users"
        ],
        'canthide' => [
            'code' => 'canthide',
            'info' => "You don't have permission to hide user names from the block log"
        ],
        'cantblock-email' => [
            'code' => 'cantblock-email',
            'info' => "You don't have permission to block users from sending email through the wiki"
        ],
        'unblock-notarget' => [
            'code' => 'notarget',
            'info' => 'Either the id or the user parameter must be set'
        ],
        'unblock-idanduser' => [
            'code' => 'idanduser',
            'info' => "The id and user parameters can't be used together"
        ],
        'cantunblock' => [
            'code' => 'permissiondenied',
            'info' => "You don't have permission to unblock users"
        ],
        'cannotundelete' => [
            'code' => 'cantundelete',
            'info' => "Couldn't undelete: the requested revisions may not exist, or may have been undeleted already"
        ],
        'permdenied-undelete' => [
            'code' => 'permissiondenied',
            'info' => "You don't have permission to restore deleted revisions"
        ],
        'createonly-exists' => [
            'code' => 'articleexists',
            'info' => 'The article you tried to create has been created already'
        ],
        'nocreate-missing' => [
            'code' => 'missingtitle',
            'info' => "The article you tried to edit doesn't exist"
        ],
        'cantchangecontentmodel' => [
            'code' => 'cantchangecontentmodel',
            'info' => "You don't have permission to change the content model of a page"
        ],
        'nosuchrcid' => [
            'code' => 'nosuchrcid',
            'info' => "There is no change with rcid \"\$1\""
        ],
        'nosuchlogid' => [
            'code' => 'nosuchlogid',
            'info' => "There is no log entry with ID \"\$1\""
        ],
        'protect-invalidaction' => [
            'code' => 'protect-invalidaction',
            'info' => "Invalid protection type \"\$1\""
        ],
        'protect-invalidlevel' => [
            'code' => 'protect-invalidlevel',
            'info' => "Invalid protection level \"\$1\""
        ],
        'toofewexpiries' => [
            'code' => 'toofewexpiries',
            'info' => "\$1 expiry timestamps were provided where \$2 were needed"
        ],
        'cantimport' => [
            'code' => 'cantimport',
            'info' => "You don't have permission to import pages"
        ],
        'cantimport-upload' => [
            'code' => 'cantimport-upload',
            'info' => "You don't have permission to import uploaded pages"
        ],
        'importnofile' => [ 'code' => 'nofile', 'info' => "You didn't upload a file" ],
        'importuploaderrorsize' => [
            'code' => 'filetoobig',
            'info' => 'The file you uploaded is bigger than the maximum upload size'
        ],
        'importuploaderrorpartial' => [
            'code' => 'partialupload',
            'info' => 'The file was only partially uploaded'
        ],
        'importuploaderrortemp' => [
            'code' => 'notempdir',
            'info' => 'The temporary upload directory is missing'
        ],
        'importcantopen' => [
            'code' => 'cantopenfile',
            'info' => "Couldn't open the uploaded file"
        ],
        'import-noarticle' => [
            'code' => 'badinterwiki',
            'info' => 'Invalid interwiki title specified'
        ],
        'importbadinterwiki' => [
            'code' => 'badinterwiki',
            'info' => 'Invalid interwiki title specified'
        ],
        'import-unknownerror' => [
            'code' => 'import-unknownerror',
            'info' => "Unknown error on import: \"\$1\""
        ],
        'cantoverwrite-sharedfile' => [
            'code' => 'cantoverwrite-sharedfile',
            'info' => 'The target file exists on a shared repository and you do not have permission to override it'
        ],
        'sharedfile-exists' => [
            'code' => 'fileexists-sharedrepo-perm',
            'info' => 'The target file exists on a shared repository. Use the ignorewarnings parameter to override it.'
        ],
        'mustbeposted' => [
            'code' => 'mustbeposted',
            'info' => "The \$1 module requires a POST request"
        ],
        'show' => [
            'code' => 'show',
            'info' => 'Incorrect parameter - mutually exclusive values may not be supplied'
        ],
        'specialpage-cantexecute' => [
            'code' => 'specialpage-cantexecute',
            'info' => "You don't have permission to view the results of this special page"
        ],
        'invalidoldimage' => [
            'code' => 'invalidoldimage',
            'info' => 'The oldimage parameter has invalid format'
        ],
        'nodeleteablefile' => [
            'code' => 'nodeleteablefile',
            'info' => 'No such old version of the file'
        ],
        'fileexists-forbidden' => [
            'code' => 'fileexists-forbidden',
            'info' => 'A file with name "$1" already exists, and cannot be overwritten.'
        ],
        'fileexists-shared-forbidden' => [
            'code' => 'fileexists-shared-forbidden',
            'info' => 'A file with name "$1" already exists in the shared file repository, and cannot be overwritten.'
        ],
        'filerevert-badversion' => [
            'code' => 'filerevert-badversion',
            'info' => 'There is no previous local version of this file with the provided timestamp.'
        ],

        // ApiEditPage messages
        'noimageredirect-anon' => [
            'code' => 'noimageredirect-anon',
            'info' => "Anonymous users can't create image redirects"
        ],
        'noimageredirect-logged' => [
            'code' => 'noimageredirect',
            'info' => "You don't have permission to create image redirects"
        ],
        'spamdetected' => [
            'code' => 'spamdetected',
            'info' => "Your edit was refused because it contained a spam fragment: \"\$1\""
        ],
        'contenttoobig' => [
            'code' => 'contenttoobig',
            'info' => "The content you supplied exceeds the article size limit of \$1 kilobytes"
        ],
        'noedit-anon' => [ 'code' => 'noedit-anon', 'info' => "Anonymous users can't edit pages" ],
        'noedit' => [ 'code' => 'noedit', 'info' => "You don't have permission to edit pages" ],
        'wasdeleted' => [
            'code' => 'pagedeleted',
            'info' => 'The page has been deleted since you fetched its timestamp'
        ],
        'blankpage' => [
            'code' => 'emptypage',
            'info' => 'Creating new, empty pages is not allowed'
        ],
        'editconflict' => [ 'code' => 'editconflict', 'info' => 'Edit conflict detected' ],
        'hashcheckfailed' => [ 'code' => 'badmd5', 'info' => 'The supplied MD5 hash was incorrect' ],
        'missingtext' => [
            'code' => 'notext',
            'info' => 'One of the text, appendtext, prependtext and undo parameters must be set'
        ],
        'emptynewsection' => [
            'code' => 'emptynewsection',
            'info' => 'Creating empty new sections is not possible.'
        ],
        'revwrongpage' => [
            'code' => 'revwrongpage',
            'info' => "r\$1 is not a revision of \"\$2\""
        ],
        'undo-failure' => [
            'code' => 'undofailure',
            'info' => 'Undo failed due to conflicting intermediate edits'
        ],
        'content-not-allowed-here' => [
            'code' => 'contentnotallowedhere',
            'info' => 'Content model "$1" is not allowed at title "$2"'
        ],

        // Messages from WikiPage::doEit(]
        'edit-hook-aborted' => [
            'code' => 'edit-hook-aborted',
            'info' => 'Your edit was aborted by an ArticleSave hook'
        ],
        'edit-gone-missing' => [
            'code' => 'edit-gone-missing',
            'info' => "The page you tried to edit doesn't seem to exist anymore"
        ],
        'edit-conflict' => [ 'code' => 'editconflict', 'info' => 'Edit conflict detected' ],
        'edit-already-exists' => [
            'code' => 'edit-already-exists',
            'info' => 'It seems the page you tried to create already exist'
        ],

        // uploadMsgs
        'invalid-file-key' => [ 'code' => 'invalid-file-key', 'info' => 'Not a valid file key' ],
        'nouploadmodule' => [ 'code' => 'nouploadmodule', 'info' => 'No upload module set' ],
        'uploaddisabled' => [
            'code' => 'uploaddisabled',
            'info' => 'Uploads are not enabled. Make sure $wgEnableUploads is set to true in LocalSettings.php and the PHP ini setting file_uploads is true'
        ],
        'copyuploaddisabled' => [
            'code' => 'copyuploaddisabled',
            'info' => 'Uploads by URL is not enabled. Make sure $wgAllowCopyUploads is set to true in LocalSettings.php.'
        ],
        'copyuploadbaddomain' => [
            'code' => 'copyuploadbaddomain',
            'info' => 'Uploads by URL are not allowed from this domain.'
        ],
        'copyuploadbadurl' => [
            'code' => 'copyuploadbadurl',
            'info' => 'Upload not allowed from this URL.'
        ],

        'filename-tooshort' => [
            'code' => 'filename-tooshort',
            'info' => 'The filename is too short'
        ],
        'filename-toolong' => [ 'code' => 'filename-toolong', 'info' => 'The filename is too long' ],
        'illegal-filename' => [
            'code' => 'illegal-filename',
            'info' => 'The filename is not allowed'
        ],
        'filetype-missing' => [
            'code' => 'filetype-missing',
            'info' => 'The file is missing an extension'
        ],

        'mustbeloggedin' => [ 'code' => 'mustbeloggedin', 'info' => 'You must be logged in to $1.' ]
    ];
    // @codingStandardsIgnoreEnd

    public function dieReadOnly() {
        $parsed = $this->parseMsg( [ 'readonlytext' ] );
        $this->dieUsage( $parsed['info'], $parsed['code'], /* http error */ 0,
            [ 'readonlyreason' => wfReadOnlyReason() ] );
    }

    public function dieUsageMsg( $error ) {
        # most of the time we send a 1 element, so we might as well send it as
        # a string and make this an array here.
        if ( is_string( $error ) ) {
            $error = [ $error ];
        }
        $parsed = $this->parseMsg( $error );
        $extraData = isset( $parsed['data'] ) ? $parsed['data'] : null;
        $this->dieUsage( $parsed['info'], $parsed['code'], 0, $extraData );
    }

    public function dieUsageMsgOrDebug( $error ) {
        if ( $this->getConfig()->get( 'DebugAPI' ) !== true ) {
            $this->dieUsageMsg( $error );
        }

        if ( is_string( $error ) ) {
            $error = [ $error ];
        }
        $parsed = $this->parseMsg( $error );
        $this->setWarning( '$wgDebugAPI: ' . $parsed['code'] . ' - ' . $parsed['info'] );
    }

    protected function dieContinueUsageIf( $condition ) {
        if ( $condition ) {
            $this->dieUsage(
                'Invalid continue param. You should pass the original value returned by the previous query',
                'badcontinue' );
        }
    }

    public function parseMsg( $error ) {
        // Check whether someone passed the whole array, instead of one element as
        // documented. This breaks if it's actually an array of fallback keys, but
        // that's long-standing misbehavior introduced in r87627 to incorrectly
        // fix T30797.
        if ( is_array( $error ) ) {
            $first = reset( $error );
            if ( is_array( $first ) ) {
                wfDebug( __METHOD__ . ' was passed an array of arrays. ' . wfGetAllCallers( 5 ) );
                $error = $first;
            }
        }

        $msg = Message::newFromSpecifier( $error );

        if ( $msg instanceof IApiMessage ) {
            return [
                'code' => $msg->getApiCode(),
                'info' => $msg->inLanguage( 'en' )->useDatabase( false )->text(),
                'data' => $msg->getApiData()
            ];
        }

        $key = $msg->getKey();
        if ( isset( self::$messageMap[$key] ) ) {
            $params = $msg->getParams();
            return [
                'code' => wfMsgReplaceArgs( self::$messageMap[$key]['code'], $params ),
                'info' => wfMsgReplaceArgs( self::$messageMap[$key]['info'], $params )
            ];
        }

        // If the key isn't present, throw an "unknown error"
        return $this->parseMsg( [ 'unknownerror', $key ] );
    }

    protected static function dieDebug( $method, $message ) {
        throw new MWException( "Internal error in $method: $message" );
    }

    public function logFeatureUsage( $feature ) {
        $request = $this->getRequest();
        $s = '"' . addslashes( $feature ) . '"' .
            ' "' . wfUrlencode( str_replace( ' ', '_', $this->getUser()->getName() ) ) . '"' .
            ' "' . $request->getIP() . '"' .
            ' "' . addslashes( $request->getHeader( 'Referer' ) ) . '"' .
            ' "' . addslashes( $this->getMain()->getUserAgent() ) . '"';
        wfDebugLog( 'api-feature-usage', $s, 'private' );
    }

    /************************************************************************/
    protected function getDescriptionMessage() {
        return "apihelp-{$this->getModulePath()}-description";
    }

    public function getFinalDescription() {
        $desc = $this->getDescription();
        Hooks::run( 'APIGetDescription', [ &$this, &$desc ] );
        $desc = self::escapeWikiText( $desc );
        if ( is_array( $desc ) ) {
            $desc = implode( "\n", $desc );
        } else {
            $desc = (string)$desc;
        }

        $msg = ApiBase::makeMessage( $this->getDescriptionMessage(), $this->getContext(), [
            $this->getModulePrefix(),
            $this->getModuleName(),
            $this->getModulePath(),
        ] );
        if ( !$msg->exists() ) {
            $msg = $this->msg( 'api-help-fallback-description', $desc );
        }
        $msgs = [ $msg ];

        Hooks::run( 'APIGetDescriptionMessages', [ $this, &$msgs ] );

        return $msgs;
    }

    public function getFinalParams( $flags = 0 ) {
        $params = $this->getAllowedParams( $flags );
        if ( !$params ) {
            $params = [];
        }

        if ( $this->needsToken() ) {
            $params['token'] = [
                ApiBase::PARAM_TYPE => 'string',
                ApiBase::PARAM_REQUIRED => true,
                ApiBase::PARAM_HELP_MSG => [
                    'api-help-param-token',
                    $this->needsToken(),
                ],
            ] + ( isset( $params['token'] ) ? $params['token'] : [] );
        }

        Hooks::run( 'APIGetAllowedParams', [ &$this, &$params, $flags ] );

        return $params;
    }

    public function getFinalParamDescription() {
        $prefix = $this->getModulePrefix();
        $name = $this->getModuleName();
        $path = $this->getModulePath();

        $desc = $this->getParamDescription();
        Hooks::run( 'APIGetParamDescription', [ &$this, &$desc ] );

        if ( !$desc ) {
            $desc = [];
        }
        $desc = self::escapeWikiText( $desc );

        $params = $this->getFinalParams( ApiBase::GET_VALUES_FOR_HELP );
        $msgs = [];
        foreach ( $params as $param => $settings ) {
            if ( !is_array( $settings ) ) {
                $settings = [];
            }

            $d = isset( $desc[$param] ) ? $desc[$param] : '';
            if ( is_array( $d ) ) {
                // Special handling for prop parameters
                $d = array_map( function ( $line ) {
                    if ( preg_match( '/^\s+(\S+)\s+-\s+(.+)$/', $line, $m ) ) {
                        $line = "\n;{$m[1]}:{$m[2]}";
                    }
                    return $line;
                }, $d );
                $d = implode( ' ', $d );
            }

            if ( isset( $settings[ApiBase::PARAM_HELP_MSG] ) ) {
                $msg = $settings[ApiBase::PARAM_HELP_MSG];
            } else {
                $msg = $this->msg( "apihelp-{$path}-param-{$param}" );
                if ( !$msg->exists() ) {
                    $msg = $this->msg( 'api-help-fallback-parameter', $d );
                }
            }
            $msg = ApiBase::makeMessage( $msg, $this->getContext(),
                [ $prefix, $param, $name, $path ] );
            if ( !$msg ) {
                self::dieDebug( __METHOD__,
                    'Value in ApiBase::PARAM_HELP_MSG is not valid' );
            }
            $msgs[$param] = [ $msg ];

            if ( isset( $settings[ApiBase::PARAM_HELP_MSG_PER_VALUE] ) ) {
                if ( !is_array( $settings[ApiBase::PARAM_HELP_MSG_PER_VALUE] ) ) {
                    self::dieDebug( __METHOD__,
                        'ApiBase::PARAM_HELP_MSG_PER_VALUE is not valid' );
                }
                if ( !is_array( $settings[ApiBase::PARAM_TYPE] ) ) {
                    self::dieDebug( __METHOD__,
                        'ApiBase::PARAM_HELP_MSG_PER_VALUE may only be used when ' .
                        'ApiBase::PARAM_TYPE is an array' );
                }

                $valueMsgs = $settings[ApiBase::PARAM_HELP_MSG_PER_VALUE];
                foreach ( $settings[ApiBase::PARAM_TYPE] as $value ) {
                    if ( isset( $valueMsgs[$value] ) ) {
                        $msg = $valueMsgs[$value];
                    } else {
                        $msg = "apihelp-{$path}-paramvalue-{$param}-{$value}";
                    }
                    $m = ApiBase::makeMessage( $msg, $this->getContext(),
                        [ $prefix, $param, $name, $path, $value ] );
                    if ( $m ) {
                        $m = new ApiHelpParamValueMessage(
                            $value,
                            [ $m->getKey(), 'api-help-param-no-description' ],
                            $m->getParams()
                        );
                        $msgs[$param][] = $m->setContext( $this->getContext() );
                    } else {
                        self::dieDebug( __METHOD__,
                            "Value in ApiBase::PARAM_HELP_MSG_PER_VALUE for $value is not valid" );
                    }
                }
            }

            if ( isset( $settings[ApiBase::PARAM_HELP_MSG_APPEND] ) ) {
                if ( !is_array( $settings[ApiBase::PARAM_HELP_MSG_APPEND] ) ) {
                    self::dieDebug( __METHOD__,
                        'Value for ApiBase::PARAM_HELP_MSG_APPEND is not an array' );
                }
                foreach ( $settings[ApiBase::PARAM_HELP_MSG_APPEND] as $m ) {
                    $m = ApiBase::makeMessage( $m, $this->getContext(),
                        [ $prefix, $param, $name, $path ] );
                    if ( $m ) {
                        $msgs[$param][] = $m;
                    } else {
                        self::dieDebug( __METHOD__,
                            'Value in ApiBase::PARAM_HELP_MSG_APPEND is not valid' );
                    }
                }
            }
        }

        Hooks::run( 'APIGetParamDescriptionMessages', [ $this, &$msgs ] );

        return $msgs;
    }

    protected function getHelpFlags() {
        $flags = [];

        if ( $this->isDeprecated() ) {
            $flags[] = 'deprecated';
        }
        if ( $this->isInternal() ) {
            $flags[] = 'internal';
        }
        if ( $this->isReadMode() ) {
            $flags[] = 'readrights';
        }
        if ( $this->isWriteMode() ) {
            $flags[] = 'writerights';
        }
        if ( $this->mustBePosted() ) {
            $flags[] = 'mustbeposted';
        }

        return $flags;
    }

    protected function getModuleSourceInfo() {
        global $IP;

        if ( $this->mModuleSource !== false ) {
            return $this->mModuleSource;
        }

        // First, try to find where the module comes from...
        $rClass = new ReflectionClass( $this );
        $path = $rClass->getFileName();
        if ( !$path ) {
            // No path known?
            $this->mModuleSource = null;
            return null;
        }
        $path = realpath( $path ) ?: $path;

        // Build map of extension directories to extension info
        if ( self::$extensionInfo === null ) {
            $extDir = $this->getConfig()->get( 'ExtensionDirectory' );
            self::$extensionInfo = [
                realpath( __DIR__ ) ?: __DIR__ => [
                    'path' => $IP,
                    'name' => 'MediaWiki',
                    'license-name' => 'GPL-2.0+',
                ],
                realpath( "$IP/extensions" ) ?: "$IP/extensions" => null,
                realpath( $extDir ) ?: $extDir => null,
            ];
            $keep = [
                'path' => null,
                'name' => null,
                'namemsg' => null,
                'license-name' => null,
            ];
            foreach ( $this->getConfig()->get( 'ExtensionCredits' ) as $group ) {
                foreach ( $group as $ext ) {
                    if ( !isset( $ext['path'] ) || !isset( $ext['name'] ) ) {
                        // This shouldn't happen, but does anyway.
                        continue;
                    }

                    $extpath = $ext['path'];
                    if ( !is_dir( $extpath ) ) {
                        $extpath = dirname( $extpath );
                    }
                    self::$extensionInfo[realpath( $extpath ) ?: $extpath] =
                        array_intersect_key( $ext, $keep );
                }
            }
            foreach ( ExtensionRegistry::getInstance()->getAllThings() as $ext ) {
                $extpath = $ext['path'];
                if ( !is_dir( $extpath ) ) {
                    $extpath = dirname( $extpath );
                }
                self::$extensionInfo[realpath( $extpath ) ?: $extpath] =
                    array_intersect_key( $ext, $keep );
            }
        }

        // Now traverse parent directories until we find a match or run out of
        // parents.
        do {
            if ( array_key_exists( $path, self::$extensionInfo ) ) {
                // Found it!
                $this->mModuleSource = self::$extensionInfo[$path];
                return $this->mModuleSource;
            }

            $oldpath = $path;
            $path = dirname( $path );
        } while ( $path !== $oldpath );

        // No idea what extension this might be.
        $this->mModuleSource = null;
        return null;
    }

    public function modifyHelp( array &$help, array $options, array &$tocData ) {
    }

    /************************************************************************/
    protected function getDescription() {
        return false;
    }

    protected function getParamDescription() {
        return [];
    }

    protected function getExamples() {
        return false;
    }

    public function getModuleProfileName( $db = false ) {
        wfDeprecated( __METHOD__, '1.25' );
        return '';
    }

    public function profileIn() {
        // No wfDeprecated() yet because extensions call this and might need to
        // keep doing so for BC.
    }

    public function profileOut() {
        // No wfDeprecated() yet because extensions call this and might need to
        // keep doing so for BC.
    }

    public function safeProfileOut() {
        wfDeprecated( __METHOD__, '1.25' );
    }

    public function getProfileTime() {
        wfDeprecated( __METHOD__, '1.25' );
        return 0;
    }

    public function profileDBIn() {
        wfDeprecated( __METHOD__, '1.25' );
    }

    public function profileDBOut() {
        wfDeprecated( __METHOD__, '1.25' );
    }

    public function getProfileDBTime() {
        wfDeprecated( __METHOD__, '1.25' );
        return 0;
    }

    protected function useTransactionalTimeLimit() {
        if ( $this->getRequest()->wasPosted() ) {
            wfTransactionalTimeLimit();
        }
    }

}