public function findWithTenant($searchText, $tenantId, $sortDirection = 'desc')
{
$boolFilter = new Filter\Bool();
$boolFilter->addMust(new Filter\Term(['tenant.id' => $tenantId]));
$boolQuery = new Query\Bool();
if ($searchText !== null) {
$fieldQuery = new Query\MultiMatch();
$fieldQuery->setQuery("*" . $searchText . "*");
$fieldQuery->setFields(['name', 'description']);
$boolQuery->addMust($fieldQuery);
}
$filtered = new Query\Filtered($boolQuery, $boolFilter);
$query = Query::create($filtered);
$query->addSort(['created_at' => $sortDirection]);
return $this->findPaginated($query);
}
/**
* Sets rescoreQuery object.
*
* @param string|\Elastica\Query|\Elastica\Query\AbstractQuery $query
*
* @return $this
*/
public function setRescoreQuery($rescoreQuery)
{
$rescoreQuery = BaseQuery::create($rescoreQuery);
$query = $this->getParam('query');
$query['rescore_query'] = $rescoreQuery;
return $this->setParam('query', $query);
}
/**
* Sets query object
*
* @param string|\Elastica\Query|\Elastica\Query\AbstractQuery $query
* @return \Elastica\Query\TopChildren
*/
public function setQuery($query)
{
$query = BaseQuery::create($query);
$data = $query->toArray();
return $this->setParam('query', $data['query']);
}
public function testSetSort()
{
$index = $this->_createIndex();
$type = $index->getType('test');
$doc = new Document(1, array('name' => 'hello world'));
$type->addDocument($doc);
$doc = new Document(2, array('firstname' => 'guschti', 'lastname' => 'ruflin'));
$type->addDocument($doc);
$doc = new Document(3, array('firstname' => 'nicolas', 'lastname' => 'ruflin'));
$type->addDocument($doc);
$queryTerm = new Term();
$queryTerm->setTerm('lastname', 'ruflin');
$index->refresh();
$query = Query::create($queryTerm);
// ASC order
$query->setSort(array(array('firstname' => array('order' => 'asc'))));
$resultSet = $type->search($query);
$this->assertEquals(2, $resultSet->count());
$first = $resultSet->current()->getData();
$second = $resultSet->next()->getData();
$this->assertEquals('guschti', $first['firstname']);
$this->assertEquals('nicolas', $second['firstname']);
// DESC order
$query->setSort(array('firstname' => array('order' => 'desc')));
$resultSet = $type->search($query);
$this->assertEquals(2, $resultSet->count());
$first = $resultSet->current()->getData();
$second = $resultSet->next()->getData();
$this->assertEquals('nicolas', $first['firstname']);
$this->assertEquals('guschti', $second['firstname']);
}
/**
* Performs a search query and returns either a ResultList (SS template compatible) or an Elastica\ResultSet
* @param \Elastica\Query|string|array $query
* @param array $options Options defined in \Elastica\Search
* @param bool $returnResultList
* @return ResultList
*/
public function search($query, $options = null, $returnResultList = true)
{
if ($returnResultList) {
return new ResultList($this->getIndex(), Query::create($query), $this->logger);
}
return $this->getIndex()->search($query, $options);
}
/**
* @group functional
*/
public function testMappingStoreFields()
{
$client = $this->_getClient();
$index = $client->getIndex('test');
$index->create(array(), true);
$type = $index->getType('test');
$mapping = new Mapping($type, array('firstname' => array('type' => 'string', 'store' => true), 'lastname' => array('type' => 'string')));
$mapping->disableSource();
$type->setMapping($mapping);
$firstname = 'Nicolas';
$doc = new Document(1, array('firstname' => $firstname, 'lastname' => 'Ruflin'));
$type->addDocument($doc);
$index->refresh();
$queryString = new QueryString('ruflin');
$query = Query::create($queryString);
$query->setFields(array('*'));
$resultSet = $type->search($query);
$result = $resultSet->current();
$fields = $result->getFields();
$this->assertEquals($firstname, $fields['firstname'][0]);
$this->assertArrayNotHasKey('lastname', $fields);
$this->assertEquals(1, count($fields));
$index->flush();
$document = $type->getDocument(1);
$this->assertEmpty($document->getData());
$index->delete();
}
/**
* Sets rescoreQuery object.
*
* @param string|\Elastica\Query|\Elastica\Query\AbstractQuery $query
*
* @return $this
*/
public function setRescoreQuery($rescoreQuery)
{
$query = BaseQuery::create($rescoreQuery);
$data = $query->toArray();
$query = $this->getParam('query');
$query['rescore_query'] = $data['query'];
return $this->setParam('query', $query);
}
public function testFindHybridMethodTransformsSearchResults()
{
$transformer = $this->createMockTransformer('hybridTransform');
$query = Query::create('');
$limit = 10;
$finder = $this->createMockFinderForSearch($transformer, $query, $limit);
$finder->findHybrid($query, $limit);
}
public function autocomplete($term, $limit = 10)
{
$fuzzyQuery = new \Elastica\Query\FuzzyLikeThis();
$fuzzyQuery->addFields(['nameTranslatableRU', 'nameTranslatableEN']);
$fuzzyQuery->setLikeText($term);
//$baseQuery = $prefixQuery;
$filtered = new \Elastica\Query\Filtered($fuzzyQuery);
$query = \Elastica\Query::create($filtered);
return $this->find($query, $limit);
}
public function autocomplete($term, $limit = 10)
{
if ($term != null) {
$prefixQuery = new \Elastica\Query\Prefix();
$prefixQuery->setPrefix('tag.name', $term);
} else {
$prefixQuery = new \Elastica\Query\MatchAll();
}
$baseQuery = $prefixQuery;
$filtered = new \Elastica\Query\Filtered($baseQuery);
$query = \Elastica\Query::create($filtered);
return $this->find($query, $limit);
}
/**
* @group functional
*/
public function testFuzzySuggestWorks()
{
$suggest = new Completion('suggestName', 'fieldName');
$suggest->setFuzzy(array('fuzziness' => 2));
$suggest->setText('Neavermint');
$index = $this->_getIndexForTest();
$resultSet = $index->search(Query::create($suggest));
$this->assertTrue($resultSet->hasSuggests());
$suggests = $resultSet->getSuggests();
$options = $suggests['suggestName'][0]['options'];
$this->assertCount(1, $options);
$this->assertEquals('Nevermind - Nirvana', $options[0]['text']);
}
public function searchAdvanced($q = '')
{
if ($q == '') {
$baseQuery = new \Elastica\Query\MatchAll();
} else {
$baseQuery = new \Elastica\Query\Match();
$baseQuery->setFieldQuery('description', $q);
$baseQuery->setFieldFuzziness('description', 0.7);
$baseQuery->setFieldMinimumShouldMatch('description', '80%');
}
$boolFilter = new \Elastica\Filter\BoolFilter();
$dateFrom = new \DateTime();
$dateFrom->sub(new \DateInterval('P7D'));
$dateTo = new \DateTime();
$dateTo->add(new \DateInterval('P1D'));
$boolFilter->addMust(new \Elastica\Filter\Range('createdAt', array('gte' => \Elastica\Util::convertDate($dateFrom->getTimestamp()), 'lte' => \Elastica\Util::convertDate($dateTo->getTimestamp()))));
/*
* $boolFilter->addMust(
* new \Elastica\Filter\Term(array('isPublished' => true))
* );
* $boolFilter->addMust(
* new \Elastica\Filter\Terms('isPublished', array('1', '2', '3'))
* );
*/
/*
* $baseQuery = new \Elastica\Filter\Bool();
* $baseQuery->addShould(
* new \Elastica\Filter\Term(array('id' => intval($q)))
* );
* $baseQuery->addShould(
* new \Elastica\Filter\Term(array('amount' => floatval($q)))
* );
* $filtered = new \Elastica\Query\Filtered();
* $filtered->setFilter($baseQuery);
* return $this->finder->find($filtered);
*/
/*
* $baseQuery = new \Elastica\Query\Bool;
* $idQueryTerm = new \Elastica\Query\Term;
* $idQueryTerm->setTerm('id', intval($q));
* $baseQuery->addShould($idQueryTerm);
*/
$filtered = new \Elastica\Query\Filtered($baseQuery, $boolFilter);
$query = \Elastica\Query::create($filtered);
$query->addSort(array('id' => array('order' => 'asc')));
$query->setSize(1);
return $this->find($query);
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$indexName = $input->getOption('index');
/** @var $index \Elastica\Index */
$index = $this->getContainer()->get('fos_elastica.index_manager')->getIndex($indexName ? $indexName : null);
$type = $index->getType($input->getArgument('type'));
$query = Query::create($input->getArgument('query'));
$query->setSize($input->getOption('limit'));
if ($input->getOption('explain')) {
$query->setExplain(true);
}
$resultSet = $type->search($query);
$output->writeLn(sprintf('Found %d results', $type->count($query)));
foreach ($resultSet->getResults() as $result) {
$output->writeLn($this->formatResult($result, $input->getOption('show-field'), $input->getOption('show-source'), $input->getOption('show-id'), $input->getOption('explain')));
}
}
public function testPartialFailure()
{
$client = $this->_getClient();
$index = $client->getIndex('elastica_partial_failure');
$index->create(array('index' => array('number_of_shards' => 5, 'number_of_replicas' => 0)), true);
$type = $index->getType('folks');
$type->addDocument(new Document('', array('name' => 'ruflin')));
$type->addDocument(new Document('', array('name' => 'bobrik')));
$type->addDocument(new Document('', array('name' => 'kimchy')));
$index->refresh();
$query = Query::create(array('query' => array('filtered' => array('filter' => array('script' => array('script' => 'doc["undefined"] > 8'))))));
try {
$index->search($query);
$this->fail('PartialShardFailureException should have been thrown');
} catch (PartialShardFailureException $e) {
$resultSet = new ResultSet($e->getResponse(), $query);
$this->assertEquals(0, count($resultSet->getResults()));
}
}
public function testElasticaSubscriber()
{
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new ElasticaQuerySubscriber());
$dispatcher->addSubscriber(new MockPaginationSubscriber());
// pagination view
$p = new Paginator($dispatcher);
$query = Query::create(new Term(array('name' => 'Fred')));
$response = $this->getMockBuilder('Elastica\\ResultSet')->disableOriginalConstructor()->getMock();
$response->expects($this->once())->method('getTotalHits')->will($this->returnValue(2));
$response->expects($this->once())->method('getResults')->will($this->returnValue(array(new Result(array()), new Result(array()))));
$searchable = $this->getMockBuilder('Elastica\\SearchableInterface')->getMock();
$searchable->expects($this->once())->method('search')->with($query)->will($this->returnValue($response));
$view = $p->paginate(array($searchable, $query), 1, 10);
$this->assertEquals(0, $query->getParam('from'), 'Query offset set correctly');
$this->assertEquals(10, $query->getParam('size'), 'Query limit set correctly');
$this->assertSame($response, $view->getCustomParameter('resultSet'), 'Elastica ResultSet available in Paginator');
$this->assertEquals(1, $view->getCurrentPageNumber());
$this->assertEquals(10, $view->getItemNumberPerPage());
$this->assertEquals(2, count($view->getItems()));
$this->assertEquals(2, $view->getTotalItemCount());
}
public function searchAdvanced(AdvancedSearch $advancedSearch)
{
if (!$advancedSearch->innerObjectIsDefine()) {
$match = new \Elastica\Query\MatchAll();
} else {
$match = new \Elastica\Query\BoolQuery();
if ($advancedSearch->getMarque()) {
$match->addMust(new \Elastica\Query\Match('modeleMarque.marque.id', $advancedSearch->getMarque()));
}
if ($advancedSearch->getModele()) {
$match->addMust(new \Elastica\Query\Match('modeleMarque.modele.id', $advancedSearch->getModele()));
}
if ($advancedSearch->getBoitier()) {
$match->addMust(new \Elastica\Query\Match('boitier.id', $advancedSearch->getBoitier()));
}
if ($advancedSearch->getCarburant()) {
$match->addMust(new \Elastica\Query\Match('carburant.id', $advancedSearch->getCarburant()));
}
}
$boolFilter = new \Elastica\Filter\BoolFilter();
if ($advancedSearch->getPrixMin()) {
$boolFilter->addMust(new \Elastica\Filter\Range('prix', array('gte' => intval($advancedSearch->getPrixMin()))));
}
if ($advancedSearch->getPrixMax()) {
$boolFilter->addMust(new \Elastica\Filter\Range('prix', array('lte' => $advancedSearch->getPrixMax())));
}
if ($advancedSearch->getKmMin()) {
$boolFilter->addMust(new \Elastica\Filter\Range('kmParcouru', array('gte' => intval($advancedSearch->getKmMin()))));
}
if ($advancedSearch->getKmMax()) {
$boolFilter->addMust(new \Elastica\Filter\Range('kmParcouru', array('lte' => $advancedSearch->getKmMax())));
}
$filtered = new \Elastica\Query\Filtered($match, $boolFilter);
$query = \Elastica\Query::create($filtered);
return $this->find($query);
}
/**
* @return \Elastica\Query
*/
public function getQuery()
{
if (null === $this->_query) {
$this->_query = Query::create('');
}
return $this->_query;
}
/**
* More like this query based on the given object
*
* The id in the given object has to be set
*
* @param \Elastica\Document $doc Document to query for similar objects
* @param array $params OPTIONAL Additional arguments for the query
* @param string|array|\Elastica\Query $query OPTIONAL Query to filter the moreLikeThis results
* @return \Elastica\ResultSet ResultSet with all results inside
* @link http://www.elasticsearch.org/guide/reference/api/more-like-this.html
*/
public function moreLikeThis(Document $doc, $params = array(), $query = array())
{
$path = $doc->getId() . '/_mlt';
$query = Query::create($query);
$response = $this->request($path, Request::GET, $query->toArray(), $params);
return new ResultSet($response, $query);
}
/**
* Performs a search query and returns a result list.
*
* @param \Elastica\Query|string|array $query
* @return ResultList
*/
public function search($query)
{
return new ResultList($this->getIndex(), Query::create($query));
}
public function search($category)
{
// we create a query to return all the articles
// but if the criteria title is specified, we use it
$boolQuery = new \Elastica\Query\Bool();
/*Fetch only VALIDATED place*/
$queryStatus = new \Elastica\Query\Match();
$queryStatus->setFieldQuery('event.status', StatusType::VALIDATED);
$boolQuery->addMust($queryStatus);
if ($category !== null) {
$queryCategory = new \Elastica\Query\Match();
$queryCategory->setFieldQuery('event.categories.slug', $category);
$boolQuery->addMust($queryCategory);
} else {
$query = new \Elastica\Query\MatchAll();
}
$baseQuery = $boolQuery;
// then we create filters depending on the chosen criterias
$boolFilter = new \Elastica\Filter\Bool();
/*
Dates filter
We add this filter only the getIspublished filter is not at "false"
*/
// if("false" != $articleSearch->getIsPublished()
// && null !== $articleSearch->getDateFrom()
// && null !== $articleSearch->getDateTo())
// {
// $boolFilter->addMust(new \Elastica\Filter\Range('publishedAt',
// array(
// 'gte' => \Elastica\Util::convertDate($articleSearch->getDateFrom()->getTimestamp()),
// 'lte' => \Elastica\Util::convertDate($articleSearch->getDateTo()->getTimestamp())
// )
// ));
// }
//
// Published or not filter
// if($placeSearch->getIs24h() !== null && $placeSearch->getIs24h()){
// //var_dump($placeSearch->getIs24h());die();
// $boolFilter->addMust(
// new \Elastica\Filter\Term(['is24h' => $placeSearch->getIs24h()])
// //new \Elastica\Filter\Term(['isWifi' => $placeSearch->getIsWifi()])
// );
//
// //$boolFilter->addMust('is24h', $placeSearch->getIs24h());
// }
//
// if($placeSearch->getIsWifi() !== null && $placeSearch->getIsWifi()){
// $boolFilter->addMust(
// new \Elastica\Filter\Term(['isWifi' => $placeSearch->getIsWifi()])
// );
// }
//
// if($placeSearch->getIsDelivery() !== null && $placeSearch->getIsDelivery()){
// $boolFilter->addMust(
// new \Elastica\Filter\Term(['isDelivery' => $placeSearch->getIsDelivery()])
// );
// }
$filtered = new \Elastica\Query\Filtered($baseQuery, $boolFilter);
$query = \Elastica\Query::create($filtered);
return $this->find($query);
}
/**
* search query to Elasticsearch.
*
* @param $search_query
* @return true or WP_Error object
* @since 0.1
*/
public function search($search_query)
{
try {
$options = get_option('wpels_settings');
$client = $this->_create_client($options);
if (!$client) {
throw new Exception('Couldn\'t make Elasticsearch Client. Parameter is not enough.');
}
$type = $client->getIndex($options['index'])->getType($options['type']);
$qs = new QueryString();
$qs->setQuery($search_query);
$query_es = Query::create($qs);
$resultSet = $type->search($query_es);
$post_ids = array();
foreach ($resultSet as $r) {
$post_ids[] = $r->getID();
}
return $post_ids;
} catch (Exception $e) {
$err = new WP_Error('Elasticsearch Search Error', $e->getMessage());
return $err;
}
}
/**
* Deletes entries in the db based on a query.
*
* @param \Elastica\Query|string|array $query Query object or array
* @param array $options Optional params
*
* @return \Elastica\Response
*
* @link https://www.elastic.co/guide/en/elasticsearch/reference/5.0/docs-delete-by-query.html
*/
public function deleteByQuery($query, array $options = [])
{
$query = Query::create($query)->getQuery();
return $this->request('_delete_by_query', Request::POST, ['query' => is_array($query) ? $query : $query->toArray()], $options);
}
/**
* @inheritDoc
*/
public function createPaginatorAdapter($query, $options = array())
{
$query = Query::create($query);
return new TransformedPaginatorAdapter($this->searchable, $query, $options, $this->transformer);
}
/**
* Sets query object.
*
* @param string|\Elastica\Query|\Elastica\Query\AbstractQuery $query
*
* @return $this
*/
public function setQuery($query)
{
return $this->setParam('query', BaseQuery::create($query));
}
/**
* @group functional
*/
public function testSetTypeArraySearchSingle()
{
$filter = new Ids();
$filter->setIds('4');
$filter->setType(array('helloworld1', 'helloworld2'));
$query = Query::create($filter);
$resultSet = $this->_getIndexForTest()->search($query);
$this->assertEquals(2, $resultSet->count());
}
/**
* Deletes entries in the db based on a query.
*
* @param \Elastica\Query|string $query Query object
* @param array $options Optional params
*
* @return \Elastica\Response
*
* @link https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html
*/
public function deleteByQuery($query, array $options = array())
{
if (is_string($query)) {
// query_string queries are not supported for delete by query operations
$options['q'] = $query;
return $this->request('_query', Request::DELETE, array(), $options);
}
$query = Query::create($query);
return $this->request('_query', Request::DELETE, array('query' => $query->getQuery()->toArray()), $options);
}
/**
* Sets query object.
*
* @param string|\Elastica\Query|\Elastica\Query\AbstractQuery $query
*
* @return $this
*/
public function setQuery($query)
{
return $this->setParam('query', \Elastica\Query::create($query));
}
/**
* @group functional
*/
public function testBodyReuse()
{
$client = $this->_getClient();
$index = $client->getIndex('elastica_body_reuse_test');
$index->create(array(), true);
$this->_waitForAllocation($index);
$type = $index->getType('test');
$type->addDocument(new Document(1, array('test' => 'test')));
$index->refresh();
$resultSet = $index->search(array('query' => array('query_string' => array('query' => 'pew pew pew'))));
$this->assertEquals(0, $resultSet->getTotalHits());
$response = $index->request('/_search', 'POST');
$resultSet = new ResultSet($response, Query::create(array()));
$this->assertEquals(1, $resultSet->getTotalHits());
}
/**
* @group functional
*/
public function testNoSource()
{
$index = $this->_createIndex();
$type = new Type($index, 'user');
// Adds 1 document to the index
$doc1 = new Document(1, array('username' => 'ruflin', 'test' => array('2', '3', '5')));
$type->addDocument($doc1);
// To update index
$index->refresh();
$query = Query::create('ruflin');
$resultSet = $type->search($query);
// Disable source
$query->setSource(false);
$resultSetNoSource = $type->search($query);
$this->assertEquals(1, $resultSet->count());
$this->assertEquals(1, $resultSetNoSource->count());
// Tests if no source is in response except id
$result = $resultSetNoSource->current();
$this->assertEquals(1, $result->getId());
$this->assertEmpty($result->getData());
// Tests if source is in response except id
$result = $resultSet->current();
$this->assertEquals(1, $result->getId());
$this->assertNotEmpty($result->getData());
}
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;
}
