ApiQueryBase.php

Go to the documentation of this file.

<?php
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\ResultWrapper;

abstract class ApiQueryBase extends ApiBase {

    private $mQueryModule, $mDb, $tables, $where, $fields, $options, $join_conds;

    public function __construct( ApiQuery $queryModule, $moduleName, $paramPrefix = '' ) {
        parent::__construct( $queryModule->getMain(), $moduleName, $paramPrefix );
        $this->mQueryModule = $queryModule;
        $this->mDb = null;
        $this->resetQueryParams();
    }

    /************************************************************************/
    public function getCacheMode( $params ) {
        return 'private';
    }

    public function requestExtraData( $pageSet ) {
    }

    /************************************************************************/
    public function getQuery() {
        return $this->mQueryModule;
    }

    public function getParent() {
        return $this->getQuery();
    }

    protected function getDB() {
        if ( is_null( $this->mDb ) ) {
            $this->mDb = $this->getQuery()->getDB();
        }

        return $this->mDb;
    }

    public function selectNamedDB( $name, $db, $groups ) {
        $this->mDb = $this->getQuery()->getNamedDB( $name, $db, $groups );
        return $this->mDb;
    }

    protected function getPageSet() {
        return $this->getQuery()->getPageSet();
    }

    /************************************************************************/
    protected function resetQueryParams() {
        $this->tables = [];
        $this->where = [];
        $this->fields = [];
        $this->options = [];
        $this->join_conds = [];
    }

    protected function addTables( $tables, $alias = null ) {
        if ( is_array( $tables ) ) {
            if ( $alias !== null ) {
                ApiBase::dieDebug( __METHOD__, 'Multiple table aliases not supported' );
            }
            $this->tables = array_merge( $this->tables, $tables );
        } elseif ( $alias !== null ) {
            $this->tables[$alias] = $tables;
        } else {
            $this->tables[] = $tables;
        }
    }

    protected function addJoinConds( $join_conds ) {
        if ( !is_array( $join_conds ) ) {
            ApiBase::dieDebug( __METHOD__, 'Join conditions have to be arrays' );
        }
        $this->join_conds = array_merge( $this->join_conds, $join_conds );
    }

    protected function addFields( $value ) {
        if ( is_array( $value ) ) {
            $this->fields = array_merge( $this->fields, $value );
        } else {
            $this->fields[] = $value;
        }
    }

    protected function addFieldsIf( $value, $condition ) {
        if ( $condition ) {
            $this->addFields( $value );

            return true;
        }

        return false;
    }

    protected function addWhere( $value ) {
        if ( is_array( $value ) ) {
            // Sanity check: don't insert empty arrays,
            // Database::makeList() chokes on them
            if ( count( $value ) ) {
                $this->where = array_merge( $this->where, $value );
            }
        } else {
            $this->where[] = $value;
        }
    }

    protected function addWhereIf( $value, $condition ) {
        if ( $condition ) {
            $this->addWhere( $value );

            return true;
        }

        return false;
    }

    protected function addWhereFld( $field, $value ) {
        if ( $value !== null && !( is_array( $value ) && !$value ) ) {
            $this->where[$field] = $value;
        }
    }

    protected function addWhereIDsFld( $table, $field, $ids ) {
        // Use count() to its full documented capabilities to simultaneously
        // test for null, empty array or empty countable object
        if ( count( $ids ) ) {
            $ids = $this->filterIDs( [ [ $table, $field ] ], $ids );

            if ( $ids === [] ) {
                // Return nothing, no IDs are valid
                $this->where[] = '0 = 1';
            } else {
                $this->where[$field] = $ids;
            }
        }
        return count( $ids );
    }

    protected function addWhereRange( $field, $dir, $start, $end, $sort = true ) {
        $isDirNewer = ( $dir === 'newer' );
        $after = ( $isDirNewer ? '>=' : '<=' );
        $before = ( $isDirNewer ? '<=' : '>=' );
        $db = $this->getDB();

        if ( !is_null( $start ) ) {
            $this->addWhere( $field . $after . $db->addQuotes( $start ) );
        }

        if ( !is_null( $end ) ) {
            $this->addWhere( $field . $before . $db->addQuotes( $end ) );
        }

        if ( $sort ) {
            $order = $field . ( $isDirNewer ? '' : ' DESC' );
            // Append ORDER BY
            $optionOrderBy = isset( $this->options['ORDER BY'] )
                ? (array)$this->options['ORDER BY']
                : [];
            $optionOrderBy[] = $order;
            $this->addOption( 'ORDER BY', $optionOrderBy );
        }
    }

    protected function addTimestampWhereRange( $field, $dir, $start, $end, $sort = true ) {
        $db = $this->getDB();
        $this->addWhereRange( $field, $dir,
            $db->timestampOrNull( $start ), $db->timestampOrNull( $end ), $sort );
    }

    protected function addOption( $name, $value = null ) {
        if ( is_null( $value ) ) {
            $this->options[] = $name;
        } else {
            $this->options[$name] = $value;
        }
    }

    protected function select( $method, $extraQuery = [], array &$hookData = null ) {
        $tables = array_merge(
            $this->tables,
            isset( $extraQuery['tables'] ) ? (array)$extraQuery['tables'] : []
        );
        $fields = array_merge(
            $this->fields,
            isset( $extraQuery['fields'] ) ? (array)$extraQuery['fields'] : []
        );
        $where = array_merge(
            $this->where,
            isset( $extraQuery['where'] ) ? (array)$extraQuery['where'] : []
        );
        $options = array_merge(
            $this->options,
            isset( $extraQuery['options'] ) ? (array)$extraQuery['options'] : []
        );
        $join_conds = array_merge(
            $this->join_conds,
            isset( $extraQuery['join_conds'] ) ? (array)$extraQuery['join_conds'] : []
        );

        if ( $hookData !== null ) {
            Hooks::run( 'ApiQueryBaseBeforeQuery',
                [ $this, &$tables, &$fields, &$where, &$options, &$join_conds, &$hookData ]
            );
        }

        $res = $this->getDB()->select( $tables, $fields, $where, $method, $options, $join_conds );

        if ( $hookData !== null ) {
            Hooks::run( 'ApiQueryBaseAfterQuery', [ $this, $res, &$hookData ] );
        }

        return $res;
    }

    protected function processRow( $row, array &$data, array &$hookData ) {
        return Hooks::run( 'ApiQueryBaseProcessRow', [ $this, $row, &$data, &$hookData ] );
    }

    public function showHiddenUsersAddBlockInfo( $showBlockInfo ) {
        $db = $this->getDB();

        $tables = [ 'ipblocks' ];
        $fields = [ 'ipb_deleted' ];
        $joinConds = [
            'blk' => [ 'LEFT JOIN', [
                'ipb_user=user_id',
                'ipb_expiry > ' . $db->addQuotes( $db->timestamp() ),
            ] ],
        ];

        if ( $showBlockInfo ) {
            $actorQuery = ActorMigration::newMigration()->getJoin( 'ipb_by' );
            $commentQuery = CommentStore::getStore()->getJoin( 'ipb_reason' );
            $tables += $actorQuery['tables'] + $commentQuery['tables'];
            $joinConds += $actorQuery['joins'] + $commentQuery['joins'];
            $fields = array_merge( $fields, [
                'ipb_id',
                'ipb_expiry',
                'ipb_timestamp'
            ], $actorQuery['fields'], $commentQuery['fields'] );
        }

        $this->addTables( [ 'blk' => $tables ] );
        $this->addFields( $fields );
        $this->addJoinConds( $joinConds );

        // Don't show hidden names
        if ( !$this->getUser()->isAllowed( 'hideuser' ) ) {
            $this->addWhere( 'ipb_deleted = 0 OR ipb_deleted IS NULL' );
        }
    }

    /************************************************************************/
    public static function addTitleInfo( &$arr, $title, $prefix = '' ) {
        $arr[$prefix . 'ns'] = (int)$title->getNamespace();
        $arr[$prefix . 'title'] = $title->getPrefixedText();
    }

    protected function addPageSubItems( $pageId, $data ) {
        $result = $this->getResult();
        ApiResult::setIndexedTagName( $data, $this->getModulePrefix() );

        return $result->addValue( [ 'query', 'pages', (int)$pageId ],
            $this->getModuleName(),
            $data );
    }

    protected function addPageSubItem( $pageId, $item, $elemname = null ) {
        if ( is_null( $elemname ) ) {
            $elemname = $this->getModulePrefix();
        }
        $result = $this->getResult();
        $fit = $result->addValue( [ 'query', 'pages', $pageId,
            $this->getModuleName() ], null, $item );
        if ( !$fit ) {
            return false;
        }
        $result->addIndexedTagName( [ 'query', 'pages', $pageId,
            $this->getModuleName() ], $elemname );

        return true;
    }

    protected function setContinueEnumParameter( $paramName, $paramValue ) {
        $this->getContinuationManager()->addContinueParam( $this, $paramName, $paramValue );
    }

    public function titlePartToKey( $titlePart, $namespace = NS_MAIN ) {
        $t = Title::makeTitleSafe( $namespace, $titlePart . 'x' );
        if ( !$t || $t->hasFragment() ) {
            // Invalid title (e.g. bad chars) or contained a '#'.
            $this->dieWithError( [ 'apierror-invalidtitle', wfEscapeWikiText( $titlePart ) ] );
        }
        if ( $namespace != $t->getNamespace() || $t->isExternal() ) {
            // This can happen in two cases. First, if you call titlePartToKey with a title part
            // that looks like a namespace, but with $defaultNamespace = NS_MAIN. It would be very
            // difficult to handle such a case. Such cases cannot exist and are therefore treated
            // as invalid user input. The second case is when somebody specifies a title interwiki
            // prefix.
            $this->dieWithError( [ 'apierror-invalidtitle', wfEscapeWikiText( $titlePart ) ] );
        }

        return substr( $t->getDBkey(), 0, -1 );
    }

    public function prefixedTitlePartToKey( $titlePart, $defaultNamespace = NS_MAIN ) {
        $t = Title::newFromText( $titlePart . 'x', $defaultNamespace );
        if ( !$t || $t->hasFragment() || $t->isExternal() ) {
            // Invalid title (e.g. bad chars) or contained a '#'.
            $this->dieWithError( [ 'apierror-invalidtitle', wfEscapeWikiText( $titlePart ) ] );
        }

        return [ $t->getNamespace(), substr( $t->getDBkey(), 0, -1 ) ];
    }

    public function validateSha1Hash( $hash ) {
        return (bool)preg_match( '/^[a-f0-9]{40}$/', $hash );
    }

    public function validateSha1Base36Hash( $hash ) {
        return (bool)preg_match( '/^[a-z0-9]{31}$/', $hash );
    }

    public function userCanSeeRevDel() {
        return $this->getUser()->isAllowedAny(
            'deletedhistory',
            'deletedtext',
            'suppressrevision',
            'viewsuppressed'
        );
    }

}