SearchHandler.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest\Handler;
 
use Config;
use InvalidArgumentException;
use ISearchResultSet;
use MediaWiki\Permissions\PermissionManager;
use MediaWiki\Rest\Entity\SearchResultPageIdentityValue;
use MediaWiki\Rest\Handler;
use MediaWiki\Rest\LocalizedHttpException;
use MediaWiki\Rest\Response;
use MediaWiki\Search\Entity\SearchResultThumbnail;
use RequestContext;
use SearchEngine;
use SearchEngineConfig;
use SearchEngineFactory;
use SearchResult;
use SearchSuggestion;
use Status;
use User;
use Wikimedia\Message\MessageValue;
use Wikimedia\ParamValidator\ParamValidator;
use Wikimedia\ParamValidator\TypeDef\IntegerDef;
 
class SearchHandler extends Handler {
 
    private $permissionManager;
 
    private $searchEngineFactory;
 
    private $searchEngineConfig;
 
    private $user;
 
    public const FULLTEXT_MODE = 'fulltext';
 
    public const COMPLETION_MODE = 'completion';
 
    private const SUPPORTED_MODES = [ self::FULLTEXT_MODE, self::COMPLETION_MODE ];
 
    private $mode = null;
 
    private const LIMIT = 50;
 
    private const MAX_LIMIT = 100;
 
    private const OFFSET = 0;
 
    private $completionCacheExpiry;
 
    public function __construct(
        Config $config,
        PermissionManager $permissionManager,
        SearchEngineFactory $searchEngineFactory,
        SearchEngineConfig $searchEngineConfig
    ) {
        $this->permissionManager = $permissionManager;
        $this->searchEngineFactory = $searchEngineFactory;
        $this->searchEngineConfig = $searchEngineConfig;
 
        // @todo Inject this, when there is a good way to do that, see T239753
        $this->user = RequestContext::getMain()->getUser();
 
        // @todo Avoid injecting the entire config, see T246377
        $this->completionCacheExpiry = $config->get( 'SearchSuggestCacheExpiry' );
    }
 
    protected function postInitSetup() {
        $this->mode = $this->getConfig()['mode'] ?? self::FULLTEXT_MODE;
 
        if ( !in_array( $this->mode, self::SUPPORTED_MODES ) ) {
            throw new InvalidArgumentException(
                "Unsupported search mode `{$this->mode}` configured. Supported modes: " .
                implode( ', ', self::SUPPORTED_MODES )
            );
        }
    }
 
    private function createSearchEngine() {
        $limit = $this->getValidatedParams()['limit'];
 
        $searchEngine = $this->searchEngineFactory->create();
        $searchEngine->setNamespaces( $this->searchEngineConfig->defaultNamespaces() );
        $searchEngine->setLimitOffset( $limit, self::OFFSET );
        return $searchEngine;
    }
 
    public function needsWriteAccess() {
        return false;
    }
 
    private function getSearchResultsOrThrow( $results ) {
        if ( $results ) {
            if ( $results instanceof Status ) {
                $status = $results;
                if ( !$status->isOK() ) {
                    list( $error ) = $status->splitByErrorType();
                    if ( $error->getErrors() ) { // Only throw for errors, suppress warnings (for now)
                        $errorMessages = $error->getMessage();
                        throw new LocalizedHttpException(
                            new MessageValue( "rest-search-error", [ $errorMessages->getKey() ] )
                        );
                    }
                }
                $statusValue = $status->getValue();
                if ( $statusValue instanceof ISearchResultSet ) {
                    return $statusValue->extractResults();
                }
            } else {
                return $results->extractResults();
            }
        }
        return [];
    }
 
    private function doSearch( $searchEngine ) {
        $query = $this->getValidatedParams()['q'];
 
        if ( $this->mode == self::COMPLETION_MODE ) {
            $completionSearch = $searchEngine->completionSearchWithVariants( $query );
            return $this->buildPageInfosFromSuggestions( $completionSearch->getSuggestions() );
        } else {
            $titleSearch = $searchEngine->searchTitle( $query );
            $textSearch = $searchEngine->searchText( $query );
 
            $titleSearchResults = $this->getSearchResultsOrThrow( $titleSearch );
            $textSearchResults = $this->getSearchResultsOrThrow( $textSearch );
 
            $mergedResults = array_merge( $titleSearchResults, $textSearchResults );
            return $this->buildPageInfosFromSearchResults( $mergedResults );
        }
    }
 
    private function buildPageInfosFromSuggestions( array $suggestions ): array {
        $pageInfos = [];
 
        foreach ( $suggestions as $sugg ) {
            $title = $sugg->getSuggestedTitle();
            if ( $title && $title->exists() ) {
                $pageID = $title->getArticleID();
                if ( !isset( $pageInfos[$pageID] ) &&
                    $this->permissionManager->quickUserCan( 'read', $this->user, $title )
                ) {
                    $pageInfos[ $pageID ] = [ $title, $sugg, null ];
                }
            }
        }
        return $pageInfos;
    }
 
    private function buildPageInfosFromSearchResults( array $searchResults ): array {
        $pageInfos = [];
 
        foreach ( $searchResults as $result ) {
            if ( !$result->isBrokenTitle() && !$result->isMissingRevision() ) {
                $title = $result->getTitle();
                $pageID = $title->getArticleID();
                if ( !isset( $pageInfos[$pageID] ) &&
                    $this->permissionManager->quickUserCan( 'read', $this->user, $title )
                ) {
                    $pageInfos[$pageID] = [ $title, null, $result ];
                }
            }
        }
        return $pageInfos;
    }
 
    private function buildResultFromPageInfos( array $pageInfos ): array {
        return array_map( function ( $pageInfo ) {
            list( $title, $sugg, $result ) = $pageInfo;
            return [
                'id' => $title->getArticleID(),
                'key' => $title->getPrefixedDBkey(),
                'title' => $title->getPrefixedText(),
                'excerpt' => ( $sugg ? $sugg->getText() : $result->getTextSnippet() ) ?: null,
            ];
        },
        $pageInfos );
    }
 
    private function serializeThumbnail( ?SearchResultThumbnail $thumbnail ) : ?array {
        if ( $thumbnail == null ) {
            return null;
        }
 
        return [
            'mimetype' => $thumbnail->getMimeType(),
            'size' => $thumbnail->getSize(),
            'width' => $thumbnail->getWidth(),
            'height' => $thumbnail->getHeight(),
            'duration' => $thumbnail->getDuration(),
            'url' => $thumbnail->getUrl(),
        ];
    }
 
    private function buildDescriptionsFromPageIdentities( array $pageIdentities ) {
        $descriptions = array_fill_keys( array_keys( $pageIdentities ), null );
 
        $this->getHookRunner()->onSearchResultProvideDescription( $pageIdentities, $descriptions );
 
        return array_map( function ( $description ) {
            return [ 'description' => $description ];
        }, $descriptions );
    }
 
    private function buildThumbnailsFromPageIdentities( array $pageIdentities ) {
        $thumbnails = array_fill_keys( array_keys( $pageIdentities ), null );
 
        $this->getHookRunner()->onSearchResultProvideThumbnail( $pageIdentities, $thumbnails );
 
        return array_map( function ( $thumbnail ) {
            return [ 'thumbnail' => $this->serializeThumbnail( $thumbnail ) ];
        }, $thumbnails );
    }
 
    public function execute() {
        $searchEngine = $this->createSearchEngine();
        $pageInfos = $this->doSearch( $searchEngine );
        $pageIdentities = array_map( function ( $pageInfo ) {
            list( $title ) = $pageInfo;
            return new SearchResultPageIdentityValue(
                $title->getArticleID(),
                $title->getNamespace(),
                $title->getDBkey()
            );
        }, $pageInfos );
 
        $result = array_map( "array_merge",
            $this->buildResultFromPageInfos( $pageInfos ),
            $this->buildDescriptionsFromPageIdentities( $pageIdentities ),
            $this->buildThumbnailsFromPageIdentities( $pageIdentities )
        );
 
        $response = $this->getResponseFactory()->createJson( [ 'pages' => $result ] );
 
        if ( $this->mode === self::COMPLETION_MODE && $this->completionCacheExpiry ) {
            // Type-ahead completion matches should be cached by the client and
            // in the CDN, especially for short prefixes.
            // See also $wgSearchSuggestCacheExpiry and ApiOpenSearch
            $response->setHeader( 'Cache-Control', 'public, max-age=' . $this->completionCacheExpiry );
        }
 
        return $response;
    }
 
    public function getParamSettings() {
        return [
            'q' => [
                self::PARAM_SOURCE => 'query',
                ParamValidator::PARAM_TYPE => 'string',
                ParamValidator::PARAM_REQUIRED => true,
            ],
            'limit' => [
                self::PARAM_SOURCE => 'query',
                ParamValidator::PARAM_TYPE => 'integer',
                ParamValidator::PARAM_REQUIRED => false,
                ParamValidator::PARAM_DEFAULT => self::LIMIT,
                IntegerDef::PARAM_MIN => 1,
                IntegerDef::PARAM_MAX => self::MAX_LIMIT,
            ],
        ];
    }
}