/** * @test */ public function canGetVariants() { $this->indexPageIdsFromFixture('can_get_searchResultSet.xml', [1, 2, 3, 4, 5, 6, 7, 8]); sleep(1); $solrConnection = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\ConnectionManager')->getConnectionByPageId(1, 0, 0); $typoScriptConfiguration = Util::getSolrConfiguration(); $typoScriptConfiguration->mergeSolrConfiguration(['search.' => ['variants' => 1, 'variants.' => ['variantField' => 'subTitle', 'expand' => 1, 'limit' => 11]]]); $this->assertTrue($typoScriptConfiguration->getSearchVariants(), 'Variants are not enabled'); $this->assertEquals('subTitle', $typoScriptConfiguration->getSearchVariantsField()); $this->assertEquals(11, $typoScriptConfiguration->getSearchVariantsLimit()); $search = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Search', $solrConnection); /** @var $searchResultsSetService \ApacheSolrForTypo3\Solr\Domain\Search\ResultSet\SearchResultSetService */ $searchResultsSetService = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Domain\\Search\\ResultSet\\SearchResultSetService', $typoScriptConfiguration, $search); /** @var $searchRequest SearchRequest */ $searchRequest = GeneralUtility::makeInstance(SearchRequest::class); $searchRequest->setRawQueryString('*'); $searchResultSet = $searchResultsSetService->search($searchRequest); $searchResults = $searchResultSet->getSearchResults(); $firstResult = $searchResults[0]; // We assume that the first result has three variants. $this->assertSame(3, count($firstResult->getVariants())); // And every variant is indicated to be a variant. foreach ($firstResult->getVariants() as $variant) { $this->assertTrue($variant->getIsVariant(), 'Document should be a variant'); } }
/** * Resolves a TS path and returns its value * * @param string $path a TS path, separated with dots * @return string */ protected function resolveTypoScriptPath($path, $arguments = null) { $value = ''; $pathExploded = explode('.', trim($path)); $lastPathSegment = array_pop($pathExploded); /** @var \ApacheSolrForTypo3\Solr\System\Configuration\TypoScriptConfiguration $configuration */ $configuration = Util::getSolrConfiguration(); $pathBranch = $configuration->getObjectByPath($path); // generate ts content $cObj = $this->getContentObject(); if (!isset($pathBranch[$lastPathSegment . '.'])) { $value = htmlspecialchars($pathBranch[$lastPathSegment]); } else { if (count($arguments)) { $data = array('arguments' => $arguments); $numberOfArguments = count($arguments); for ($i = 0; $i < $numberOfArguments; $i++) { $data['argument_' . $i] = $arguments[$i]; } $cObj->start($data); } $value = $cObj->cObjGetSingle($pathBranch[$lastPathSegment], $pathBranch[$lastPathSegment . '.']); } return $value; }
/** * Initializes the search component. * * Sets the debug query parameter * */ public function initializeSearchComponent() { $solrConfiguration = Util::getSolrConfiguration(); if ($solrConfiguration->getEnabledDebugMode()) { $this->query->setDebugMode(); } }
/** * @return TypoScriptConfiguration|array */ protected function getConfiguration() { if ($this->configuration == null) { $this->configuration = Util::getSolrConfiguration(); } return $this->configuration; }
/** * Constructor * * @param array $arguments */ public function __construct(array $arguments = array()) { $configuration = Util::getSolrConfiguration(); if (!empty($configuration['viewhelpers.']['multivalue.']['glue'])) { $this->glue = $configuration['viewhelpers.']['multivalue.']['glue']; } }
/** * Creates a link to a given page with a given link text * * @param array Array of arguments, [0] is the link text, [1] is the (optional) page Id to link to (otherwise TSFE->id), [2] are additional URL parameters, [3] use cache, defaults to FALSE, [4] additional A tag parameters * @return string complete anchor tag with URL and link text */ public function execute(array $arguments = array()) { $linkText = $arguments[0]; $additionalParameters = $arguments[2] ? $arguments[2] : ''; $useCache = $arguments[3] ? true : false; $ATagParams = $arguments[4] ? $arguments[4] : ''; // by default or if no link target is set, link to the current page $linkTarget = $GLOBALS['TSFE']->id; // if the link target is a number, interpret it as a page ID $linkArgument = trim($arguments[1]); if (is_numeric($linkArgument)) { $linkTarget = intval($linkArgument); } elseif (!empty($linkArgument) && is_string($linkArgument)) { /** @var \ApacheSolrForTypo3\Solr\System\Configuration\TypoScriptConfiguration $configuration */ $configuration = Util::getSolrConfiguration(); if ($configuration->isValidPath($linkArgument)) { try { $typoscript = $configuration->getObjectByPath($linkArgument); $pathExploded = explode('.', $linkArgument); $lastPathSegment = array_pop($pathExploded); $linkTarget = intval($typoscript[$lastPathSegment]); } catch (\InvalidArgumentException $e) { // ignore exceptions caused by markers, but accept the exception for wrong TS paths if (substr($linkArgument, 0, 3) != '###') { throw $e; } } } elseif (GeneralUtility::isValidUrl($linkArgument) || GeneralUtility::isValidUrl(GeneralUtility::getIndpEnv('TYPO3_REQUEST_HOST') . '/' . $linkArgument)) { // $linkTarget is an URL $linkTarget = filter_var($linkArgument, FILTER_SANITIZE_URL); } } $linkConfiguration = array('useCacheHash' => $useCache, 'no_cache' => false, 'parameter' => $linkTarget, 'additionalParams' => $additionalParameters, 'ATagParams' => $ATagParams); return $this->contentObject->typoLink($linkText, $linkConfiguration); }
/** * Returns an URL that switches the sorting indicator according to the * given sorting direction * * @param array $arguments Expects 'asc' or 'desc' as sorting direction in key 0 * @return string * @throws \InvalidArgumentException when providing an invalid sorting direction */ public function execute(array $arguments = array()) { $content = ''; $sortDirection = trim($arguments[0]); $configuration = Util::getSolrConfiguration(); $contentObject = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectRenderer'); $defaultImagePrefix = 'EXT:solr/Resources/Public/Images/Indicator'; $sortViewHelperConfiguration = $configuration->getViewHelpersSortIndicatorConfiguration(); switch ($sortDirection) { case 'asc': $imageConfiguration = $sortViewHelperConfiguration['up.']; if (!isset($imageConfiguration['file'])) { $imageConfiguration['file'] = $defaultImagePrefix . 'Up.png'; } $content = $contentObject->cObjGetSingle('IMAGE', $imageConfiguration); break; case 'desc': $imageConfiguration = $sortViewHelperConfiguration['down.']; if (!isset($imageConfiguration['file'])) { $imageConfiguration['file'] = $defaultImagePrefix . 'Down.png'; } $content = $contentObject->cObjGetSingle('IMAGE', $imageConfiguration); break; case '###SORT.CURRENT_DIRECTION###': case '': // ignore break; default: throw new \InvalidArgumentException('Invalid sorting direction "' . $arguments[0] . '", must be "asc" or "desc".', 1390868460); } return $content; }
/** * Renders the block of used / applied facets. * * @return string Rendered HTML representing the used facet. */ public function render() { $solrConfiguration = Util::getSolrConfiguration(); $facetOption = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Facet\\FacetOption', $this->facetName, $this->filterValue); $facetLinkBuilder = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Facet\\LinkBuilder', $this->query, $this->facetName, $facetOption); /* @var $facetLinkBuilder LinkBuilder */ $facetLinkBuilder->setLinkTargetPageId($this->linkTargetPageId); if ($this->facetConfiguration['type'] == 'hierarchy') { // FIXME decouple this $filterEncoder = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Query\\FilterEncoder\\Hierarchy'); $facet = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Facet\\Facet', $this->facetName); $facetRenderer = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Facet\\HierarchicalFacetRenderer', $facet); $facetText = $facetRenderer->getLastPathSegmentFromHierarchicalFacetOption($filterEncoder->decodeFilter($this->filterValue)); } else { $facetText = $facetOption->render(); } $facetText = $this->getModifiedFacetTextFromHook($facetText); $contentObject = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectRenderer'); $facetConfiguration = $solrConfiguration->getSearchFacetingFacetByName($this->facetName); $facetLabel = $contentObject->stdWrap($facetConfiguration['label'], $facetConfiguration['label.']); $removeFacetText = strtr($solrConfiguration->getSearchFacetingRemoveFacetLinkText(), array('@facetValue' => $this->filterValue, '@facetName' => $this->facetName, '@facetLabel' => $facetLabel, '@facetText' => $facetText)); $removeFacetLink = $facetLinkBuilder->getRemoveFacetOptionLink($removeFacetText); $removeFacetUrl = $facetLinkBuilder->getRemoveFacetOptionUrl(); $facetToRemove = array('link' => $removeFacetLink, 'url' => $removeFacetUrl, 'text' => $removeFacetText, 'value' => $this->filterValue, 'facet_name' => $this->facetName); return $facetToRemove; }
/** * Constructor * * @param array $arguments */ public function __construct(array $arguments = array()) { if (is_null($this->dateFormat) || is_null($this->contentObject)) { $configuration = Util::getSolrConfiguration(); $this->dateFormat = $configuration->getValueByPathOrDefaultValue('plugin.tx_solr.general.dateFormat.', array('date' => 'd.m.Y H:i')); $this->contentObject = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectRenderer'); } }
/** * Constructor. * * @param string $facetName Facet Name * @param int|string $facetOptionValue Facet option value * @param int $facetOptionNumberOfResults number of results to be returned when applying this option's filter */ public function __construct($facetName, $facetOptionValue, $facetOptionNumberOfResults = 0) { $this->facetName = $facetName; $this->value = $facetOptionValue; $this->numberOfResults = intval($facetOptionNumberOfResults); $solrConfiguration = Util::getSolrConfiguration(); $this->facetConfiguration = $solrConfiguration->getSearchFacetingFacetByName($this->facetName); }
/** * Constructor * * @param SolrService $solrConnection The Solr connection to use for searching */ public function __construct(SolrService $solrConnection = null) { $this->solr = $solrConnection; if (is_null($solrConnection)) { $this->solr = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\ConnectionManager')->getConnectionByPageId($GLOBALS['TSFE']->id, $GLOBALS['TSFE']->sys_language_uid); } $this->configuration = Util::getSolrConfiguration(); }
/** * Constructor. * * @param string $facetName Facet Name * @param integer|string $facetOptionValue Facet option value * @param integer $facetOptionNumberOfResults number of results to be returned when applying this option's filter */ public function __construct($facetName, $facetOptionValue, $facetOptionNumberOfResults = 0) { $this->facetName = $facetName; $this->value = $facetOptionValue; $this->numberOfResults = intval($facetOptionNumberOfResults); $solrConfiguration = Util::getSolrConfiguration(); $this->facetConfiguration = $solrConfiguration['search.']['faceting.']['facets.'][$this->facetName . '.']; }
/** * Constructor * * @param array $arguments */ public function __construct(array $arguments = array()) { if (is_null($this->dateFormat) || is_null($this->contentObject)) { $configuration = Util::getSolrConfiguration(); $this->dateFormat = $configuration['general.']['dateFormat.']; $this->contentObject = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectRenderer'); } }
/** * Initializes the search component. * */ public function initializeSearchComponent() { $solrConfiguration = Util::getSolrConfiguration(); if (!empty($solrConfiguration['statistics'])) { $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['modifySearchQuery']['statistics'] = 'ApacheSolrForTypo3\\Solr\\Query\\Modifier\\Statistics'; $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['processSearchResponse']['statistics'] = 'ApacheSolrForTypo3\\Solr\\Response\\Processor\\StatisticsWriter'; } }
/** * @param TypoScriptConfiguration $solrConfiguration */ public function __construct($solrConfiguration = null) { if (!is_null($solrConfiguration)) { $this->configuration = $solrConfiguration; } else { $this->configuration = Util::getSolrConfiguration(); } $this->allConfiguredFacets = $this->configuration->getSearchFacetingFacets(); $this->facetRendererFactory = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Facet\\FacetRendererFactory', $this->allConfiguredFacets); }
/** * Constructor */ public function __construct(array $arguments = array()) { $configuration = Util::getSolrConfiguration(); if (!empty($configuration['viewHelpers.']['crop.']['maxLength'])) { $this->maxLength = $configuration['viewHelpers.']['crop.']['maxLength']; } if (!empty($configuration['viewHelpers.']['crop.']['cropIndicator'])) { $this->cropIndicator = $configuration['viewHelpers.']['crop.']['cropIndicator']; } if (isset($configuration['viewHelpers.']['crop.']['cropFullWords'])) { $this->cropFullWords = (bool) $configuration['viewHelpers.']['crop.']['cropFullWords']; } }
/** * Modifies the given query and returns the modified query as result * * @param ResultsCommand $resultCommand The search result command * @param array $resultDocument Result document * @return array The document with fields as array */ public function modifyResultDocument(ResultsCommand $resultCommand, array $resultDocument) { $this->search = $resultCommand->getParentPlugin()->getSearchResultSetService()->getSearch(); // only check whether a BE user is logged in, don't need to check // for enabled score analysis as we wouldn't be here if it was disabled if ($GLOBALS['TSFE']->beUserLogin) { $configuration = Util::getSolrConfiguration(); $queryFields = $configuration->getSearchQueryQueryFields(); $debugData = $this->search->getDebugResponse()->explain->{$resultDocument['id']}; $scoreCalculationService = GeneralUtility::makeInstance(ScoreCalculationService::class); $resultDocument['score_analysis'] = $scoreCalculationService->getRenderedScores($debugData, $queryFields); } return $resultDocument; }
/** * Modifies the given document and returns the modified document as result. * * @param ResultsCommand $resultCommand The search result command * @param array $resultDocument Result document as array * @return array The document with fields as array */ public function modifyResultDocument(ResultsCommand $resultCommand, array $resultDocument) { $this->search = $resultCommand->getParentPlugin()->getSearch(); $configuration = Util::getSolrConfiguration(); $highlightedContent = $this->search->getHighlightedContent(); $highlightFields = GeneralUtility::trimExplode(',', $configuration['search.']['results.']['resultsHighlighting.']['highlightFields'], true); foreach ($highlightFields as $highlightField) { if (!empty($highlightedContent->{$resultDocument['id']}->{$highlightField}[0])) { $fragments = array(); foreach ($highlightedContent->{$resultDocument['id']}->{$highlightField} as $fragment) { $fragments[] = Template::escapeMarkers($fragment); } $resultDocument[$highlightField] = implode(' ' . $configuration['search.']['results.']['resultsHighlighting.']['fragmentSeparator'] . ' ', $fragments); } } return $resultDocument; }
/** * SuggestQuery constructor. * * @param string $keywords * @param TypoScriptConfiguration $solrConfiguration */ public function __construct($keywords, $solrConfiguration = null) { $keywords = (string) $keywords; if ($solrConfiguration == null) { $solrConfiguration = Util::getSolrConfiguration(); } parent::__construct('', $solrConfiguration); $this->configuration = $solrConfiguration->getObjectByPathOrDefault('plugin.tx_solr.suggest.', []); if (!empty($this->configuration['treatMultipleTermsAsSingleTerm'])) { $this->prefix = $this->escape($keywords); } else { $matches = array(); preg_match('/^(:?(.* |))([^ ]+)$/', $keywords, $matches); $fullKeywords = trim($matches[2]); $partialKeyword = trim($matches[3]); $this->setKeywords($fullKeywords); $this->prefix = $this->escape($partialKeyword); } $this->setAlternativeQuery('*:*'); }
/** * Loads the initially defined local lang file * * @return void */ protected function loadLL() { $configuration = Util::getSolrConfiguration(); $this->localLang[$this->languageFile] = $this->languageFactory->getParsedData($this->languageFile, $this->llKey, $GLOBALS['TSFE']->renderCharset, 3); $localLangConfiguration = $configuration->getLocalLangConfiguration(); if (count($localLangConfiguration) == 0) { return; } // Overlaying labels from TypoScript (including fictitious language keys for non-system languages!): foreach ($localLangConfiguration as $language => $overrideLabels) { $language = substr($language, 0, -1); if (is_array($overrideLabels)) { foreach ($overrideLabels as $labelKey => $overrideLabel) { if (!is_array($overrideLabel)) { $this->localLang[$this->languageFile][$language][$labelKey] = array(array('source' => $overrideLabel)); } } } } }
/** * Processes a query and its response after searching for that query. * * @param Query $query The query that has been searched for. * @param \Apache_Solr_Response $response The response for the last query. */ public function processResponse(Query $query, \Apache_Solr_Response $response) { $urlParameters = GeneralUtility::_GP('tx_solr'); $keywords = $query->getKeywords(); $filters = isset($urlParameters['filter']) ? $urlParameters['filter'] : array(); if (empty($keywords)) { // do not track empty queries return; } $keywords = $this->sanitizeString($keywords); $sorting = ''; if (!empty($urlParameters['sort'])) { $sorting = $this->sanitizeString($urlParameters['sort']); } $configuration = Util::getSolrConfiguration(); if ($configuration['search.']['frequentSearches.']['useLowercaseKeywords']) { $keywords = strtolower($keywords); } $ipMaskLength = (int) $configuration['statistics.']['anonymizeIP']; $insertFields = array('pid' => $GLOBALS['TSFE']->id, 'root_pid' => $GLOBALS['TSFE']->tmpl->rootLine[0]['uid'], 'tstamp' => $GLOBALS['EXEC_TIME'], 'language' => $GLOBALS['TSFE']->sys_language_uid, 'num_found' => $response->response->numFound, 'suggestions_shown' => is_object($response->spellcheck->suggestions) ? (int) get_object_vars($response->spellcheck->suggestions) : 0, 'time_total' => $response->debug->timing->time, 'time_preparation' => $response->debug->timing->prepare->time, 'time_processing' => $response->debug->timing->process->time, 'feuser_id' => (int) $GLOBALS['TSFE']->fe_user->user['uid'], 'cookie' => $GLOBALS['TSFE']->fe_user->id, 'ip' => $this->applyIpMask(GeneralUtility::getIndpEnv('REMOTE_ADDR'), $ipMaskLength), 'page' => (int) $urlParameters['page'], 'keywords' => $keywords, 'filters' => serialize($filters), 'sorting' => $sorting, 'parameters' => serialize($response->responseHeader->params)); $GLOBALS['TYPO3_DB']->exec_INSERTquery('tx_solr_statistics', $insertFields); }
/** * Gets a Solr connection. * * Instead of generating a new connection with each call, connections are * kept and checked whether the requested connection already exists. If a * connection already exists, it's reused. * * @param string $host Solr host (optional) * @param integer $port Solr port (optional) * @param string $path Solr path (optional) * @param string $scheme Solr scheme, defaults to http, can be https (optional) * @return SolrService A solr connection. */ public function getConnection($host = '', $port = 8080, $path = '/solr/', $scheme = 'http') { $connection = null; if (empty($host)) { GeneralUtility::devLog('ApacheSolrForTypo3\\Solr\\ConnectionManager::getConnection() called with empty host parameter. Using configuration from TSFE, might be inaccurate. Always provide a host or use the getConnectionBy* methods.', 'solr', 2); $configuration = Util::getSolrConfiguration(); $solrConfiguration = $configuration['solr.']; $host = $solrConfiguration['host']; $port = $solrConfiguration['port']; $path = $solrConfiguration['path']; $scheme = $solrConfiguration['scheme']; } $connectionHash = md5($scheme . '://' . $host . $port . $path); if (!isset(self::$connections[$connectionHash])) { $connection = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\SolrService', $host, $port, $path, $scheme); self::$connections[$connectionHash] = $connection; } return self::$connections[$connectionHash]; }
/** * Constructor. * * @param Facet $facet The facet to render. */ public function __construct(Facet $facet) { $this->search = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Search'); $this->facet = $facet; $this->facetName = $facet->getName(); $this->solrConfiguration = Util::getSolrConfiguration(); $this->facetConfiguration = $this->solrConfiguration['search.']['faceting.']['facets.'][$this->facetName . '.']; $this->linkTargetPageId = $GLOBALS['TSFE']->id; $this->queryLinkBuilder = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Query\\LinkBuilder', $this->search->getQuery()); }
/** * Returns the number of results per Page. * * Also influences how many result documents are returned by the Solr * server as the return value is used in the Solr "rows" GET parameter. * * @return int number of results to show per page */ public function getNumberOfResultsPerPage() { $configuration = Util::getSolrConfiguration(); $resultsPerPageSwitchOptions = GeneralUtility::intExplode(',', $configuration['search.']['results.']['resultsPerPageSwitchOptions']); $solrParameters = array(); $solrPostParameters = GeneralUtility::_POST('tx_solr'); $solrGetParameters = GeneralUtility::_GET('tx_solr'); // check for GET parameters, POST takes precedence if (isset($solrGetParameters) && is_array($solrGetParameters)) { $solrParameters = $solrGetParameters; } if (isset($solrPostParameters) && is_array($solrPostParameters)) { $solrParameters = $solrPostParameters; } if (isset($solrParameters['resultsPerPage']) && in_array($solrParameters['resultsPerPage'], $resultsPerPageSwitchOptions)) { $GLOBALS['TSFE']->fe_user->setKey('ses', 'tx_solr_resultsPerPage', intval($solrParameters['resultsPerPage'])); $this->resultsPerPageChanged = true; } $defaultNumberOfResultsShown = $this->conf['search.']['results.']['resultsPerPage']; $userSetNumberOfResultsShown = $GLOBALS['TSFE']->fe_user->getKey('ses', 'tx_solr_resultsPerPage'); $currentNumberOfResultsShown = $defaultNumberOfResultsShown; if (!is_null($userSetNumberOfResultsShown) && in_array($userSetNumberOfResultsShown, $resultsPerPageSwitchOptions)) { $currentNumberOfResultsShown = (int) $userSetNumberOfResultsShown; } $rawUserQuery = $this->getRawUserQuery(); if (($this->conf['search.']['initializeWithEmptyQuery'] || $this->conf['search.']['initializeWithQuery']) && !$this->conf['search.']['showResultsOfInitialEmptyQuery'] && !$this->conf['search.']['showResultsOfInitialQuery'] && empty($rawUserQuery)) { // initialize search with an empty query, which would by default return all documents // anyway, tell Solr to not return any result documents // Solr will still return facets though $currentNumberOfResultsShown = 0; } return $currentNumberOfResultsShown; }
/** * Gets the document's score. * * @param string $document The result document as serialized array * @return float The document's score * @throws \RuntimeException if the serialized result document array cannot be unserialized */ protected function getScore($document) { $rawDocument = $document; $score = 0; if (is_numeric($document)) { // backwards compatibility GeneralUtility::deprecationLog('You are using an old notation of the ' . 'relevance view helpers. The notation used to be ' . '###RELEVANCE:###RESULT_DOCUMENT.SCORE######, please change ' . 'this to simply provide the whole result document: ' . '###RELEVANCE:###RESULT_DOCUMENT######'); return $document; } $document = unserialize($document); if (is_array($document)) { $score = $document['score']; } else { if ($rawDocument == '###RESULT_DOCUMENT###') { // unresolved marker // may happen when using search.spellchecking.searchUsingSpellCheckerSuggestion // -> ignore } else { $solrConfiguration = Util::getSolrConfiguration(); if ($solrConfiguration['logging.']['exceptions']) { GeneralUtility::devLog('Could not resolve document score for relevance calculation', 'solr', 3, array('rawDocument' => $rawDocument, 'unserializedDocument' => $document)); } throw new \RuntimeException('Could not resolve document score for relevance calculation', 1343670545); } } return $score; }
/** * Constructor * */ public function __construct() { $this->configuration = Util::getSolrConfiguration(); }
/** * Constructor * */ public function __construct($keywords) { $this->solrConfiguration = Util::getSolrConfiguration(); $this->fieldList = array('*', 'score'); $this->setKeywords($keywords); $this->sorting = ''; // What fields to search if (!empty($this->solrConfiguration['search.']['query.']['queryFields'])) { $this->setQueryFieldsFromString($this->solrConfiguration['search.']['query.']['queryFields']); } // What fields to return from Solr if (!empty($this->solrConfiguration['search.']['query.']['returnFields'])) { $this->fieldList = GeneralUtility::trimExplode(',', $this->solrConfiguration['search.']['query.']['returnFields']); } $this->linkTargetPageId = $this->solrConfiguration['search.']['targetPage']; if (empty($this->linkTargetPageId)) { $this->linkTargetPageId = $GLOBALS['TSFE']->id; } $this->id = ++self::$idCount; }
/** * Constructor. * * @param Query $query Solr query */ public function __construct(Query $query) { $this->solrConfiguration = Util::getSolrConfiguration(); $this->contentObject = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectRenderer'); $this->query = $query; $targetPageUid = $this->contentObject->stdWrap($this->solrConfiguration->getSearchTargetPage(), $this->solrConfiguration->getSearchTargetPageConfiguration()); $this->linkTargetPageId = $targetPageUid; }
/** * Constructor * * @param array $arguments */ public function __construct(array $arguments = array()) { $this->search = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Search'); $this->configuration = Util::getSolrConfiguration(); $this->queryLinkBuilder = GeneralUtility::makeInstance('ApacheSolrForTypo3\\Solr\\Query\\LinkBuilder', $this->search->getQuery()); }
/** * Renders an overview of how the score for a certain document has been * calculated. * * @param array $highScores The result document which to analyse * @return string The HTML showing the score analysis */ protected function renderScoreAnalysis(array $highScores) { $configuration = Util::getSolrConfiguration(); $content = ''; $scores = array(); $totalScore = 0; foreach ($highScores as $field => $highScore) { $pattern = '/' . $highScore['field'] . '\\^([\\d.]*)/'; $matches = array(); preg_match_all($pattern, $configuration->getSearchQueryQueryFields(), $matches); $scores[] = ' <td>+ ' . $highScore['score'] . '</td> <td>' . $highScore['field'] . '</td> <td>' . $matches[1][0] . '</td>'; $totalScore += $highScore['score']; } $content = '<table style="width: 100%; border: 1px solid #aaa; font-size: 11px; background-color: #eee;"> <tr style="border-bottom: 2px solid #aaa; font-weight: bold;"><td>Score</td><td>Field</td><td>Boost</td></tr><tr>' . implode('</tr><tr>', $scores) . '</tr> <tr><td colspan="3"><hr style="border-top: 1px solid #aaa; height: 0; padding: 0; margin: 0;" /></td></tr> <tr><td colspan="3">= ' . $totalScore . ' (Inaccurate analysis! Not all parts of the score have been taken into account.)</td></tr> </table>'; return $content; }