/**
* and filter
*
* @link http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-and-filter.html
* @param AbstractFilter[] $filters
* @return BoolAnd
*/
public function bool_and(array $filters)
{
$and = new BoolAnd();
$and->setFilters($filters);
return $and;
}
/**
* @group unit
*/
public function testConstruct()
{
$ids1 = new Ids('foo', array(1, 2));
$ids2 = new Ids('bar', array(3, 4));
$and1 = new BoolAnd(array($ids1, $ids2));
$and2 = new BoolAnd();
$and2->addFilter($ids1);
$and2->addFilter($ids2);
$this->assertEquals($and1->toArray(), $and2->toArray());
}
/**
* Merges lists of include/exclude filters into a single filter that
* Elasticsearch will execute efficiently.
* @param array(\Elastica\AbstractFilter) $mustFilters filters that must match all returned documents
* @param array(\Elastica\AbstractFilter) $mustNotFilters filters that must not match all returned documents
* @return null|\Elastica\AbstractFilter null if there are no filters or one that will execute
* all of the provided filters
*/
public static function unify($mustFilters, $mustNotFilters)
{
// We want to make sure that we execute script filters last. So we do these steps:
// 1. Strip script filters from $must and $mustNot.
// 2. Unify the non-script filters.
// 3. Build a BoolAnd filter out of the script filters if there are any.
$scriptFilters = array();
$nonScriptMust = array();
$nonScriptMustNot = array();
foreach ($mustFilters as $must) {
if ($must->hasParam('script')) {
$scriptFilters[] = $must;
} else {
$nonScriptMust[] = $must;
}
}
foreach ($mustNotFilters as $mustNot) {
if ($mustNot->hasParam('script')) {
$scriptFilters[] = new \Elastica\Filter\BoolNot($mustNot);
} else {
$nonScriptMustNot[] = $mustNot;
}
}
$nonScript = self::unifyNonScript($nonScriptMust, $nonScriptMustNot);
$scriptFiltersCount = count($scriptFilters);
if ($scriptFiltersCount === 0) {
return $nonScript;
}
$boolAndFilter = new \Elastica\Filter\BoolAnd();
if ($nonScript === null) {
if ($scriptFiltersCount === 1) {
return $scriptFilters[0];
}
} else {
$boolAndFilter->addFilter($nonScript);
}
foreach ($scriptFilters as $scriptFilter) {
$boolAndFilter->addFilter($scriptFilter);
}
return $boolAndFilter;
}
/**
* @inheritdoc
*/
public function findPaginatedByQueryAndCategory(\string $queryString = null, \string $category = null, \int $priceFrom = null, \int $priceTo = null, \bool $availability = null)
{
$queryObject = new Query();
$filter = new BoolAnd();
if ($queryString) {
$query = new Match('_all', ['query' => $queryString, 'operator' => 'AND']);
} else {
$query = new Query\MatchAll();
}
if ($availability !== null) {
$filter->addFilter(new Term(['availability' => $availability]));
}
$range = [];
if ($priceFrom) {
$range['gte'] = $priceFrom;
}
if ($priceTo) {
$range['lte'] = $priceTo;
}
if ($range) {
$filter->addFilter(new Range('price', $range));
}
if ($category) {
$term = new Term(['category.id' => $category]);
$queryObject->setPostFilter($term);
}
$terms = new Terms('categories');
$terms->setField('category.id');
$terms->setSize(0);
$queryObject->addAggregation($terms);
if ($filter->getFilters()) {
$filtered = new Query\Filtered($query, $filter);
$queryObject->setQuery($filtered);
} else {
$queryObject->setQuery($query);
}
$queryObject->setSort(['updated' => 'desc']);
$queryObject->setMinScore(0.5);
return $this->findPaginated($queryObject);
}
public function testSetCache()
{
$client = $this->_getClient();
$index = $client->getIndex('test');
$index->create(array(), true);
$type = $index->getType('test');
$doc = new Document(1, array('name' => 'hello world'));
$type->addDocument($doc);
$doc = new Document(2, array('name' => 'nicolas ruflin'));
$type->addDocument($doc);
$doc = new Document(3, array('name' => 'ruflin'));
$type->addDocument($doc);
$and = new BoolAnd();
$idsFilter1 = new Ids();
$idsFilter1->setIds(1);
$idsFilter2 = new Ids();
$idsFilter2->setIds(1);
$and->addFilter($idsFilter1);
$and->addFilter($idsFilter2);
$index->refresh();
$and->setCached(true);
$resultSet = $type->search($and);
$this->assertEquals(1, $resultSet->count());
}
private static function newAnd()
{
$and = new BoolAnd();
$and->setFilters(func_get_args());
return $and;
}
/**
* getFilter
*
* @access private
* @return AbstractFilter
*/
private function getFilter()
{
if (!$this->filterList) {
return null;
}
if (count($this->filterList) == 1) {
return current($this->filterList);
}
$boolFilters = [];
$andFilters = [];
foreach ($this->filterList as $tmpFilter) {
if ($this->isAndFilter($tmpFilter)) {
$andFilters[] = $tmpFilter;
} else {
$boolFilters[] = $tmpFilter;
}
}
$boolFilter = null;
$nbBoolFilters = count($boolFilters);
if ($nbBoolFilters > 1) {
$boolFilter = new Filter\Bool();
foreach ($boolFilters as $tmpFilter) {
$boolFilter->addMust($tmpFilter);
}
array_unshift($andFilters, $boolFilter);
} elseif ($nbBoolFilters == 1) {
$andFilters = array_merge($boolFilters, $andFilters);
}
$nbAndFilters = count($andFilters);
if ($nbAndFilters == 1) {
return current($andFilters);
} elseif ($nbAndFilters > 1) {
$filter = new Filter\BoolAnd();
$filter->setFilters($andFilters);
return $filter;
}
return null;
}
public function Addons()
{
$list = Addon::get();
$search = $this->request->getVar('search');
$type = $this->request->getVar('type');
$compat = $this->request->getVar('compatibility');
$tags = $this->request->getVar('tags');
$sort = $this->request->getVar('sort');
$view = $this->request->getVar('view');
if (!$view) {
$view = 'list';
}
if (!in_array($sort, array('name', 'downloads', 'newest'))) {
$sort = null;
}
// Proxy out a search to elastic if any parameters are set.
if ($search || $type || $compat || $tags) {
$filter = new BoolAnd();
$query = new Query();
$query->setSize(count($list));
if ($search) {
$match = new Match();
$match->setField('_all', $search);
$query->setQuery($match);
}
if ($type) {
$filter->addFilter(new Term(array('type' => $type)));
}
if ($compat) {
$filter->addFilter(new Terms('compatible', (array) $compat));
}
if ($tags) {
$filter->addFilter(new Terms('tag', (array) $tags));
}
if ($type || $compat || $tags) {
$query->setFilter($filter);
}
$list = new ResultList($this->elastica->getIndex(), $query);
if ($sort) {
$ids = $list->column('ID');
if ($ids) {
$list = Addon::get()->byIDs($ids);
} else {
$list = new ArrayList();
}
}
} else {
if (!$sort) {
$sort = 'downloads';
}
}
switch ($sort) {
case 'name':
$list = $list->sort('Name');
break;
case 'newest':
$list = $list->sort('Released', 'DESC');
break;
case 'downloads':
$list = $list->sort('Downloads', 'DESC');
break;
}
$list = new PaginatedList($list, $this->request);
$list->setPageLength(16);
return $list;
}
