SearchResultSetService::wrapResultDocumentInResultObject() - Code Metrics - Inspection of "[!!!][TASK] Extract document parsing to parser cla..." - timohund/ext-solr - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a15d6d...9819c1 )

by Timo

created 2017-10-09 13:22 UTC

wrapResultDocumentInResultObject() A

↳ Parent: SearchResultSetService

Complexity

Conditions	3
Paths	3

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	3

Importance

Changes

Metric	Value
dl	0
loc	17
ccs	11
cts	11
cp	1
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	10
nc	3
nop	1
crap	3

<?php

namespace ApacheSolrForTypo3\Solr\Domain\Search\ResultSet;

/***************************************************************
 *  Copyright notice
 *
 *  (c) 2015-2016 Timo Schmidt <[email protected]>
 *  All rights reserved
 *
 *  This script is part of the TYPO3 project. The TYPO3 project is
 *  free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  The GNU General Public License can be found at
 *  http://www.gnu.org/copyleft/gpl.html.
 *
 *  This script is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/

use ApacheSolrForTypo3\Solr\Domain\Search\Query\ParameterBuilder\QueryFields;
use ApacheSolrForTypo3\Solr\Domain\Search\ResultSet\Result\Parser\ResultParserRegistry;
use ApacheSolrForTypo3\Solr\Domain\Search\SearchRequest;
use ApacheSolrForTypo3\Solr\Domain\Search\SearchRequestAware;
use ApacheSolrForTypo3\Solr\Domain\Variants\VariantsProcessor;
use ApacheSolrForTypo3\Solr\Query;
use ApacheSolrForTypo3\Solr\Query\Modifier\Modifier;
use ApacheSolrForTypo3\Solr\Search;
use ApacheSolrForTypo3\Solr\Search\QueryAware;
use ApacheSolrForTypo3\Solr\Search\SearchAware;
use ApacheSolrForTypo3\Solr\Search\SearchComponentManager;
use ApacheSolrForTypo3\Solr\System\Configuration\TypoScriptConfiguration;
use ApacheSolrForTypo3\Solr\System\Logging\SolrLogManager;
use ApacheSolrForTypo3\Solr\System\Solr\SolrCommunicationException;
use ApacheSolrForTypo3\Solr\System\Solr\SolrIncompleteResponseException;
use ApacheSolrForTypo3\Solr\System\Solr\SolrInternalServerErrorException;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;

/**
 * The SearchResultSetService is responsible to build a SearchResultSet from a SearchRequest.
 * It encapsulates the logic to trigger a search in order to be able to reuse it in multiple places.
 *
 * @author Timo Schmidt <[email protected]>
 */
class SearchResultSetService
{
    /**
     * Additional filters, which will be added to the query, as well as to
     * suggest queries.
     *
     * @var array
     */
    protected $additionalFilters = [];

    /**
     * Track, if the number of results per page has been changed by the current request
     *
     * @var bool
     */
    protected $resultsPerPageChanged = false;

    /**
     * @var Search
     */
    protected $search;

    /**
     * @var SearchResultSet
     */
    protected $lastResultSet = null;

    /**
     * @var boolean
     */
    protected $isSolrAvailable = false;

    /**
     * @var TypoScriptConfiguration
     */
    protected $typoScriptConfiguration;

    /**
     * @var SolrLogManager;
     */
    protected $logger = null;

    /**
     * @var SearchResultBuilder
     */
    protected $searchResultBuilder;

    /**
     * @param TypoScriptConfiguration $configuration
     * @param Search $search
     * @param SolrLogManager $solrLogManager
     * @param SearchResultBuilder $resultBuilder
     */
    public function __construct(TypoScriptConfiguration $configuration, Search $search, SolrLogManager $solrLogManager = null, SearchResultBuilder $resultBuilder = null)
    {
        $this->search = $search;
        $this->typoScriptConfiguration = $configuration;
        $this->logger = is_null($solrLogManager) ? GeneralUtility::makeInstance(SolrLogManager::class, __CLASS__) : $solrLogManager;
        $this->searchResultBuilder = is_null($resultBuilder) ? GeneralUtility::makeInstance(SearchResultBuilder::class) : $resultBuilder;
    }

    /**
     * @param bool $useCache
     * @return bool
     */
    public function getIsSolrAvailable($useCache = true)
    {
        $this->isSolrAvailable = $this->search->ping($useCache);
        return $this->isSolrAvailable;
    }

    /**
     * @return bool
     */
    public function getHasSearched()
    {
        return $this->search->hasSearched();
    }

    /**
     * Retrieves the used search instance.
     *
     * @return Search
     */
    public function getSearch()
    {
        return $this->search;
    }

    /**
     * Initializes the Query object and SearchComponents and returns
     * the initialized query object, when a search should be executed.
     *
     * @param string|null $rawQuery
     * @param int $resultsPerPage
     * @return Query
     */
    protected function getPreparedQuery($rawQuery, $resultsPerPage)
    {
        /* @var $query Query */
        $query = $this->getQueryInstance($rawQuery);

        $this->applyPageSectionsRootLineFilter($query);

        if ($this->typoScriptConfiguration->getLoggingQuerySearchWords()) {
            $this->logger->log(
                SolrLogManager::INFO,
                'Received search query',
                [
                    $rawQuery
                ]
            );
        }

        $query->setResultsPerPage($resultsPerPage);

        if ($this->typoScriptConfiguration->getSearchInitializeWithEmptyQuery() || $this->typoScriptConfiguration->getSearchQueryAllowEmptyQuery()) {
            // empty main query, but using a "return everything"
            // alternative query in q.alt
            $query->setAlternativeQuery('*:*');
        }

        if ($this->typoScriptConfiguration->getSearchInitializeWithQuery()) {
            $query->setAlternativeQuery($this->typoScriptConfiguration->getSearchInitializeWithQuery());
        }

        foreach ($this->getAdditionalFilters() as $additionalFilter) {
            $query->getFilters()->add($additionalFilter);
        }

        return $query;
    }

    /**
     * @param Query $query
     * @param SearchRequest $searchRequest
     */
    protected function initializeRegisteredSearchComponents(Query $query, SearchRequest $searchRequest)
    {
        $searchComponents = $this->getRegisteredSearchComponents();

        foreach ($searchComponents as $searchComponent) {
            /** @var Search\SearchComponent $searchComponent */
            $searchComponent->setSearchConfiguration($this->typoScriptConfiguration->getSearchConfiguration());

            if ($searchComponent instanceof QueryAware) {
                $searchComponent->setQuery($query);
            }

            if ($searchComponent instanceof SearchRequestAware) {
                $searchComponent->setSearchRequest($searchRequest);
            }

            $searchComponent->initializeSearchComponent();
        }
    }

    /**
     * @return string
     */
    protected function getResultSetClassName()
    {
        return isset($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['searchResultSetClassName ']) ?
            $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['searchResultSetClassName '] : SearchResultSet::class;
    }

    /**
     * Initializes additional filters configured through TypoScript and
     * Flexforms for use in regular queries and suggest queries.
     *
     * @param Query $query
     * @return void
     */
    protected function applyPageSectionsRootLineFilter(Query $query)
    {
        $searchQueryFilters = $this->typoScriptConfiguration->getSearchQueryFilterConfiguration();
        if (count($searchQueryFilters) <= 0) {
            return;
        }

        // special filter to limit search to specific page tree branches
        if (array_key_exists('__pageSections', $searchQueryFilters)) {
            $query->setRootlineFilter($searchQueryFilters['__pageSections']);
            $this->typoScriptConfiguration->removeSearchQueryFilterForPageSections();
        }
    }

    /**
     * Retrieves the configuration filters from the TypoScript configuration, except the __pageSections filter.
     *
     * @return array
     */
    public function getAdditionalFilters()
    {
        // when we've build the additionalFilter once, we could return them
        if (count($this->additionalFilters) > 0) {
            return $this->additionalFilters;
        }

        $searchQueryFilters = $this->typoScriptConfiguration->getSearchQueryFilterConfiguration();
        if (count($searchQueryFilters) <= 0) {
            return [];
        }

        $cObj = GeneralUtility::makeInstance(ContentObjectRenderer::class);

        // all other regular filters
        foreach ($searchQueryFilters as $filterKey => $filter) {
            // the __pageSections filter should not be handled as additional filter
            if ($filterKey === '__pageSections') {
                continue;
            }

            $filterIsArray = is_array($searchQueryFilters[$filterKey]);
            if ($filterIsArray) {
                continue;
            }

            $hasSubConfiguration = is_array($searchQueryFilters[$filterKey . '.']);
            if ($hasSubConfiguration) {
                $filter = $cObj->stdWrap($searchQueryFilters[$filterKey], $searchQueryFilters[$filterKey . '.']);
            }

            $this->additionalFilters[$filterKey] = $filter;
        }

        return $this->additionalFilters;
    }

    /**
     * Performs a search and returns a SearchResultSet.
     *
     * @param SearchRequest $searchRequest
     * @return SearchResultSet
     */
    public function search(SearchRequest $searchRequest)
    {
        /** @var $resultSet SearchResultSet */
        $resultSetClass = $this->getResultSetClassName();
        $resultSet = GeneralUtility::makeInstance($resultSetClass);
        $resultSet->setUsedSearchRequest($searchRequest);
        $this->lastResultSet = $resultSet;

        $resultSet = $this->handleSearchHook('beforeSearch', $resultSet);

        if ($searchRequest->getRawUserQueryIsNull() && !$this->getInitialSearchIsConfigured()) {
            // when no rawQuery was passed or no initialSearch is configured, we pass an empty result set
            return $resultSet;
        }

        if ($searchRequest->getRawUserQueryIsEmptyString() && !$this->typoScriptConfiguration->getSearchQueryAllowEmptyQuery()) {
            // the user entered an empty query string "" or "  " and empty querystring is not allowed
            return $resultSet;
        }

        $rawQuery = $searchRequest->getRawUserQuery();
        $resultsPerPage = (int)$searchRequest->getResultsPerPage();
        $query = $this->getPreparedQuery($rawQuery, $resultsPerPage);
        $this->initializeRegisteredSearchComponents($query, $searchRequest);
        $resultSet->setUsedQuery($query);

        // the offset mulitplier is page - 1 but not less then zero
        $offsetMultiplier = max(0, $searchRequest->getPage() - 1);
        $offSet = $offsetMultiplier * $resultsPerPage;

        // performing the actual search, sending the query to the Solr server
        $query = $this->modifyQuery($query, $searchRequest, $this->search);
        $response = $this->doASearch($query, $offSet);

        if ($resultsPerPage === 0) {
            // when resultPerPage was forced to 0 we also set the numFound to 0 to hide results, e.g.
            // when results for the initial search should not be shown.
            $response->response->numFound = 0;

        }

        $resultSet->setUsedSearch($this->search);
        $resultSet->setResponse($response);

            /** @var ResultParserRegistry $parserRegistry */
        $parserRegistry = GeneralUtility::makeInstance(ResultParserRegistry::class, $this->typoScriptConfiguration);
        $useRawDocuments = (bool)$this->typoScriptConfiguration->getValueByPathOrDefaultValue('plugin.tx_solr.features.useRawDocuments', false);
        $searchResults = $parserRegistry->getParser($resultSet)->parse($resultSet, $useRawDocuments);
        $resultSet->setSearchResults($searchResults);

        $resultSet->setUsedPage((int)$searchRequest->getPage());
        $resultSet->setUsedResultsPerPage($resultsPerPage);
        $resultSet->setUsedAdditionalFilters($this->getAdditionalFilters());

        /** @var $variantsProcessor VariantsProcessor */
        $variantsProcessor = GeneralUtility::makeInstance(VariantsProcessor::class, $this->typoScriptConfiguration, $this->searchResultBuilder);
        $variantsProcessor->process($resultSet);

        /** @var $searchResultReconstitutionProcessor ResultSetReconstitutionProcessor */
        $searchResultReconstitutionProcessor = GeneralUtility::makeInstance(ResultSetReconstitutionProcessor::class);
        $searchResultReconstitutionProcessor->process($resultSet);

        $resultSet = $this->getAutoCorrection($resultSet);

        return $this->handleSearchHook('afterSearch', $resultSet);
    }

    /**
     * Executes the search and builds a fake response for a current bug in Apache Solr 6.3
     *
     * @param Query $query
     * @param int $offSet
     * @throws SolrCommunicationException
     * @return \Apache_Solr_Response
     */
    protected function doASearch($query, $offSet)
    {
        try {
            $response = $this->search->search($query, $offSet, null);
        } catch (SolrInternalServerErrorException $e) {
            // when variants are enable and the index is empty, we get a parse exception, because of a
            // Apache Solr Bug.
            // see: https://github.com/TYPO3-Solr/ext-solr/issues/668
            // @todo this try/catch block can be removed after upgrading to Apache Solr 6.4
            if (!$this->typoScriptConfiguration->getSearchVariants()) {
                throw $e;
            }

            $response = $e->getSolrResponse();

            $parsedData = new \stdClass();
            $parsedData->response = new \stdClass();
            $parsedData->response->docs = [];
            $parsedData->spellcheck = [];
            $parsedData->debug = [];
            $parsedData->responseHeader = [];
            $parsedData->facet_counts = [];
            $parsedData->facets = [];
            $response->setParsedData($parsedData);

        }

        if($response === null) {
            throw new SolrIncompleteResponseException('The response retrieved from solr was incomplete', 1505989678);
        }

        return $response;
    }

    /**
     * @param SearchResultSet $searchResultSet
     * @return SearchResultSet
     */
    protected function getAutoCorrection(SearchResultSet $searchResultSet)
    {
        // no secondary search configured
        if (!$this->typoScriptConfiguration->getSearchSpellcheckingSearchUsingSpellCheckerSuggestion()) {
            return $searchResultSet;
        }

        // more then zero results
        if ($searchResultSet->getAllResultCount() > 0) {
            return $searchResultSet;
        }

        // no corrections present
        if (!$searchResultSet->getHasSpellCheckingSuggestions()) {
            return $searchResultSet;
        }

        $searchResultSet = $this->peformAutoCorrection($searchResultSet);

        return $searchResultSet;
    }

    /**
     * @param SearchResultSet $searchResultSet
     * @return SearchResultSet
     */
    protected function peformAutoCorrection(SearchResultSet $searchResultSet)
    {
        $searchRequest = $searchResultSet->getUsedSearchRequest();
        $suggestions = $searchResultSet->getSpellCheckingSuggestions();

        $maximumRuns = $this->typoScriptConfiguration->getSearchSpellcheckingNumberOfSuggestionsToTry(1);
        $runs = 0;

        foreach ($suggestions as $suggestion) {
            $runs++;

            $correction = $suggestion->getSuggestion();
            $initialQuery = $searchRequest->getRawUserQuery();

            $searchRequest->setRawQueryString($correction);
            $searchResultSet = $this->search($searchRequest);
            if ($searchResultSet->getAllResultCount() > 0) {
                $searchResultSet->setIsAutoCorrected(true);
                $searchResultSet->setCorrectedQueryString($correction);
                $searchResultSet->setInitialQueryString($initialQuery);
                break;
            }

            if ($runs > $maximumRuns) {
                break;
            }
        }
        return $searchResultSet;
    }

    /**
     * Allows to modify a query before eventually handing it over to Solr.
     *
     * @param Query $query The current query before it's being handed over to Solr.
     * @param SearchRequest $searchRequest The searchRequest, relevant in the current context
     * @param Search $search The search, relevant in the current context
     * @throws \UnexpectedValueException
     * @return Query The modified query that is actually going to be given to Solr.
     */
    protected function modifyQuery(Query $query, SearchRequest $searchRequest, Search $search)
    {
        // hook to modify the search query
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['modifySearchQuery'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['modifySearchQuery'] as $classReference) {
                $queryModifier = GeneralUtility::getUserObj($classReference);

                if ($queryModifier instanceof Modifier) {
                    if ($queryModifier instanceof SearchAware) {
                        $queryModifier->setSearch($search);
                    }

                    if ($queryModifier instanceof SearchRequestAware) {
                        $queryModifier->setSearchRequest($searchRequest);
                    }

                    $query = $queryModifier->modifyQuery($query);
                } else {
                    throw new \UnexpectedValueException(
                        get_class($queryModifier) . ' must implement interface ' . Modifier::class,
                        1310387414
                    );
                }
            }
        }

        return $query;
    }

    /**
     * Retrieves a single document from solr by document id.
     *
     * @param string $documentId
     * @return SearchResult
     */
    public function getDocumentById($documentId)
    {
        /* @var $query Query */
        $query = GeneralUtility::makeInstance(Query::class, $documentId);
        $query->setQueryFields(QueryFields::fromString('id'));
        $response = $this->search->search($query, 0, 1);
        $parsedData = $response->getParsedData();
        $resultDocument = isset($parsedData->response->docs[0]) ? $parsedData->response->docs[0] : null;

        return $this->searchResultBuilder->fromApacheSolrDocument($resultDocument);
    }

    /**
     * This method is used to call the registered hooks during the search execution.
     *
     * @param string $eventName
     * @param SearchResultSet $resultSet
     * @return SearchResultSet
     */
    private function handleSearchHook($eventName, SearchResultSet $resultSet)
    {
        if (!is_array($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr'][$eventName])) {
            return $resultSet;
        }

        foreach ($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr'][$eventName] as $classReference) {
            $afterSearchProcessor = GeneralUtility::getUserObj($classReference);
            if ($afterSearchProcessor instanceof SearchResultSetProcessor) {
                $afterSearchProcessor->process($resultSet);
            }
        }

        return $resultSet;
    }

    /**
     * @return SearchResultSet
     */
    public function getLastResultSet()
    {
        return $this->lastResultSet;
    }

    /**
     * This method returns true when the last search was executed with an empty query
     * string or whitespaces only. When no search was triggered it will return false.
     *
     * @return bool
     */
    public function getLastSearchWasExecutedWithEmptyQueryString()
    {
        $wasEmptyQueryString = false;
        if ($this->lastResultSet != null) {
            $wasEmptyQueryString = $this->lastResultSet->getUsedSearchRequest()->getRawUserQueryIsEmptyString();
        }

        return $wasEmptyQueryString;
    }

    /**
     * @return bool
     */
    protected function getInitialSearchIsConfigured()
    {
        return $this->typoScriptConfiguration->getSearchInitializeWithEmptyQuery() || $this->typoScriptConfiguration->getSearchShowResultsOfInitialEmptyQuery() || $this->typoScriptConfiguration->getSearchInitializeWithQuery() || $this->typoScriptConfiguration->getSearchShowResultsOfInitialQuery();
    }

    /**
     * @return mixed
     */
    protected function getRegisteredSearchComponents()
    {
        return GeneralUtility::makeInstance(SearchComponentManager::class)->getSearchComponents();
    }

    /**
     * @param string $rawQuery
     * @return Query|object
     */
    protected function getQueryInstance($rawQuery)
    {
        $query = GeneralUtility::makeInstance(Query::class, $rawQuery, $this->typoScriptConfiguration);
        return $query;
    }
}


1		<?php
2
3		namespace ApacheSolrForTypo3\Solr\Domain\Search\ResultSet;
4
5		/***************************************************************
6		* Copyright notice
7		*
8		* (c) 2015-2016 Timo Schmidt <[email protected]>
9		* All rights reserved
10		*
11		* This script is part of the TYPO3 project. The TYPO3 project is
12		* free software; you can redistribute it and/or modify
13		* it under the terms of the GNU General Public License as published by
14		* the Free Software Foundation; either version 2 of the License, or
15		* (at your option) any later version.
16		*
17		* The GNU General Public License can be found at
18		* http://www.gnu.org/copyleft/gpl.html.
19		*
20		* This script is distributed in the hope that it will be useful,
21		* but WITHOUT ANY WARRANTY; without even the implied warranty of
22		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23		* GNU General Public License for more details.
24		*
25		* This copyright notice MUST APPEAR in all copies of the script!
26		***************************************************************/
27
28		use ApacheSolrForTypo3\Solr\Domain\Search\Query\ParameterBuilder\QueryFields;
29		use ApacheSolrForTypo3\Solr\Domain\Search\ResultSet\Result\Parser\ResultParserRegistry;
30		use ApacheSolrForTypo3\Solr\Domain\Search\SearchRequest;
31		use ApacheSolrForTypo3\Solr\Domain\Search\SearchRequestAware;
32		use ApacheSolrForTypo3\Solr\Domain\Variants\VariantsProcessor;
33		use ApacheSolrForTypo3\Solr\Query;
34		use ApacheSolrForTypo3\Solr\Query\Modifier\Modifier;
35		use ApacheSolrForTypo3\Solr\Search;
36		use ApacheSolrForTypo3\Solr\Search\QueryAware;
37		use ApacheSolrForTypo3\Solr\Search\SearchAware;
38		use ApacheSolrForTypo3\Solr\Search\SearchComponentManager;
39		use ApacheSolrForTypo3\Solr\System\Configuration\TypoScriptConfiguration;
40		use ApacheSolrForTypo3\Solr\System\Logging\SolrLogManager;
41		use ApacheSolrForTypo3\Solr\System\Solr\SolrCommunicationException;
42		use ApacheSolrForTypo3\Solr\System\Solr\SolrIncompleteResponseException;
43		use ApacheSolrForTypo3\Solr\System\Solr\SolrInternalServerErrorException;
44		use TYPO3\CMS\Core\Utility\GeneralUtility;
45		use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
46
47		/**
48		* The SearchResultSetService is responsible to build a SearchResultSet from a SearchRequest.
49		* It encapsulates the logic to trigger a search in order to be able to reuse it in multiple places.
50		*
51		* @author Timo Schmidt <[email protected]>
52		*/
53		class SearchResultSetService
54		{
55		/**
56		* Additional filters, which will be added to the query, as well as to
57		* suggest queries.
58		*
59		* @var array
60		*/
61		protected $additionalFilters = [];
62
63		/**
64		* Track, if the number of results per page has been changed by the current request
65		*
66		* @var bool
67		*/
68		protected $resultsPerPageChanged = false;
69
70		/**
71		* @var Search
72		*/
73		protected $search;
74
75		/**
76		* @var SearchResultSet
77		*/
78		protected $lastResultSet = null;
79
80		/**
81		* @var boolean
82		*/
83		protected $isSolrAvailable = false;
84
85		/**
86		* @var TypoScriptConfiguration
87		*/
88		protected $typoScriptConfiguration;
89
90		/**
91		* @var SolrLogManager;
92		*/
93		protected $logger = null;
94
95		/**
96		* @var SearchResultBuilder
97		*/
98		protected $searchResultBuilder;
99
100		/**
101		* @param TypoScriptConfiguration $configuration
102		* @param Search $search
103	45	* @param SolrLogManager $solrLogManager
104		* @param SearchResultBuilder $resultBuilder
105	45	*/
106	45	public function __construct(TypoScriptConfiguration $configuration, Search $search, SolrLogManager $solrLogManager = null, SearchResultBuilder $resultBuilder = null)
107	45	{
108	45	$this->search = $search;
109		$this->typoScriptConfiguration = $configuration;
110		$this->logger = is_null($solrLogManager) ? GeneralUtility::makeInstance(SolrLogManager::class, __CLASS__) : $solrLogManager;
111		$this->searchResultBuilder = is_null($resultBuilder) ? GeneralUtility::makeInstance(SearchResultBuilder::class) : $resultBuilder;
112		}
113
114	29	/**
115		* @param bool $useCache
116	29	* @return bool
117	29	*/
118		public function getIsSolrAvailable($useCache = true)
119		{
120		$this->isSolrAvailable = $this->search->ping($useCache);
121		return $this->isSolrAvailable;
122		}
123	29
124		/**
125	29	* @return bool
126		*/
127		public function getHasSearched()
128		{
129		return $this->search->hasSearched();
130		}
131
132		/**
133	2	* Retrieves the used search instance.
134		*
135	2	* @return Search
136		*/
137		public function getSearch()
138		{
139		return $this->search;
140		}
141
142		/**
143		* Initializes the Query object and SearchComponents and returns
144		* the initialized query object, when a search should be executed.
145		*
146		* @param string\|null $rawQuery
147		* @param int $resultsPerPage
148		* @return Query
149		*/
150		protected function getPreparedQuery($rawQuery, $resultsPerPage)
151		{
152		/* @var $query Query */
153		$query = $this->getQueryInstance($rawQuery);
154
155		$this->applyPageSectionsRootLineFilter($query);
156
157		if ($this->typoScriptConfiguration->getLoggingQuerySearchWords()) {
158		$this->logger->log(
159		SolrLogManager::INFO,
160		'Received search query',
161		[
162	37	$rawQuery
163		]
164		);
165	37	}
166
167	37	$query->setResultsPerPage($resultsPerPage);
168
169	37	if ($this->typoScriptConfiguration->getSearchInitializeWithEmptyQuery() \|\| $this->typoScriptConfiguration->getSearchQueryAllowEmptyQuery()) {
170		// empty main query, but using a "return everything"
171		// alternative query in q.alt
172		$query->setAlternativeQuery(':');
173		}
174
175		if ($this->typoScriptConfiguration->getSearchInitializeWithQuery()) {
176		$query->setAlternativeQuery($this->typoScriptConfiguration->getSearchInitializeWithQuery());
177		}
178
179	37	foreach ($this->getAdditionalFilters() as $additionalFilter) {
180		$query->getFilters()->add($additionalFilter);
181	37	}
182
183		return $query;
184	30	}
185
186		/**
187	37	* @param Query $query
188	3	* @param SearchRequest $searchRequest
189		*/
190		protected function initializeRegisteredSearchComponents(Query $query, SearchRequest $searchRequest)
191	37	{
192	2	$searchComponents = $this->getRegisteredSearchComponents();
193
194		foreach ($searchComponents as $searchComponent) {
195	37	/** @var Search\SearchComponent $searchComponent */
196		$searchComponent->setSearchConfiguration($this->typoScriptConfiguration->getSearchConfiguration());
197
198		if ($searchComponent instanceof QueryAware) {
199		$searchComponent->setQuery($query);
200		}
201
202	37	if ($searchComponent instanceof SearchRequestAware) {
203		$searchComponent->setSearchRequest($searchRequest);
204	37	}
205
206	37	$searchComponent->initializeSearchComponent();
207		}
208	31	}
209
210	31	/**
211	31	* @return string
212		*/
213		protected function getResultSetClassName()
214	31	{
215	30	return isset($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['searchResultSetClassName ']) ?
216		$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['searchResultSetClassName '] : SearchResultSet::class;
217		}
218	31
219		/**
220	37	* Initializes additional filters configured through TypoScript and
221		* Flexforms for use in regular queries and suggest queries.
222		*
223		* @param Query $query
224		* @return void
225		*/
226		protected function applyPageSectionsRootLineFilter(Query $query)
227		{
228		$searchQueryFilters = $this->typoScriptConfiguration->getSearchQueryFilterConfiguration();
229		if (count($searchQueryFilters) <= 0) {
230		return;
231	37	}
232
233	37	// special filter to limit search to specific page tree branches
234	37	if (array_key_exists('__pageSections', $searchQueryFilters)) {
235	37	$query->setRootlineFilter($searchQueryFilters['__pageSections']);
236	4	$this->typoScriptConfiguration->removeSearchQueryFilterForPageSections();
237	4	}
238		}
239
240	37	/**
241	37	* Retrieves the configuration filters from the TypoScript configuration, except the __pageSections filter.
242		*
243	37	* @return array
244	37	*/
245	3	public function getAdditionalFilters()
246		{
247		// when we've build the additionalFilter once, we could return them
248	37	if (count($this->additionalFilters) > 0) {
249		return $this->additionalFilters;
250		}
251
252	2	$searchQueryFilters = $this->typoScriptConfiguration->getSearchQueryFilterConfiguration();
253		if (count($searchQueryFilters) <= 0) {
254		return [];
255	37	}
256
257		$cObj = GeneralUtility::makeInstance(ContentObjectRenderer::class);
258
259		// all other regular filters
260		foreach ($searchQueryFilters as $filterKey => $filter) {
261		// the __pageSections filter should not be handled as additional filter
262		if ($filterKey === '__pageSections') {
263		continue;
264	39	}
265
266	39	$filterIsArray = is_array($searchQueryFilters[$filterKey]);
267	39	if ($filterIsArray) {
268		continue;
269	39	}
270	39
271		$hasSubConfiguration = is_array($searchQueryFilters[$filterKey . '.']);
272		if ($hasSubConfiguration) {
273		$filter = $cObj->stdWrap($searchQueryFilters[$filterKey], $searchQueryFilters[$filterKey . '.']);
274		}
275
276		$this->additionalFilters[$filterKey] = $filter;
277		}
278
279	39	return $this->additionalFilters;
280		}
281	39
282	1	/**
283		* Performs a search and returns a SearchResultSet.
284	1	*
285	1	* @param SearchRequest $searchRequest
286	1	* @return SearchResultSet
287	1	*/
288		public function search(SearchRequest $searchRequest)
289		{
290		/** @var $resultSet SearchResultSet */
291	39	$resultSetClass = $this->getResultSetClassName();
292		$resultSet = GeneralUtility::makeInstance($resultSetClass);
293		$resultSet->setUsedSearchRequest($searchRequest);
294		$this->lastResultSet = $resultSet;
295
296		$resultSet = $this->handleSearchHook('beforeSearch', $resultSet);
297
298		if ($searchRequest->getRawUserQueryIsNull() && !$this->getInitialSearchIsConfigured()) {
299	39	// when no rawQuery was passed or no initialSearch is configured, we pass an empty result set
300		return $resultSet;
301	39	}
302	5
303		if ($searchRequest->getRawUserQueryIsEmptyString() && !$this->typoScriptConfiguration->getSearchQueryAllowEmptyQuery()) {
304		// the user entered an empty query string "" or " " and empty querystring is not allowed
305	34	return $resultSet;
306	31	}
307
308		$rawQuery = $searchRequest->getRawUserQuery();
309	3	$resultsPerPage = (int)$searchRequest->getResultsPerPage();
310	3	$query = $this->getPreparedQuery($rawQuery, $resultsPerPage);
311		$this->initializeRegisteredSearchComponents($query, $searchRequest);
312	2	$resultSet->setUsedQuery($query);
313	2
314		// the offset mulitplier is page - 1 but not less then zero
315		$offsetMultiplier = max(0, $searchRequest->getPage() - 1);
316	2	$offSet = $offsetMultiplier * $resultsPerPage;
317
318		// performing the actual search, sending the query to the Solr server
319		$query = $this->modifyQuery($query, $searchRequest, $this->search);
320	2	$response = $this->doASearch($query, $offSet);
321	2
322		if ($resultsPerPage === 0) {
323		// when resultPerPage was forced to 0 we also set the numFound to 0 to hide results, e.g.
324		// when results for the initial search should not be shown.
325	2	$response->response->numFound = 0;
		0 ignored issues – show Bug introduced 2017-05-29 10:44 UTC by Report Bug Copy Issue Report The property `response` does not seem to exist. Did you mean `_response`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
326	2	}
327	2
328	2	$resultSet->setUsedSearch($this->search);
329		$resultSet->setResponse($response);
330	2
331	2	/** @var ResultParserRegistry $parserRegistry */
332	2	$parserRegistry = GeneralUtility::makeInstance(ResultParserRegistry::class, $this->typoScriptConfiguration);
333		$useRawDocuments = (bool)$this->typoScriptConfiguration->getValueByPathOrDefaultValue('plugin.tx_solr.features.useRawDocuments', false);
334	2	$searchResults = $parserRegistry->getParser($resultSet)->parse($resultSet, $useRawDocuments);
335		$resultSet->setSearchResults($searchResults);
336
337	3	$resultSet->setUsedPage((int)$searchRequest->getPage());
338		$resultSet->setUsedResultsPerPage($resultsPerPage);
339		$resultSet->setUsedAdditionalFilters($this->getAdditionalFilters());
340
341		/** @var $variantsProcessor VariantsProcessor */
342		$variantsProcessor = GeneralUtility::makeInstance(VariantsProcessor::class, $this->typoScriptConfiguration, $this->searchResultBuilder);
343		$variantsProcessor->process($resultSet);
344
345		/** @var $searchResultReconstitutionProcessor ResultSetReconstitutionProcessor */
346		$searchResultReconstitutionProcessor = GeneralUtility::makeInstance(ResultSetReconstitutionProcessor::class);
347		$searchResultReconstitutionProcessor->process($resultSet);
348
349		$resultSet = $this->getAutoCorrection($resultSet);
350
351	39	return $this->handleSearchHook('afterSearch', $resultSet);
352		}
353
354	39	/**
355	1	* Executes the search and builds a fake response for a current bug in Apache Solr 6.3
356		*
357		* @param Query $query
358		* @param int $offSet
359		* @throws SolrCommunicationException
360	1	* @return \Apache_Solr_Response
361		*/
362		protected function doASearch($query, $offSet)
363		{
364	1	try {
365	1	$response = $this->search->search($query, $offSet, null);
366	1	} catch (SolrInternalServerErrorException $e) {
367	1	// when variants are enable and the index is empty, we get a parse exception, because of a
368	1	// Apache Solr Bug.
369		// see: https://github.com/TYPO3-Solr/ext-solr/issues/668
370	1	// @todo this try/catch block can be removed after upgrading to Apache Solr 6.4
371		if (!$this->typoScriptConfiguration->getSearchVariants()) {
372		throw $e;
373	39	}
374	5
375		$response = $e->getSolrResponse();
376
377	34	$parsedData = new \stdClass();
378	28	$parsedData->response = new \stdClass();
379	28	$parsedData->response->docs = [];
380		$parsedData->spellcheck = [];
381		$parsedData->debug = [];
382	34	$parsedData->responseHeader = [];
383	34	$parsedData->facet_counts = [];
384		$parsedData->facets = [];
385		$response->setParsedData($parsedData);
386
387		}
388
389		if($response === null) {
390		throw new SolrIncompleteResponseException('The response retrieved from solr was incomplete', 1505989678);
391		}
392
393	28	return $response;
394		}
395	28
396	28	/**
397	28	* @param SearchResultSet $searchResultSet
398		* @return SearchResultSet
399		*/
400		protected function getAutoCorrection(SearchResultSet $searchResultSet)
401	28	{
402		// no secondary search configured
403		if (!$this->typoScriptConfiguration->getSearchSpellcheckingSearchUsingSpellCheckerSuggestion()) {
404		return $searchResultSet;
405		}
406
407	28	// more then zero results
408		if ($searchResultSet->getAllResultCount() > 0) {
409	28	return $searchResultSet;
410	28	}
411
412		// no corrections present
413		if (!$searchResultSet->getHasSpellCheckingSuggestions()) {
414		return $searchResultSet;
415		}
416	39
417		$searchResultSet = $this->peformAutoCorrection($searchResultSet);
418	39
419	39	return $searchResultSet;
420		}
421
422		/**
423		* @param SearchResultSet $searchResultSet
424		* @return SearchResultSet
425		*/
426		protected function peformAutoCorrection(SearchResultSet $searchResultSet)
427		{
428	37	$searchRequest = $searchResultSet->getUsedSearchRequest();
429		$suggestions = $searchResultSet->getSpellCheckingSuggestions();
430	37
431		$maximumRuns = $this->typoScriptConfiguration->getSearchSpellcheckingNumberOfSuggestionsToTry(1);
432		$runs = 0;
433
434		foreach ($suggestions as $suggestion) {
435		$runs++;
436
437		$correction = $suggestion->getSuggestion();
438		$initialQuery = $searchRequest->getRawUserQuery();
439
440	37	$searchRequest->setRawQueryString($correction);
441		$searchResultSet = $this->search($searchRequest);
442	37	if ($searchResultSet->getAllResultCount() > 0) {
443	37	$searchResultSet->setIsAutoCorrected(true);
444	35	$searchResultSet->setCorrectedQueryString($correction);
445		$searchResultSet->setInitialQueryString($initialQuery);
446		break;
447		}
448	2
449		if ($runs > $maximumRuns) {
450		break;
451		}
452	2	}
453		return $searchResultSet;
454		}
455
456		/**
457		* Allows to modify a query before eventually handing it over to Solr.
458		*
459	42	* @param Query $query The current query before it's being handed over to Solr.
460		* @param SearchRequest $searchRequest The searchRequest, relevant in the current context
461		* @param Search $search The search, relevant in the current context
462	42	* @throws \UnexpectedValueException
463	2	* @return Query The modified query that is actually going to be given to Solr.
464		*/
465		protected function modifyQuery(Query $query, SearchRequest $searchRequest, Search $search)
466	42	{
467	42	// hook to modify the search query
468	40	if (is_array($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['modifySearchQuery'])) {
469		foreach ($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['modifySearchQuery'] as $classReference) {
470		$queryModifier = GeneralUtility::getUserObj($classReference);
471	2
472		if ($queryModifier instanceof Modifier) {
473		if ($queryModifier instanceof SearchAware) {
474	2	$queryModifier->setSearch($search);
475		}
476	2
477		if ($queryModifier instanceof SearchRequestAware) {
478		$queryModifier->setSearchRequest($searchRequest);
479		}
480	2
481	2	$query = $queryModifier->modifyQuery($query);
482		} else {
483		throw new \UnexpectedValueException(
484		get_class($queryModifier) . ' must implement interface ' . Modifier::class,
485	2	1310387414
486	2	);
487		}
488		}
489		}
490	2
491		return $query;
492		}
493	2
494		/**
495		* Retrieves a single document from solr by document id.
496		*
497		* @param string $documentId
498		* @return SearchResult
499		*/
500		public function getDocumentById($documentId)
501		{
502	39	/* @var $query Query */
503		$query = GeneralUtility::makeInstance(Query::class, $documentId);
504		$query->setQueryFields(QueryFields::fromString('id'));
505	39	$response = $this->search->search($query, 0, 1);
506	39	$parsedData = $response->getParsedData();
507	39	$resultDocument = isset($parsedData->response->docs[0]) ? $parsedData->response->docs[0] : null;
508	39
509		return $this->searchResultBuilder->fromApacheSolrDocument($resultDocument);
510	39	}
511
512	39	/**
513		* This method is used to call the registered hooks during the search execution.
514	2	*
515		* @param string $eventName
516		* @param SearchResultSet $resultSet
517	37	* @return SearchResultSet
518		*/
519		private function handleSearchHook($eventName, SearchResultSet $resultSet)
520		{
521		if (!is_array($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr'][$eventName])) {
522	37	return $resultSet;
523	37	}
524	37
525	37	foreach ($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr'][$eventName] as $classReference) {
526	37	$afterSearchProcessor = GeneralUtility::getUserObj($classReference);
527		if ($afterSearchProcessor instanceof SearchResultSetProcessor) {
528	37	$afterSearchProcessor->process($resultSet);
529		}
530	37	}
531	4
532		return $resultSet;
533		}
534	37
535		/**
536		* @return SearchResultSet
537	37	*/
538	37	public function getLastResultSet()
539	37	{
540		return $this->lastResultSet;
541	37	}
542
543		/**
544	2	* This method returns true when the last search was executed with an empty query
545		* string or whitespaces only. When no search was triggered it will return false.
546		*
547	37	* @return bool
548		*/
549	37	public function getLastSearchWasExecutedWithEmptyQueryString()
550		{
551	37	$wasEmptyQueryString = false;
552	37	if ($this->lastResultSet != null) {
553	37	$wasEmptyQueryString = $this->lastResultSet->getUsedSearchRequest()->getRawUserQueryIsEmptyString();
554	37	}
555	37
556		return $wasEmptyQueryString;
557		}
558	37
559	37	/**
560		* @return bool
561	37	*/
562		protected function getInitialSearchIsConfigured()
563		{
564		return $this->typoScriptConfiguration->getSearchInitializeWithEmptyQuery() \|\| $this->typoScriptConfiguration->getSearchShowResultsOfInitialEmptyQuery() \|\| $this->typoScriptConfiguration->getSearchInitializeWithQuery() \|\| $this->typoScriptConfiguration->getSearchShowResultsOfInitialQuery();
565		}
566
567		/**
568		* @return mixed
569		*/
570		protected function getRegisteredSearchComponents()
571		{
572		return GeneralUtility::makeInstance(SearchComponentManager::class)->getSearchComponents();
573	37	}
574
575		/**
576	37	* @param string $rawQuery
577	30	* @return Query\|object
578	30	*/
579		protected function getQueryInstance($rawQuery)
580	30	{
581	30	$query = GeneralUtility::makeInstance(Query::class, $rawQuery, $this->typoScriptConfiguration);
582		return $query;
583		}
584		}
585

timohund / ext-solr

Push — master ( a15d6d...9819c1 )

wrapResultDocumentInResultObject() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like