public function indexAction(Request $request, $page = 1)
{
$getTypes = $request->query->get('type_filters');
$getSubjects = $request->query->get('subject_filters');
$getPublishers = $request->query->get('publisher_filters');
$typeFilters = !empty($getTypes) ? explode(',', $getTypes) : [];
$subjectFilters = !empty($getSubjects) ? explode(',', $getSubjects) : [];
$publisherFilters = !empty($getPublishers) ? explode(',', $getPublishers) : [];
$journalSearcher = $this->get('fos_elastica.index.search.journal');
$boolQuery = new Query\Bool();
$match = new Query\Match();
$match->setField('status', 1);
$boolQuery->addMust($match);
$match = new Query\Match();
$match->setField('published', true);
$boolQuery->addMust($match);
if (!empty($typeFilters) || !empty($subjectFilters) || !empty($publisherFilters)) {
foreach ($typeFilters as $type) {
$match = new Query\Match();
$match->setField('publisher.publisher_type.name', $type);
$boolQuery->addMust($match);
}
foreach ($subjectFilters as $subject) {
$match = new Query\Match();
$match->setField('subjects.subject', $subject);
$boolQuery->addMust($match);
}
foreach ($publisherFilters as $publisher) {
$match = new Query\Match();
$match->setField('publisher.name', $publisher);
$boolQuery->addMust($match);
}
}
$journalQuery = new Query($boolQuery);
$typeAgg = new Aggregation\Terms('types');
$typeAgg->setField('publisher.publisher_type.name');
$typeAgg->setOrder('_term', 'asc');
$typeAgg->setSize(0);
$journalQuery->addAggregation($typeAgg);
$subjectAgg = new Aggregation\Terms('subjects');
$subjectAgg->setField('subjects.subject');
$subjectAgg->setOrder('_term', 'asc');
$subjectAgg->setSize(0);
$journalQuery->addAggregation($subjectAgg);
$publisherAgg = new Aggregation\Terms('publishers');
$publisherAgg->setField('publisher.name');
$publisherAgg->setOrder('_term', 'asc');
$publisherAgg->setSize(0);
$journalQuery->addAggregation($publisherAgg);
$adapter = new ElasticaAdapter($journalSearcher, $journalQuery);
$pagerfanta = new Pagerfanta($adapter);
$pagerfanta->setMaxPerPage(21);
$pagerfanta->setCurrentPage($page);
$journals = $pagerfanta->getCurrentPageResults();
$types = $adapter->getResultSet()->getAggregation('types')['buckets'];
$subjects = $adapter->getResultSet()->getAggregation('subjects')['buckets'];
$publishers = $adapter->getResultSet()->getAggregation('publishers')['buckets'];
$data = ['types' => $types, 'subjects' => $subjects, 'publishers' => $publishers, 'type_filters' => $typeFilters, 'subject_filters' => $subjectFilters, 'publisher_filters' => $publisherFilters, 'journals' => $journals, 'pagerfanta' => $pagerfanta, 'page' => 'explore'];
return $this->render('OjsSiteBundle:Explore:index.html.twig', $data);
}
/**
* @group functional
*/
public function testReverseNestedAggregation()
{
$agg = new Nested('comments', 'comments');
$names = new Terms('name');
$names->setField('comments.name');
$tags = new Terms('tags');
$tags->setField('tags');
$reverseNested = new ReverseNested('main');
$reverseNested->addAggregation($tags);
$names->addAggregation($reverseNested);
$agg->addAggregation($names);
$query = new Query();
$query->addAggregation($agg);
$results = $this->_getIndexForTest()->search($query)->getAggregation('comments');
$this->assertArrayHasKey('name', $results);
$nameResults = $results['name'];
$this->assertCount(3, $nameResults['buckets']);
// bob
$this->assertEquals('bob', $nameResults['buckets'][0]['key']);
$tags = array(array('key' => 'foo', 'doc_count' => 2), array('key' => 'bar', 'doc_count' => 1), array('key' => 'baz', 'doc_count' => 1));
$this->assertEquals($tags, $nameResults['buckets'][0]['main']['tags']['buckets']);
// john
$this->assertEquals('john', $nameResults['buckets'][1]['key']);
$tags = array(array('key' => 'bar', 'doc_count' => 1), array('key' => 'foo', 'doc_count' => 1));
$this->assertEquals($tags, $nameResults['buckets'][1]['main']['tags']['buckets']);
// susan
$this->assertEquals('susan', $nameResults['buckets'][2]['key']);
$tags = array(array('key' => 'baz', 'doc_count' => 1), array('key' => 'foo', 'doc_count' => 1));
$this->assertEquals($tags, $nameResults['buckets'][2]['main']['tags']['buckets']);
}
public function publisherAction(Request $request, $page = 1)
{
$getTypes = $request->query->get('type_filters');
$typeFilters = !empty($getTypes) ? explode(',', $getTypes) : [];
$publisherSearcher = $this->get('fos_elastica.index.search.publisher');
$boolQuery = new Query\Bool();
if (!empty($typeFilters)) {
foreach ($typeFilters as $type) {
$match = new Query\Match();
$match->setField('publisherType', $type);
$boolQuery->addMust($match);
}
}
$publisherQuery = new Query($boolQuery);
$typeAgg = new Aggregation\Terms('types');
$typeAgg->setField('publisherType');
$typeAgg->setOrder('_term', 'asc');
$typeAgg->setSize(0);
$publisherQuery->addAggregation($typeAgg);
$adapter = new ElasticaAdapter($publisherSearcher, $publisherQuery);
$pagerfanta = new Pagerfanta($adapter);
$pagerfanta->setMaxPerPage(20);
$pagerfanta->setCurrentPage($page);
$publishers = $pagerfanta->getCurrentPageResults();
$types = $adapter->getResultSet()->getAggregation('types')['buckets'];
$data = ['types' => $types, 'page' => 'ojs_site_explore_publisher', 'publishers' => $publishers, 'pagerfanta' => $pagerfanta, 'type_filters' => $typeFilters];
return $this->render('OjsSiteBundle:Explore:publisher.html.twig', $data);
}
/**
* Returns a query setup for getting the 'type' aggregation
*
* @param Cake\ElasticSearch\Query $query The Query Object
* @return Cake\ElasticSearch\Query
*/
public function findTypes($query)
{
$facet = new TermsAggregation('type');
$facet->setField('_type');
$facet->setSize(200);
$query->aggregate($facet);
return $query->limit(1);
}
/**
* @group functional
*/
public function testTermsAggregation()
{
$agg = new Terms('terms');
$agg->setField('color');
$query = new Query();
$query->addAggregation($agg);
$results = $this->_getIndexForTest()->search($query)->getAggregation('terms');
$this->assertEquals(2, $results['buckets'][0]['doc_count']);
$this->assertEquals('blue', $results['buckets'][0]['key']);
}
public function testTermsAggregation()
{
$agg = new Terms("terms");
$agg->setField("color");
$query = new Query();
$query->addAggregation($agg);
$results = $this->_index->search($query)->getAggregation("terms");
$this->assertEquals(2, $results['buckets'][0]['doc_count']);
$this->assertEquals("blue", $results['buckets'][0]['key']);
}
/**
* @param Request $request
* @param int $page
* @return \Symfony\Component\HttpFoundation\Response
*/
public function indexAction(Request $request, $page = 1)
{
$getRoles = $request->query->get('role_filters');
$getSubjects = $request->query->get('subject_filters');
$getJournals = $request->query->get('journal_filters');
$roleFilters = !empty($getRoles) ? explode(',', $getRoles) : [];
$subjectFilters = !empty($getSubjects) ? explode(',', $getSubjects) : [];
$journalFilters = !empty($getJournals) ? explode(',', $getJournals) : [];
$userSearcher = $this->get('fos_elastica.index.search.user');
$userQuery = new Query('*');
if (!empty($roleFilters) || !empty($subjectFilters) || !empty($journalFilters)) {
$boolQuery = new Query\Bool();
foreach ($roleFilters as $role) {
$match = new Query\Match();
$match->setField('journalUsers.roles', $role);
$boolQuery->addMust($match);
}
foreach ($subjectFilters as $subject) {
$match = new Query\Match();
$match->setField('subjects', $subject);
$boolQuery->addMust($match);
}
foreach ($journalFilters as $journal) {
$match = new Query\Match();
$match->setField('journalUsers.journal.title', $journal);
$boolQuery->addMust($match);
}
$userQuery->setQuery($boolQuery);
}
$roleAgg = new Aggregation\Terms('roles');
$roleAgg->setField('journalUsers.roles');
$roleAgg->setOrder('_term', 'asc');
$roleAgg->setSize(0);
$userQuery->addAggregation($roleAgg);
$subjectAgg = new Aggregation\Terms('subjects');
$subjectAgg->setField('subjects');
$subjectAgg->setOrder('_term', 'asc');
$subjectAgg->setSize(0);
$userQuery->addAggregation($subjectAgg);
$journalAgg = new Aggregation\Terms('journals');
$journalAgg->setField('journalUsers.journal.title');
$journalAgg->setOrder('_term', 'asc');
$journalAgg->setSize(0);
$userQuery->addAggregation($journalAgg);
$adapter = new ElasticaAdapter($userSearcher, $userQuery);
$pagerfanta = new Pagerfanta($adapter);
$pagerfanta->setMaxPerPage(20);
$pagerfanta->setCurrentPage($page);
$people = $pagerfanta->getCurrentPageResults();
$roles = $adapter->getResultSet()->getAggregation('roles')['buckets'];
$subjects = $adapter->getResultSet()->getAggregation('subjects')['buckets'];
$journals = $adapter->getResultSet()->getAggregation('journals')['buckets'];
$data = ['people' => $people, 'roles' => $roles, 'subjects' => $subjects, 'journals' => $journals, 'pagerfanta' => $pagerfanta, 'role_filters' => $roleFilters, 'subject_filters' => $subjectFilters, 'journal_filters' => $journalFilters, 'page' => 'ojs_site_people_index'];
return $this->render('OjsSiteBundle:People:index.html.twig', $data);
}
/**
* @param Terms $termsAgg
* @throws ErrorException
*/
private function addAggregation(Terms $termsAgg)
{
foreach ($this->aggregation as $parameter => $queryAttr) {
$aggregationModel = new Aggregation();
$aggregationModel->parameter = $parameter;
$aggregationModel->attributes = $queryAttr;
$itemAgg = $aggregationModel->getElasticaAggregations();
$itemAgg->setField($parameter);
$termsAgg->addAggregation($itemAgg);
$this->aggregationList[] = ['type' => $aggregationModel->type, 'index' => $aggregationModel->getAggregationName(), 'title' => (string) $aggregationModel];
}
}
private function getStatsQuery(Journal $journal)
{
$filter = new Term();
$filter->setTerm('journal.id', $journal->getId());
$filterQuery = new Filtered();
$filterQuery->setFilter($filter);
$query = new Query($filterQuery);
$dateHistogram = new DateHistogram('dateHistogram', 'created', 'month');
$dateHistogram->setFormat("YYYY-MM-dd");
$query->addAggregation($dateHistogram);
$genderAggregation = new Terms('language');
$genderAggregation->setField('locale');
$query->addAggregation($genderAggregation);
$query->setSize(0);
return $query;
}
private function getStatsQuery(Journal $journal)
{
$filter = new Term();
$filter->setTerm('journalUsers.journal.id', $journal->getId());
$filterQuery = new Query\Filtered();
$filterQuery->setFilter($filter);
$query = new Query($filterQuery);
$titleAggregation = new Terms('title');
$titleAggregation->setField('title');
$query->addAggregation($titleAggregation);
$genderAggregation = new Terms('gender');
$genderAggregation->setField('gender');
$query->addAggregation($genderAggregation);
$query->setSize(0);
return $query;
}
public function findByUserAndTags(User $user, $tags = null)
{
$filterQuery = new Query\Filtered();
$searchFilter = new Filter\Bool();
$searchFilter->addMust(new Filter\Term(array('user' => $user->getId())));
if (!empty($tags)) {
$tagFilter = new Filter\Terms('tags', explode('+', $tags));
$tagFilter->setExecution('and');
$searchFilter->addMust($tagFilter);
}
$filterQuery->setFilter($searchFilter);
$searchQuery = new Query($filterQuery);
$searchQuery->addSort(array('createdAt' => 'desc'));
$agg = new Aggregation\Terms('tags');
$agg->setField('tags')->setOrder('_count', 'desc')->setSize(100);
$searchQuery->addAggregation($agg);
return $searchQuery;
}
protected function getStates()
{
$results = [];
$query = new Elastica\Query();
$query->setSize(0);
$agg = new Elastica\Aggregation\Nested('states', 'state');
$st_terms = new Elastica\Aggregation\Terms('abbrev');
$st_terms->setField('state.abbrev');
$st_terms->setOrder('_term', 'asc');
$st_terms->setSize(0);
$state_terms = new Elastica\Aggregation\Terms('full');
$state_terms->setField('state.full');
$st_terms->addAggregation($state_terms);
$agg->addAggregation($st_terms);
$query->addAggregation($agg);
/* @var $elastica_client Elastica\Client */
$elastica_client = $this->getServiceLocator()->getServiceLocator()->get('elastica-client');
try {
/* @var $response \Elastica\Response */
$response = $elastica_client->request('usgeodb/locality/_search?query_cache=true', Request::GET, $query->toArray());
$data = $response->getData();
$aggregations = isset($data['aggregations']['states']['abbrev']['buckets']) ? $data['aggregations']['states']['abbrev']['buckets'] : [];
foreach ($aggregations as $aggregation) {
$key = strtoupper($aggregation['key']);
$value = ucwords($aggregation['full']['buckets'][0]['key']);
$results[$key] = $value;
}
} catch (\Exception $e) {
}
return $results;
}
/**
* @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);
}
/**
* Get a list of all projects.
* @return array
*/
public function getProjects()
{
$agg = new Terms('projects');
$agg->setField('project');
$agg->setSize(0);
$agg->setShardSize(0);
$agg->setOrder('_term', 'asc');
$query = new Query();
$query->addAggregation($agg);
$res = $this->doSearch($query)->getAggregation('projects');
return array_map(function ($b) {
return $b['key'];
}, $res['buckets']);
}
protected function getOuterAggregationResult($innerAggr)
{
$outerAggr = new Terms('top_tags');
$outerAggr->setField('tags');
$outerAggr->setMinimumDocumentCount(2);
$outerAggr->addAggregation($innerAggr);
$query = new Query(new MatchAll());
$query->addAggregation($outerAggr);
return $this->_getIndexForTest()->search($query)->getAggregation('top_tags');
}
/**
* Add a number of facets to the FlickrPhoto query
* @param \Elastica\Query &$query the existing query object to be augmented.
*/
public function augmentQuery(&$query)
{
// set the order to be taken at in reverse if query is blank other than aggs
$params = $query->getParams();
// add Aperture aggregate
$agg1 = new Terms("Aperture");
$agg1->setField("Aperture");
$agg1->setSize(0);
$agg1->setOrder('_term', 'asc');
$query->addAggregation($agg1);
// add shutter speed aggregate
$agg2 = new Terms("ShutterSpeed");
$agg2->setField("ShutterSpeed");
$agg2->setSize(0);
$agg2->setOrder('_term', 'asc');
$query->addAggregation($agg2);
// this currently needs to be same as the field name
// needs fixed
// Add focal length aggregate, may range this
$agg3 = new Terms("FocalLength35mm");
$agg3->setField("FocalLength35mm");
$agg3->setSize(0);
$agg3->setOrder('_term', 'asc');
$query->addAggregation($agg3);
// add film speed
$agg4 = new Terms("ISO");
$agg4->setField("ISO");
$agg4->setSize(0);
$agg4->setOrder('_term', 'asc');
$query->addAggregation($agg4);
$aspectRangedAgg = RangedAggregation::getByTitle('Aspect');
$query->addAggregation($aspectRangedAgg->getRangeAgg());
// remove NearestTo from the request so it does not get used as a term filter
unset(Controller::curr()->request['NearestTo']);
}
/**
* Tag cloud page
* @return \Symfony\Component\HttpFoundation\Response
*/
public function tagCloudAction()
{
$search = $this->container->get('fos_elastica.index.search');
$searchQuery = new Query();
$searchQuery->setSize(0);
//get tags aggregation
$tagsAgg = new Aggregation\Terms('tags');
$tagsAgg->setField('tags');
$tagsAgg->setSize(500);
$searchQuery->addAggregation($tagsAgg);
/**
* @var ResultSet $results
*/
$results = $search->search($searchQuery);
$data['tags'] = [];
foreach ($results->getAggregations()['tags']['buckets'] as $result) {
$keys = array_filter(explode(',', $result['key']));
if (is_array($keys)) {
foreach ($keys as $key) {
$data['tags'][] = trim($key);
}
}
}
return $this->render('OjsSiteBundle:Search:tags_cloud.html.twig', $data);
}
/**
* Tag cloud page
* @return \Symfony\Component\HttpFoundation\Response
*/
public function tagCloudAction()
{
$search = $this->container->get('fos_elastica.index.search');
$searchQuery = new Query('_all');
//get tags aggregation
$tagsAgg = new Aggregation\Terms('tags');
$tagsAgg->setField('tags');
$tagsAgg->setOrder('_term', 'asc');
$tagsAgg->setSize(0);
$searchQuery->addAggregation($tagsAgg);
/**
* @var ResultSet $results
*/
$results = $search->search($searchQuery);
$data['tags'] = [];
foreach ($results->getAggregations()['tags']['buckets'] as $result) {
$data['tags'][] = $result['key'];
}
return $this->render('OjsSiteBundle:Search:tags_cloud.html.twig', $data);
}
/**
* @group functional
*/
public function testQueryCacheOption()
{
$client = $this->_getClient();
$index = $client->getIndex('zero');
$index->create(array('index' => array('number_of_shards' => 1, 'number_of_replicas' => 0)), true);
$type = $index->getType('zeroType');
$type->addDocuments(array(new Document(1, array('id' => 1, 'username' => 'farrelley')), new Document(2, array('id' => 2, 'username' => 'bunny'))));
$index->refresh();
$aggregation = new Aggregation\Terms('username');
$aggregation->setField('username');
$query = new Query();
$query->addAggregation($aggregation);
$search = new Search($client);
$search->addIndex($index);
$search->setQuery($query);
$search->setOption(Search::OPTION_SEARCH_TYPE, Search::OPTION_SEARCH_TYPE_COUNT);
$search->setOption(Search::OPTION_QUERY_CACHE, true);
// before search query cache should be empty
$statsData = $index->getStats()->getData();
$queryCache = $statsData['_all']['primaries']['query_cache'];
$this->assertEquals(0, $queryCache['memory_size_in_bytes']);
$this->assertEquals(0, $queryCache['evictions']);
$this->assertEquals(0, $queryCache['hit_count']);
$this->assertEquals(0, $queryCache['miss_count']);
// first search should result in cache miss and save data to cache
$search->search();
$index->getStats()->refresh();
$statsData = $index->getStats()->getData();
$queryCache = $statsData['_all']['primaries']['query_cache'];
$this->assertNotEquals(0, $queryCache['memory_size_in_bytes']);
$this->assertEquals(0, $queryCache['evictions']);
$this->assertEquals(0, $queryCache['hit_count']);
$this->assertEquals(1, $queryCache['miss_count']);
// next search should result in cache hit
$search->search();
$index->getStats()->refresh();
$statsData = $index->getStats()->getData();
$queryCache = $statsData['_all']['primaries']['query_cache'];
$this->assertNotEquals(0, $queryCache['memory_size_in_bytes']);
$this->assertEquals(0, $queryCache['evictions']);
$this->assertEquals(1, $queryCache['hit_count']);
$this->assertEquals(1, $queryCache['miss_count']);
}
public function search()
{
//$finder = $this->container->get('fos_elastica.finder.search.articles');
$bool = new Query\Bool();
$multiMatch = new Query\MultiMatch();
$multiMatch->setFields(['subjects', 'title', 'keywords', 'subtitle', 'citations.raw', 'journal.title', 'journal.subtitle']);
$multiMatch->setType('phrase_prefix');
$multiMatch->setQuery($this->getParam('term'));
$bool->addMust($multiMatch);
if ($this->filter) {
foreach ($this->filter as $key => $filter) {
$filterObj = new Query\Match();
$this->applyFilter($filterObj, $key, $filter);
$bool->addMust($filterObj);
}
}
$missing = new Filter\Missing("issue");
$not = new Filter\BoolNot($missing);
$notQ = new Query\Filtered();
$notQ->setFilter($not);
$bool->addMust($notQ);
$query = new Query();
$query->setQuery($bool);
$query->setFrom($this->getPage() * $this->getLimit());
$query->setSize($this->getLimit());
$aggregation = new Terms('journals');
$aggregation->setField('journal.id');
$aggregation->setOrder('_count', 'desc');
$qb = $this->em->createQueryBuilder();
$qb->select('count(r.id)')->from('OjsJournalBundle:Journal', 'r')->where($qb->expr()->eq('r.status', 3));
$aggregation->setSize($qb->getQuery()->getSingleScalarResult());
$query->addAggregation($aggregation);
$aggregation = new Terms('authors');
$aggregation->setField('articleAuthors.author.id');
$aggregation->setOrder('_count', 'desc');
$qb = $this->em->createQueryBuilder();
$qb->select('count(r.id)')->from('OjsJournalBundle:Author', 'r');
$aggregation->setSize($qb->getQuery()->getSingleScalarResult());
$query->addAggregation($aggregation);
$elasticaAdapter = new ElasticaAdapter($this->index, $query);
$pagerFanta = new Pagerfanta($elasticaAdapter);
$pagerFanta->setMaxPerPage($this->getLimit());
$pagerFanta->setCurrentPage($this->getPage());
/** @var ResultSet $search */
$search = $pagerFanta->getCurrentPageResults();
$result = $search->getResults();
//$search->getResults();
$this->pager = $pagerFanta;
$transformer = new ElasticaToModelTransformer($this->registry, 'OjsJournalBundle:Article');
$transformer->setPropertyAccessor($this->propertyAccessor);
$this->result = $transformer->transform($result);
$this->setCount($pagerFanta->getNbResults());
$this->addAggregation('journal', $this->transform($search->getAggregation('journals')['buckets'], 'OjsJournalBundle:Journal'));
$this->addAggregation('author', $this->transform($search->getAggregation('authors')['buckets'], 'OjsJournalBundle:Author'));
return $this;
}
/**
* @param AbstractElasticaSearcher $searcher
* @param Request $request
* @param RenderContext $context
*/
protected function applySearchParams(AbstractElasticaSearcher $searcher, Request $request, RenderContext &$context)
{
// Retrieve the search parameters
$queryString = trim($request->query->get('query'));
$queryType = $request->query->get('type');
$lang = $request->getLocale();
$context['q_query'] = $queryString;
$context['q_type'] = $queryType;
$searcher->setData($this->sanitizeSearchQuery($queryString))->setContentType($queryType)->setLanguage($lang);
$query = $searcher->getQuery();
// Aggregations
$termsAggregation = new Terms('type');
$termsAggregation->setField('type');
$query->addAggregation($termsAggregation);
}
/**
* @param Query $elasticaQuery
*/
private function addAggregations($elasticaQuery)
{
$catAggregation = new Terms('Category');
$catAggregation->setField('category.name');
$elasticaQuery->addAggregation($catAggregation);
$trackerAggregation = new Terms('Tracker');
$trackerAggregation->setField('tracker.name');
$elasticaQuery->addAggregation($trackerAggregation);
$status = new Terms('Status');
$status->setField('status.name');
$elasticaQuery->addAggregation($status);
$priority = new Terms('Priority');
$priority->setField('priority.name');
$elasticaQuery->addAggregation($priority);
$t3ver = new Terms('TYPO3 Version');
$t3ver->setField('typo3_version');
$elasticaQuery->addAggregation($t3ver);
$targetver = new Terms('Target Version');
$targetver->setField('fixed_version.name');
$elasticaQuery->addAggregation($targetver);
$phpVer = new Terms('PHP Version');
$phpVer->setField('php_version');
$elasticaQuery->addAggregation($phpVer);
/*$age = new \Elastica\Aggregation\Range('Age');
$age->setParams(array(
'script' => 'DateTime.now().year - doc[\'updated_on\'].date.year',
'ranges' => array(
array('from' => 0,'to' => 1),
array('from' => 2,'to' => 3),
array('from' => 4,'to' => 5),
)
));
$elasticaQuery->addAggregation($age);*/
}