<?php
ini_set("display_errors", true);
require_once __DIR__ . '/../vendor/autoload.php';
$client = new \Elastica\Client();
$search = new Elastica\Search($client);
$search->addIndex('comicbook')->addType('superhero');
$query = new Elastica\Query();
$query->setSize(10)->setSort(['name' => 'asc']);
$searchText = "Kent";
$stringQuery = new Elastica\Query\QueryString($searchText);
$query->setQuery($stringQuery);
$query->setHighlight(array('pre_tags' => array('<strong>'), 'post_tags' => array('</strong>'), 'fields' => array('name' => array('force_source' => true), 'summary' => array('force_source' => true))));
$search->setQuery($query);
$resultSet = $search->search();
echo 'Search "' . $searchText . '"<br />' . PHP_EOL;
echo 'Founded ' . $resultSet->getTotalHits() . ' records in ' . $resultSet->getTotalTime() . 'ms<br /><br />' . PHP_EOL;
foreach ($resultSet as $result) {
$data = $result->getData();
foreach ($result->getHighlights() as $key => $value) {
$data[$key] = join(PHP_EOL, $value);
}
echo $data['name'] . ' - ' . $data['summary'] . "<br /><br />" . PHP_EOL;
}
public function articlelistAction(Request $request)
{
$em = $this->getDoctrine()->getManager();
$searchTerm = $request->query->get('q');
$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.article');
$boolQuery = new \Elastica\Query\BoolQuery();
$articles = "";
$totalpages = 0;
if ($request->query->get('q') != NULL) {
$searchTerm = $request->query->get('q');
$fieldQuery = new \Elastica\Query\Match();
$fieldQuery->setFieldQuery('allField', $searchTerm);
$fieldQuery->setFieldOperator('allField', 'AND');
$fieldQuery->setFieldMinimumShouldMatch('allField', '80%');
$fieldQuery->setFieldAnalyzer('allField', 'custom_search_analyzer');
$boolQuery->addMust($fieldQuery);
$query = new \Elastica\Query();
$query->setQuery($boolQuery);
$query->setSize(10000);
$articleCatgeories = $finder->find($query);
$totalpages = ceil(count($finder->find($query)) / 12);
$query->setSize(12);
$query->setFrom($pageOffset);
$articles = $finder->find($query);
}
return $this->render('OrthAdminBundle:Articles:articlelist.html.twig', array('totalpages' => $totalpages, 'articles' => $articles));
}
public function searchAction(Request $request, $page)
{
$term = $request->get('q');
if (strlen($term) === 0) {
return $this->redirectToRoute('blog_index');
}
$finder = $this->container->get('fos_elastica.finder.app.post');
$queryString = new \Elastica\Query\QueryString();
$queryString->setDefaultField('_all');
$queryString->setQuery($term);
$query = new \Elastica\Query($queryString);
$query->setSize(50);
$query->setHighlight(array('fields' => array('*' => new \stdClass())));
$elasticaSearchResults = $finder->findHybrid($query);
$searchResults = array();
$serializer = $this->get('serializer');
foreach ($elasticaSearchResults as $elasticaSearchResult) {
$resultJson = $serializer->serialize($elasticaSearchResult->getTransformed(), 'json');
$resultObj = json_decode($resultJson, true);
foreach ($elasticaSearchResult->getResult()->getHit()['highlight'] as $key => $value) {
if ($key !== 'slug') {
$resultObj[$key] = current($value);
}
}
array_push($searchResults, $resultObj);
}
return $this->render('ElasticSearchBundle::elastica_search_results.html.twig', array('term' => $term, 'results' => $searchResults));
}
/**
* @internal
**/
public static function _query($args, $pageIndex, $size, $sortByDate = false)
{
$query = new \Elastica\Query($args);
$query->setFrom($pageIndex * $size);
$query->setSize($size);
$query->setFields(array('id'));
Config::apply_filters('searcher_query', $query);
try {
$index = Indexer::_index(false);
$search = new \Elastica\Search($index->getClient());
$search->addIndex($index);
if (!$query->hasParam('sort')) {
if ($sortByDate) {
$query->addSort(array('post_date' => 'desc'));
} else {
$query->addSort('_score');
}
}
Config::apply_filters('searcher_search', $search, $query);
$results = $search->search($query);
return self::_parseResults($results);
} catch (\Exception $ex) {
error_log($ex);
return null;
}
}
public function newsAction(Request $request)
{
$request = $this->getRequest();
$pageOffset = 0;
if ($request->query->get('p')) {
$page = $request->query->get('p');
$pageOffset = ($page - 1) * 6;
}
$finder = $this->container->get('fos_elastica.finder.search.posts');
$boolQuery = new \Elastica\Query\BoolQuery();
if ($request->query->get('q')) {
$search = $request->query->get('q');
$fieldQuery = new \Elastica\Query\Match();
$fieldQuery->setFieldQuery('allField', $search);
$fieldQuery->setFieldOperator('allField', 'AND');
$fieldQuery->setFieldMinimumShouldMatch('allField', '80%');
$fieldQuery->setFieldAnalyzer('allField', 'custom_search_analyzer');
$boolQuery->addMust($fieldQuery);
} else {
$fieldQuery = new \Elastica\Query\MatchAll();
}
$query = new \Elastica\Query();
$query->setQuery($boolQuery);
$query->setSize(1000);
$totalpages = ceil(count($finder->find($query)) / 6);
$query->setSize(6);
$query->setFrom($pageOffset);
$posts = $finder->find($query);
return $this->render('TeamIndexBundle:News:news.html.twig', array('posts' => $posts, 'totalpages' => $totalpages));
}
public function getArticles($user, $searchTerm, $page, $pageOffset, $category, $colors, $finder)
{
$boolQuery = new \Elastica\Query\BoolQuery();
if ($category != NULL) {
$categoryQuery = new \Elastica\Query\Terms();
$categoryQuery->setTerms('custdata.customCatRef', array($category));
$boolQuery->addMust($categoryQuery);
}
if ($searchTerm) {
$fieldQuery = new \Elastica\Query\Match();
$fieldQuery->setFieldQuery('customerRef', $user->getCustomerRef());
$boolQuery->addMust($fieldQuery);
$fieldQuery = new \Elastica\Query\Match();
$fieldQuery->setFieldQuery('allField', $searchTerm);
$fieldQuery->setFieldOperator('allField', 'AND');
$fieldQuery->setFieldMinimumShouldMatch('allField', '70%');
$fieldQuery->setFieldFuzziness('allField', '0.8');
$fieldQuery->setFieldAnalyzer('allField', 'custom_search_analyzer');
$boolQuery->addMust($fieldQuery);
} else {
$fieldQuery = new \Elastica\Query\MatchAll();
$boolQuery->addMust($fieldQuery);
}
$fieldQuery = new \Elastica\Query\Nested();
$fieldQuery->setPath('custdata.custcat.perm');
$boolNested = new \Elastica\Query\BoolQuery();
$fieldNested = new \Elastica\Query\Match();
$fieldNested->setField('custdata.custcat.perm.permStatus', 1);
$boolNested->addMust($fieldNested);
$fieldNested = new \Elastica\Query\Match();
$fieldNested->setField('custdata.custcat.perm.userRef', $user->getId());
$boolNested->addMust($fieldNested);
$fieldQuery->setQuery($boolNested);
$boolQuery->addMust($fieldQuery);
if ($colors != NULL) {
$colorQuery = new \Elastica\Query\Terms();
$colorQuery->setTerms('variants.variantvalues.otherTerms', $colors);
$colorNested = new \Elastica\Query\Nested('variants');
$colorNested->setPath('variants.variantvalues');
$colorNested->setQuery($colorQuery);
$boolQuery->addMust($colorNested);
}
$query = new \Elastica\Query();
$query->setQuery($boolQuery);
$query->setSize(12);
$query->setFrom($pageOffset);
$articles = $finder->find($query);
$result = array("articles" => $articles, "rQuery" => $query);
return $result;
}
/**
* @Route("/app/users/list", name="app_users_list")
*/
public function listUsersAction()
{
$finder = $this->container->get('fos_elastica.finder.app.user');
$query = new \Elastica\Query();
$matchAll = new \Elastica\Query\MatchAll();
$query->setQuery($matchAll);
$query->setSize(1000);
$results = $finder->findHybrid($query);
$elasticaResults = [];
foreach ($results as $result) {
$elasticaResults[] = [$result->getResult()->getId() => $result->getResult()->getSource()];
}
return new Response(json_encode($elasticaResults));
}
private function show($filter = null)
{
$query = new \Elastica\Query();
if ($filter) {
$query->setPostFilter($filter);
}
// WHAT ARE YOU DOING TRACKING MORE THAN 5000 INDEXES?!?
$query->setSize(5000);
$res = $this->getType()->getIndex()->search($query);
foreach ($res as $r) {
$data = $r->getData();
$this->outputIndented("index name: " . $r->getId() . "\n");
$this->outputIndented(" analysis version: {$data['analysis_maj']}.{$data['analysis_min']}\n");
$this->outputIndented(" mapping version: {$data['mapping_maj']}.{$data['mapping_min']}\n");
$this->outputIndented(" shards: {$data['shard_count']}\n");
}
}
public function searchLoans($conditions = array(), $page = 1, $limit = 20)
{
$conditions += ['search' => false];
$search = $conditions['search'];
unset($conditions['search']);
$queryString = new \Elastica\Query\QueryString();
$loanIndex = $this->getLoanIndex();
$query = new \Elastica\Query();
if ($search) {
$queryString->setDefaultOperator('AND');
$queryString->setQuery($search);
$query->setQuery($queryString);
}
$filterAnd = new \Elastica\Filter\BoolAnd();
foreach ($conditions as $field => $value) {
$termFilter = new \Elastica\Filter\Term();
$termFilter->setTerm($field, $value);
$filterAnd->addFilter($termFilter);
}
if ($conditions) {
$query->setFilter($filterAnd);
}
$query->setFrom(($page - 1) * $limit);
$query->setSize($page * $limit);
$results = $loanIndex->search($query);
$ids = [];
foreach ($results as $result) {
$data = $result->getData();
$ids[$data['id']] = $data['id'];
}
$loans = LoanQuery::create()->filterById($ids)->find();
$sortedLoans = $ids;
foreach ($loans as $loan) {
$sortedLoans[$loan->getId()] = $loan;
}
$sortedLoans = array_filter($sortedLoans, function ($l) {
return !is_scalar($l);
});
$paginatorFactory = \App::make('paginator');
return $paginatorFactory->make($sortedLoans, $results->getTotalHits(), $limit);
}
/**
* 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;
}
public function getBestImg($searchTerm, $articleRef, $colors, $finder)
{
$boolQuery = new \Elastica\Query\BoolQuery();
if ($searchTerm) {
$fieldQuery = new \Elastica\Query\Match();
$fieldQuery->setFieldQuery('desc1', $searchTerm);
$fieldQuery->setFieldOperator('desc1', 'OR');
$fieldQuery->setFieldMinimumShouldMatch('desc1', '80%');
$fieldQuery->setFieldAnalyzer('desc1', 'custom_search_analyzer');
$boolQuery->addShould($fieldQuery);
$fieldQuery = new \Elastica\Query\Match();
$fieldQuery->setFieldQuery('desc2', $searchTerm);
$fieldQuery->setFieldOperator('desc2', 'OR');
$fieldQuery->setFieldMinimumShouldMatch('desc2', '80%');
$fieldQuery->setFieldAnalyzer('desc2', 'custom_search_analyzer');
$varTerms = explode(" ", $searchTerm);
$boolQuery->addShould($fieldQuery);
$colorQuery = new \Elastica\Query\Terms();
$colorQuery->setTerms('variantvalues.otherTerms', $varTerms);
$colorNested = new \Elastica\Query\Nested('variantvalues');
$colorNested->setPath('variantvalues');
$colorNested->setQuery($colorQuery);
$boolQuery->addShould($colorNested);
if ($colors != NULL) {
$fieldQuery = new \Elastica\Query\Terms();
$fieldQuery->setTerms('otherTerms', $colors);
$boolQuery->addShould($fieldQuery);
}
}
$articleRefQuery = new \Elastica\Query\Terms();
$articleRefQuery->setTerms('articleRef', array($articleRef));
$boolQuery->addMust($articleRefQuery);
if ($colors != NULL) {
$colorQuery = new \Elastica\Query\Terms();
$colorQuery->setTerms('variantvalues.otherTerms', $colors);
$colorNested = new \Elastica\Query\Nested('variantvalues');
$colorNested->setPath('variantvalues');
$colorNested->setQuery($colorQuery);
$boolQuery->addMust($colorNested);
}
$query = new \Elastica\Query();
$query->setQuery($boolQuery);
$query->setSize(12);
$articleVar = $finder->find($query);
return $articleVar;
}
/**
* Update the indexes for other wiki that also store information about $titles.
* @param Title[] $titles array of titles in other indexes to update
*/
public function updateOtherIndex($titles)
{
global $wgCirrusSearchWikimediaExtraPlugin;
if (!isset($wgCirrusSearchWikimediaExtraPlugin['super_detect_noop'])) {
$this->logFailure($titles, 'super_detect_noop plugin not enabled');
return;
}
$updates = array();
// Build multisearch to find ids to update
$findIdsMultiSearch = new \Elastica\Multi\Search($this->connection->getClient());
$findIdsClosures = array();
foreach ($titles as $title) {
foreach (OtherIndexes::getExternalIndexes($title) as $otherIndex) {
if ($otherIndex === null) {
continue;
}
$type = $this->connection->getPageType($otherIndex);
$bool = new \Elastica\Filter\Bool();
// Note that we need to use the keyword indexing of title so the analyzer gets out of the way.
$bool->addMust(new \Elastica\Filter\Term(array('title.keyword' => $title->getText())));
$bool->addMust(new \Elastica\Filter\Term(array('namespace' => $title->getNamespace())));
$filtered = new \Elastica\Query\Filtered(new \Elastica\Query\MatchAll(), $bool);
$query = new \Elastica\Query($filtered);
$query->setFields(array());
// We only need the _id so don't load the _source
$query->setSize(1);
$findIdsMultiSearch->addSearch($type->createSearch($query));
$findIdsClosures[] = function ($id) use($otherIndex, &$updates, $title) {
$updates[$otherIndex][] = array('id' => $id, 'ns' => $title->getNamespace(), 'dbKey' => $title->getDBkey());
};
}
}
$findIdsClosuresCount = count($findIdsClosures);
if ($findIdsClosuresCount === 0) {
// No other indexes to check.
return;
}
// Look up the ids and run all closures to build the list of updates
$this->start("searching for {numIds} ids in other indexes", array('numIds' => $findIdsClosuresCount));
$findIdsMultiSearchResult = $findIdsMultiSearch->search();
try {
$this->success();
for ($i = 0; $i < $findIdsClosuresCount; $i++) {
$results = $findIdsMultiSearchResult[$i]->getResults();
if (count($results) === 0) {
continue;
}
$result = $results[0];
call_user_func($findIdsClosures[$i], $result->getId());
}
} catch (\Elastica\Exception\ExceptionInterface $e) {
$this->failure($e);
return;
}
if (!$updates) {
return;
}
// These are split into a job per index so one index
// being frozen doesn't block updates to other indexes
// in the same update.
foreach ($updates as $indexName => $actions) {
$job = new Job\ElasticaWrite(reset($titles), array('clientSideTimeout' => false, 'method' => 'sendOtherIndexUpdates', 'arguments' => array($this->localSite, $indexName, $actions), 'cluster' => $this->writeToClusterName));
$job->run();
}
}
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));
}
public function search($queryString, $opts, $highlight)
{
$query = new \Elastica\Query();
list($searchQuery, $highlights) = $this->parseQueryString($queryString, $opts);
$query->setQuery($searchQuery);
$language = new \Elastica\Facet\Terms('language');
$language->setField('language');
$language->setSize(500);
$query->addFacet($language);
$group = new \Elastica\Facet\Terms('group');
$group->setField('group');
// Would like to prioritize the top level groups and not show subgroups
// if the top group has only few hits, but that doesn't seem to be possile.
$group->setSize(500);
$query->addFacet($group);
$query->setSize($opts['limit']);
$query->setFrom($opts['offset']);
// BoolAnd filters are executed in sequence per document. Bool filters with
// multiple must clauses are executed by converting each filter into a bit
// field then anding them together. The latter is normally faster if either
// of the subfilters are reused. May not make a difference in this context.
$filters = new \Elastica\Filter\Bool();
$language = $opts['language'];
if ($language !== '') {
$languageFilter = new \Elastica\Filter\Term();
$languageFilter->setTerm('language', $language);
$filters->addMust($languageFilter);
}
$group = $opts['group'];
if ($group !== '') {
$groupFilter = new \Elastica\Filter\Term();
$groupFilter->setTerm('group', $group);
$filters->addMust($groupFilter);
}
// Check that we have at least one filter to avoid invalid query errors.
if ($language !== '' || $group !== '') {
$query->setPostFilter($filters);
}
list($pre, $post) = $highlight;
$query->setHighlight(array('pre_tags' => array($pre), 'post_tags' => array($post), 'fields' => $highlights));
try {
return $this->getType()->getIndex()->search($query);
} catch (\Elastica\Exception\ExceptionInterface $e) {
throw new TTMServerException($e->getMessage());
}
}
/**
* @SWG\Api(
* path="/posts/:id",
* @SWG\Operation(
* method="GET",
* summary="Gets a post",
* nickname="posts_get"
* )
* )
*/
function getById($id)
{
$result = array();
$body = $this->getBodyAsArray();
$required_parameters = array();
$optional_parameters = array('post_type');
$this->check_req_opt_param($required_parameters, $optional_parameters, $body);
$index = $this->elastica->getIndex($this->getElasticsearchIndex());
$query = new \Elastica\Query();
$boolean = new \Elastica\Query\Bool();
$added = false;
$type = isset($body['post_type']) ? $body['post_type'] : null;
if ($type) {
$q = new \Elastica\Query\Term(array("_type" => $type));
$boolean->addMust($q);
}
$q = new \Elastica\Query\Term(array("_id" => $id));
$boolean->addMust($q);
$query->setQuery($boolean);
$query->setSize(1);
$elasticaResultSet = $index->search($query);
$elasticaResults = $elasticaResultSet->getResults();
foreach ($elasticaResults as $elasticaResult) {
$result[] = $elasticaResult->getData();
}
echo json_encode($result);
}
private function ensureCirrusInfoFetched()
{
if ($this->cirrusInfo === null) {
$query = new \Elastica\Query();
$query->setSize(5000);
$res = $this->getConnection()->getIndex('mw_cirrus_versions')->getType('version')->getIndex()->search($query);
$this->cirrusInfo = array();
foreach ($res as $r) {
$data = $r->getData();
$this->cirrusInfo[$r->getId()] = array('shard_count' => $data['shard_count']);
}
}
}
if (!empty($param['date_from']) || !empty($param['date_to'])) {
$date_param = array();
if (!empty($param['date_from'])) {
$date_param["gte"] = date("Y-m-d H:i:s", strtotime($param['date_from']));
}
if (!empty($param['date_to'])) {
$date_param["lte"] = date("Y-m-d H:i:s", strtotime($param['date_to']));
}
$date_filter = new Elastica\Filter\NumericRange("create_date", $date_param);
$filter_list[] = $date_filter;
}
if (!empty($filter_list)) {
$filter->setFilters($filter_list);
$query = new Elastica\Query\Filtered($query, $filter);
}
$query = new Elastica\Query($query);
$query->setSort(array(array('create_date' => array('order' => 'desc'))));
$query->setSize(5000);
$start_time = microtime(true);
$result_set = $chat_type->search($query);
$end_time = microtime(true);
$data = array();
while ($result = $result_set->current()) {
$d = $result->getSource();
$d['id'] = $result->getId();
$data[] = $d;
$result_set->next();
}
$response = array('count' => $result_set->count(), 'data' => $data, 'time' => $end_time - $start_time);
header("Content-Type: application/json; charset=utf-8");
echo json_encode($response);
