function getElasticaTitleEn($querystring)
 {
     if ($querystring != null && $querystring != '') {
         $query = new \Elastica\Query\MultiMatch();
         $query->setFields(array('title_en', 'name'));
         //  $query->setFieldFuzziness('title_en', 0.7);
         //  $query->setFieldMinimumShouldMatch('title_en', '80%');
         //
     } else {
         $query = new \Elastica\Query\MatchAll();
     }
     return $query;
 }
예제 #2
0
 public function searchRelatedEpisodes(Episode $episode, $numberResults = 5)
 {
     $tagtext = implode(" ", $episode->getTags()->toArray());
     $boolQuery = new \Elastica\Query\BoolQuery();
     $multiquery = new \Elastica\Query\MultiMatch();
     $multiquery->setFields(['name', 'description', 'series']);
     $multiquery->setQuery($tagtext);
     $multiquery->setType(\Elastica\Query\MultiMatch::TYPE_MOST_FIELDS);
     $boolQuery->addMust($multiquery);
     $activeQuery = new \Elastica\Query\Term();
     $activeQuery->setTerm('is_active', true);
     $boolQuery->addMust($activeQuery);
     $excludeEpisodeQuery = new \Elastica\Query\Term();
     $excludeEpisodeQuery->setTerm('id', $episode->getId());
     $boolQuery->addMustNot($excludeEpisodeQuery);
     return $this->episodeFinder->find($boolQuery, $numberResults);
 }
 /**
  * @param $ort string
  * @param $items string[]
  * @return SearchResult
  */
 public function search($ort, $items)
 {
     $result = new SearchResult();
     $ortQuery = new \Elastica\Query\MultiMatch();
     $ortQuery->setFields(["ORT", "PLZ"]);
     $ortQuery->setFuzziness(1);
     $ortQuery->setQuery($ort);
     $result->setOrte($this->marktFinder->find($ortQuery));
     $results = array();
     foreach ($items as $item) {
         $artikelQuery = new \Elastica\Query\Match();
         $artikelQuery->setFieldQuery("slugs", $item);
         $artikelQuery->setFieldFuzziness("slugs", 1.5);
         $results[] = $this->artikelFinder->find($artikelQuery);
     }
     $result->setItems($results);
     return $result;
 }
예제 #4
0
 /**
  * @Route("/app/search", name="search")
  * @Template("AppBundle::search.html.twig")
  */
 public function searchAction(Request $request)
 {
     $q = $request->query->get('q');
     $finder = $this->get('fos_elastica.finder.app');
     $tenantHelper = $this->get('multi_tenant.helper');
     $boolQuery = new \Elastica\Query\BoolQuery();
     $fieldQuery = new \Elastica\Query\MultiMatch();
     $fieldQuery->setQuery($q);
     $fieldQuery->setFields(['_all']);
     $boolQuery->addMust($fieldQuery);
     $tenantQuery = new \Elastica\Query\Term();
     $tenantQuery->setTerm('id', $tenantHelper->getCurrentTenant()->getId());
     $nestedQuery = new \Elastica\Query\Nested();
     $nestedQuery->setPath('tenant');
     $nestedQuery->setQuery($tenantQuery);
     $boolQuery->addMust($nestedQuery);
     $results = $finder->findPaginated($boolQuery);
     return ['results' => $results, 'query' => $q];
 }
예제 #5
0
 public function searchindexAction($searchTerm)
 {
     $client = new \Elastica\Client(array('host' => '192.168.15.102', 'port' => 9200));
     $index = $client->getIndex('coolcities');
     $multiMatchQuery = new \Elastica\Query\MultiMatch();
     $multiMatchQuery->setQuery($searchTerm);
     $multiMatchQuery->setFields(array('title', 'description', 'city^3'));
     // Create the actual search object with some data.
     $esQuery = new \Elastica\Query();
     $esQuery->setQuery($multiMatchQuery);
     //Search on the index.
     $results = $index->search($esQuery);
     foreach ($results as $result) {
         echo "<pre>";
         print_r($result);
         echo "<pre>";
     }
     die;
     return new Response('index search');
 }
예제 #6
0
 public function search(SiteSearch $siteSearch)
 {
     // We create a query to return all the articles but if the criteria text is specified, we use it
     if ($siteSearch->getText() != null && $siteSearch != '') {
         $baseQuery = new \Elastica\Query\MultiMatch();
         $baseQuery->setQuery($siteSearch->getText())->setFields(array('title', 'subtitle', 'courseContent', 'content'));
         $baseQuery->setFuzziness(0.7);
         $baseQuery->setMinimumShouldMatch('80%');
     } else {
         $baseQuery = new \Elastica\Query\MatchAll();
     }
     // Then we create filters depending on the chosen criterias
     // Filter courses only if type is not "product"
     $productTypeFilter = new \Elastica\Filter\Type();
     $productTypeFilter->setType('product');
     $productNotFilter = new \Elastica\Filter\BoolNot($productTypeFilter);
     // Filter for products with available courses
     $nestedFilter = new \Elastica\Filter\Nested();
     $nestedFilter->setPath('courses');
     $nestedFilter->setQuery(new \Elastica\Query\Range('beginDate', array('gte' => \Elastica\Util::convertDate((new \DateTime())->getTimestamp()))));
     // Filter not(products) OR products with available courses
     $orFilter = new \Elastica\Filter\BoolOr();
     $orFilter->addFilter($productNotFilter);
     $orFilter->addFilter($nestedFilter);
     // Create a bool filter to put everything together
     $boolFilter = new \Elastica\Filter\Bool();
     $boolFilter->addMust($orFilter);
     // Filter type
     if ($siteSearch->getIsProduct() || $siteSearch->getIsInfoEvent() || $siteSearch->getIsContent()) {
         // Create OR filter to put together the types
         $typeOrFilter = new \Elastica\Filter\BoolOr();
         // Filter products
         if ($siteSearch->getIsProduct()) {
             $productAndFilter = new \Elastica\Filter\BoolAnd();
             $productAndFilter->addFilter($productTypeFilter);
             $infoFilter = new \Elastica\Filter\Term(array('infoVa' => false));
             $productAndFilter->addFilter($infoFilter);
             $typeOrFilter->addFilter($productAndFilter);
         }
         // Filter info events if isProduct is not selected
         if ($siteSearch->getIsInfoEvent()) {
             $productAndFilter = new \Elastica\Filter\BoolAnd();
             $productAndFilter->addFilter($productTypeFilter);
             $infoFilter = new \Elastica\Filter\Term(array('infoVa' => true));
             $productAndFilter->addFilter($infoFilter);
             $typeOrFilter->addFilter($productAndFilter);
         }
         // Filter content
         if ($siteSearch->getIsContent()) {
             $typeOrFilter->addFilter($productNotFilter);
         }
         $boolFilter->addMust($typeOrFilter);
     }
     // Filter product type
     if ($siteSearch->getProductType()) {
         $productTypeFilter = new \Elastica\Filter\Nested();
         $productTypeFilter->setPath('productType');
         $productTypeFilter->setFilter(new \Elastica\Filter\Term(array('productType._id' => $siteSearch->getProductType()->getId())));
         $boolFilter->addMust($productTypeFilter);
     }
     // Filter day time
     if ($siteSearch->getDayTime()) {
         $dayTimeFilter = new \Elastica\Filter\Nested();
         $dayTimeFilter->setPath('courses');
         $dayTimeFilter->setFilter(new \Elastica\Filter\Term(array('courses.dayTimes' => $siteSearch->getDayTime())));
         $boolFilter->addMust($dayTimeFilter);
     }
     // Filter category
     if ($siteSearch->getCategory()) {
         $categoryFilter = new \Elastica\Filter\BoolOr();
         $mainCategoryFilter = new \Elastica\Filter\Nested();
         $mainCategoryFilter->setPath('category');
         $mainCategoryFilter->setFilter(new \Elastica\Filter\Term(array('category._id' => $siteSearch->getCategory()->getId())));
         $subCategoryFilter = new \Elastica\Filter\Nested();
         $subCategoryFilter->setPath('subcategory');
         $subCategoryFilter->setFilter(new \Elastica\Filter\Term(array('subcategory._id' => $siteSearch->getCategory()->getId())));
         $additionalCategoryFilter = new \Elastica\Filter\Nested();
         $additionalCategoryFilter->setPath('additionalCategories');
         $additionalCategoryFilter->setFilter(new \Elastica\Filter\Term(array('additionalCategories._id' => $siteSearch->getCategory()->getId())));
         $categoryFilter->addFilter($mainCategoryFilter);
         $categoryFilter->addFilter($subCategoryFilter);
         $categoryFilter->addFilter($additionalCategoryFilter);
         $boolFilter->addMust($categoryFilter);
     }
     $filtered = new \Elastica\Query\Filtered($baseQuery, $boolFilter);
     $query = \Elastica\Query::create($filtered);
     $sort = $siteSearch->getSort();
     if (!empty($sort)) {
         $sort = explode(' ', $sort);
         $query->setSort(array($sort[0] => array('order' => $sort[1]), "_score" => array('order' => 'desc')));
     }
     $paginated = $this->finder->findPaginated($query);
     $paginated->setMaxPerPage($siteSearch->getPerPage())->setCurrentPage($siteSearch->getPage());
     return $paginated;
 }
 /**
  * Run the search against a sanitized query string via ElasticSearch.
  *
  * @param string $string
  * @param array $scriptProperties The scriptProperties array from the SimpleSearch snippet
  * @return array
  */
 public function search($string, array $scriptProperties = array())
 {
     $fields = $this->modx->getOption('sisea.elastic.search_fields', null, 'pagetitle^20,introtext^10,alias^5,content^1');
     $fields = explode(',', $fields);
     $fields = array_map('trim', $fields);
     $fields = array_keys(array_flip($fields));
     $fields = array_filter($fields);
     if (empty($fields)) {
         return false;
     }
     /** @var \Elastica\Query\MultiMatch $query */
     $query = new \Elastica\Query\MultiMatch();
     $query->setFields($fields);
     $query->setQuery($string);
     $customFilterScore = new \Elastica\Query\CustomFiltersScore();
     $customFilterScore->setQuery($query);
     $searchBoosts = $this->modx->getOption('sisea.elastic.search_boost', null, '');
     $searchBoosts = explode('|', $searchBoosts);
     $searchBoosts = array_map('trim', $searchBoosts);
     $searchBoosts = array_keys(array_flip($searchBoosts));
     $searchBoosts = array_filter($searchBoosts);
     $boosts = array();
     foreach ($searchBoosts as $boost) {
         $arr = array('field' => '', 'value' => '', 'boost' => 1.0);
         $field = explode('=', $boost);
         $field = array_map('trim', $field);
         $field = array_keys(array_flip($field));
         $field = array_filter($field);
         if (count($field) != 2) {
             continue;
         }
         $value = explode('^', $field[1]);
         $value = array_map('trim', $value);
         $value = array_keys(array_flip($value));
         $value = array_filter($value);
         if (count($value) != 2) {
             continue;
         }
         $arr['field'] = $field[0];
         $arr['value'] = $value[0];
         $arr['boost'] = $value[1];
         $boosts[] = $arr;
     }
     if (empty($boosts)) {
         $customFilterScore->addFilter(new \Elastica\Filter\Term(array('type' => 'document')), 1);
     } else {
         foreach ($boosts as $boost) {
             $customFilterScore->addFilter(new \Elastica\Filter\Term(array($boost['field'] => $boost['value'])), $boost['boost']);
         }
     }
     /** @var \Elastica\Query $elasticaQuery */
     $elasticaQuery = new \Elastica\Query();
     $elasticaQuery->setQuery($customFilterScore);
     /* set limit */
     $perPage = $this->modx->getOption('perPage', $scriptProperties, 10);
     if (!empty($perPage)) {
         $offset = $this->modx->getOption('start', $scriptProperties, 0);
         $offsetIndex = $this->modx->getOption('offsetIndex', $scriptProperties, 'sisea_offset');
         if (isset($_REQUEST[$offsetIndex])) {
             $offset = (int) $_REQUEST[$offsetIndex];
         }
         $elasticaQuery->setFrom($offset);
         $elasticaQuery->setSize($perPage);
     }
     $elasticaFilterAnd = new \Elastica\Filter\BoolAnd();
     /* handle hidemenu option */
     $hideMenu = $this->modx->getOption('hideMenu', $scriptProperties, 2);
     if ($hideMenu != 2) {
         $elasticaFilterHideMenu = new \Elastica\Filter\Term();
         $elasticaFilterHideMenu->setTerm('hidemenu', $hideMenu ? 1 : 0);
         $elasticaFilterAnd->addFilter($elasticaFilterHideMenu);
     }
     /* handle contexts */
     $contexts = $this->modx->getOption('contexts', $scriptProperties, '');
     $contexts = !empty($contexts) ? $contexts : $this->modx->context->get('key');
     $contexts = explode(',', $contexts);
     $elasticaFilterContext = new \Elastica\Filter\Terms();
     $elasticaFilterContext->setTerms('context_key', $contexts);
     $elasticaFilterAnd->addFilter($elasticaFilterContext);
     /* handle restrict search to these IDs */
     $ids = $this->modx->getOption('ids', $scriptProperties, '');
     if (!empty($ids)) {
         $idType = $this->modx->getOption('idType', $this->config, 'parents');
         $depth = $this->modx->getOption('depth', $this->config, 10);
         $ids = $this->processIds($ids, $idType, $depth);
         $elasticaFilterId = new \Elastica\Filter\Term();
         $elasticaFilterId->setTerm('id', $ids);
         $elasticaFilterAnd->addFilter($elasticaFilterId);
     }
     /* handle exclude IDs from search */
     $exclude = $this->modx->getOption('exclude', $scriptProperties, '');
     if (!empty($exclude)) {
         $exclude = $this->cleanIds($exclude);
         $exclude = explode(',', $exclude);
         $elasticaFilterExcludeId = new \Elastica\Filter\Term();
         $elasticaFilterExcludeId->setTerm('id', $exclude);
         $elasticaFilterNotId = new \Elastica\Filter\BoolNot($elasticaFilterExcludeId);
         $elasticaFilterAnd->addFilter($elasticaFilterNotId);
     }
     /* basic always-on conditions */
     $elasticaFilterPublished = new \Elastica\Filter\Term();
     $elasticaFilterPublished->setTerm('published', 1);
     $elasticaFilterAnd->addFilter($elasticaFilterPublished);
     $elasticaFilterSearchable = new \Elastica\Filter\Term();
     $elasticaFilterSearchable->setTerm('searchable', 1);
     $elasticaFilterAnd->addFilter($elasticaFilterSearchable);
     $elasticaFilterDeleted = new \Elastica\Filter\Term();
     $elasticaFilterDeleted->setTerm('deleted', 0);
     $elasticaFilterAnd->addFilter($elasticaFilterDeleted);
     $elasticaQuery->setFilter($elasticaFilterAnd);
     /* sorting */
     if (!empty($scriptProperties['sortBy'])) {
         $sortDir = $this->modx->getOption('sortDir', $scriptProperties, 'desc');
         $sortDirs = explode(',', $sortDir);
         $sortBys = explode(',', $scriptProperties['sortBy']);
         $dir = 'desc';
         $sortArray = array();
         for ($i = 0; $i < count($sortBys); $i++) {
             if (isset($sortDirs[$i])) {
                 $dir = $sortDirs[$i];
             }
             $sortArray[] = array($sortBys[$i] => $dir);
         }
         $elasticaQuery->setSort($sortArray);
     }
     /* prepare response array */
     $response = array('total' => 0, 'start' => !empty($offset) ? $offset : 0, 'limit' => $perPage, 'status' => 0, 'query_time' => 0, 'results' => array());
     $elasticaResultSet = $this->index->search($elasticaQuery);
     $elasticaResults = $elasticaResultSet->getResults();
     $totalResults = $elasticaResultSet->getTotalHits();
     if ($totalResults > 0) {
         $response['total'] = $totalResults;
         $response['query_time'] = $elasticaResultSet->getTotalTime();
         $response['status'] = 1;
         $response['results'] = array();
         foreach ($elasticaResults as $doc) {
             $d = $doc->getData();
             /** @var modResource $resource */
             $resource = $this->modx->newObject($d['class_key']);
             if ($resource->checkPolicy('list')) {
                 $response['results'][] = $d;
             }
         }
     }
     return $response;
 }
예제 #8
0
 public function catsucheAction($catid, Request $request)
 {
     $em = $this->getDoctrine()->getManager();
     $mainCat = [];
     $page = 0;
     $pageOffset = 0;
     if ($request->query->get('p')) {
         $page = $request->query->get('p');
         $pageOffset = ($page - 1) * 12;
     }
     $finder = $this->container->get('fos_elastica.finder.search.articles');
     $boolQuery = new \Elastica\Query\BoolQuery();
     if ($request->query->get('q') !== NULL) {
         $searchTerm = $request->query->get('q');
         $fieldQuery = new \Elastica\Query\MultiMatch();
         $fieldQuery->setFields(array('shortName', 'shortDescription', 'longDescription'));
         $fieldQuery->setAnalyzer('custom_search_analyzer');
         $fieldQuery->setOperator('AND');
         $fieldQuery->setQuery($searchTerm);
         $boolQuery->addMust($fieldQuery);
     }
     $categoryQuery = new \Elastica\Query\Terms();
     $categoryQuery->setTerms('catRef', array($catid));
     $boolQuery->addMust($categoryQuery);
     $query = new \Elastica\Query();
     $query->setQuery($boolQuery);
     $query->setSize(10000000);
     $totalpages = ceil(count($finder->find($query)) / 12);
     $query->setSize(12);
     $query->setFrom($pageOffset);
     $articles = $finder->find($query);
     return $this->render('OrthIndexBundle:Shop:kategorien.html.twig', array('articles' => $articles, 'page' => $page, 'totalpages' => $totalpages, 'categories' => $mainCat));
 }
 /**
  * Builds a multi match query with the cross_field type.
  *
  * @param array $boostedField of boosted fields
  * @param string $queryString the query
  * @param string $minShouldMatch the MinimumShouldMatch value
  * @return \Elastica\Query\MultiMatch
  */
 private function buildCrossFields(array $boostedFields, $queryString, $minShouldMatch)
 {
     $fields = array();
     foreach ($boostedFields as $f) {
         $fields[] = $f['field'] . '^' . $f['boost'];
     }
     $cross = new \Elastica\Query\MultiMatch();
     $cross->setQuery($queryString);
     $cross->setFields($fields);
     $cross->setType('cross_fields');
     $cross->setMinimumShouldMatch($minShouldMatch);
     return $cross;
 }