public function action_index()
{
$this->view = new View_Search();
if ($this->request->query('query') !== NULL) {
$query = $this->request->query('query');
$queryString = new \Elastica\Query\QueryString();
$queryString->setDefaultOperator('AND');
$queryString->setQuery($query);
$elasticaQuery = new \Elastica\Query();
$elasticaQuery->setQuery($queryString);
$resultSet = ElasticSearch::instance()->search($elasticaQuery);
$results = $resultSet->getResults();
/** @var Kostache $renderer */
$renderer = Kostache::factory();
$out = array();
foreach ($results as $result) {
// Attempt to create the avatar instance.
try {
$refl = new ReflectionClass('View_Search_' . ucfirst($result->getType()));
$view = $refl->newInstance();
$view->data = $result->getData();
$out[] = $renderer->render($view);
} catch (ReflectionException $ex) {
Kohana::$log->add(LOG::ERROR, 'No search view class found for search type ":type".', array(':type' => $result->getType()));
}
}
$this->view->query = $query;
$this->view->results = $out;
}
}
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));
}
/**
* @param mixed $query
* @param string $lang
* @param string $type
*
* @return mixed|void
*/
public function defineSearch($query, $lang, $type)
{
$query = \Elastica\Util::escapeTerm($query);
$elasticaQueryLang = new \Elastica\Query\Term();
$elasticaQueryLang->setTerm('lang', $lang);
$elasticaQueryString = new \Elastica\Query\Match();
$elasticaQueryString->setFieldQuery('content', $query)->setFieldMinimumShouldMatch('content', '80%');
$elasticaQueryTitle = new \Elastica\Query\QueryString();
$elasticaQueryTitle->setDefaultField('title')->setBoost(2.0)->setQuery($query);
$elasticaQueryBool = new \Elastica\Query\BoolQuery();
$elasticaQueryBool->addMust($elasticaQueryLang)->addShould($elasticaQueryTitle)->addShould($elasticaQueryString)->setMinimumNumberShouldMatch(1);
$this->applySecurityContext($elasticaQueryBool);
if (!is_null($type)) {
$elasticaQueryType = new \Elastica\Query\Term();
$elasticaQueryType->setTerm('type', $type);
$elasticaQueryBool->addMust($elasticaQueryType);
}
$rootNode = $this->domainConfiguration->getRootNode();
if (!is_null($rootNode)) {
$elasticaQueryRoot = new \Elastica\Query\Term();
$elasticaQueryRoot->setTerm('root_id', $rootNode->getId());
$elasticaQueryBool->addMust($elasticaQueryRoot);
}
$this->query->setQuery($elasticaQueryBool);
$this->query->setHighlight(array('pre_tags' => array('<strong>'), 'post_tags' => array('</strong>'), 'fields' => array('content' => array('fragment_size' => 150, 'number_of_fragments' => 3))));
}
/**
*
* @return bool
*/
protected function getTrendExtensions()
{
$es = $this->app->container->get('elastica.client');
$elasticaQueryString = new \Elastica\Query\QueryString();
$elasticaQueryString->setQuery('*');
$elasticaQuery = new \Elastica\Query();
$elasticaQuery->setQuery($elasticaQueryString);
$elasticaQuery->setSort(["stars" => 'desc']);
$elasticaIndex = $es->getIndex('packages');
$results = $elasticaIndex->search($elasticaQuery);
$hits = [];
foreach ($results->getResults() as $result) {
$hits[] = $result->getHit();
}
return $hits;
}
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);
}
/**
* @Route("/get_usernames.json", name="get_usernames", options={"expose"=true})
*/
public function getUsernamesAction(Request $request)
{
$finder = $this->container->get('fos_elastica.finder.app.user');
$boolQuery = new \Elastica\Query\BoolQuery();
$fieldQuery = new \Elastica\Query\QueryString();
$fieldQuery->setFields(['username']);
$fieldQuery->setQuery($request->query->get('term') . "*");
$boolQuery->addMust($fieldQuery);
$tenantQuery = new \Elastica\Query\Term();
$tenantQuery->setTerm('id', $this->get('session')->get('tenant_id'));
$nestedQuery = new \Elastica\Query\Nested();
$nestedQuery->setPath('tenant');
$nestedQuery->setQuery($tenantQuery);
$boolQuery->addMust($nestedQuery);
$results = $finder->find($boolQuery);
$gravatar = $this->get('templating.helper.gravatar');
$users = [];
foreach ($results as $user) {
$users[] = ['value' => $user->getUsername(), 'uid' => 'user:'******'avatar' => $gravatar->getUrl($user->getEmail())];
}
return new JsonResponse($users);
}
if (full_url() != "http://lcm.touro.edu/" && full_url() != "https://lcm.touro.edu/") {
$url = full_url();
$url = str_replace("/", "\\/", $url);
$url = str_replace(":", "\\:", $url);
$field = "url";
$elasticaClient = new Elastica\Client(array('host' => 'search.touro.edu', 'port' => '80'));
switch ($_SERVER['REQUEST_METHOD']) {
case 'GET':
// Query string
if (isset($_GET['byid'])) {
include 'byid.php';
} else {
if (isset($_GET['fieldquery'])) {
$queryString = new Elastica\Query\Field($_GET['fieldquery'], $_GET['q']);
} else {
$queryString = new Elastica\Query\QueryString($_GET['q']);
$queryString->setDefaultOperator($_GET['default_operator']);
}
if (isset($_GET['fieldquery'])) {
//exact match filter code
if (isset($_GET['default_operator']) && $_GET['default_operator'] == "AND") {
$exactmatch = explode(' ', $_GET['q']);
//exact AND MATCH
foreach ($exactmatch as &$exm) {
$queryMatchTypeOf = new Elastica\Query\Match();
$queryMatchTypeOf->setFieldQuery($_GET['fieldquery'], $exm);
$elasticaTypeOfFilter = new Elastica\Filter\Query();
$elasticaTypeOfFilter->setQuery($queryMatchTypeOf);
$elasticaFilterAnd = new Elastica\Filter\BoolAnd();
$elasticaFilterAnd->addFilter($elasticaTypeOfFilter);
$filteredQuery = new Elastica\Query\Filtered($queryString, $elasticaTypeOfFilter);
/**
* To respect the design, 3 searches will be executed:
* 1st: retrieves the main facet (Text / Media / Portfolio / Users / Group) and the count for each of them
* 2nd: - retrieves the results of the first non empty facet term for display in the tab
* - retrieves the secondary facet to enable / disable the filter items
* 3nd: - retrieves the results with all filters applied
* @param unknown $query_string
* @param unknown $limit
* @param unknown $offset
* @param unknown $options
* @param unknown $mainfacetterm
* @param unknown $USER
* @return multitype:number boolean unknown Ambigous <boolean, NULL> Ambigous <boolean, unknown> multitype:multitype:string number Ambigous <string, unknown> |multitype:multitype:
*/
public static function search($query_string, $limit, $offset, $options, $mainfacetterm, $USER)
{
$result = array('count' => 0, 'limit' => $limit, 'offset' => $offset, 'data' => false, 'selected' => isset($mainfacetterm) && strlen($mainfacetterm) > 0 ? $mainfacetterm : false, 'totalresults' => 0, 'facets' => array(array('term' => "Text", 'count' => 0, 'display' => "Text"), array('term' => "Media", 'count' => 0, 'display' => "Media"), array('term' => "Portfolio", 'count' => 0, 'display' => "Portfolio"), array('term' => "User", 'count' => 0, 'display' => "Users"), array('term' => "Group", 'count' => 0, 'display' => "Group")), 'content-filter' => array(array('term' => "all", 'count' => 0, 'display' => "All"), array('term' => "Audio", 'count' => 0, 'display' => "Audio"), array('term' => "Comment", 'count' => 0, 'display' => "Comment"), array('term' => "Document", 'count' => 0, 'display' => "Document"), array('term' => "Folder", 'count' => 0, 'display' => "Folder"), array('term' => "Forum", 'count' => 0, 'display' => "Forum"), array('term' => "Forumpost", 'count' => 0, 'display' => "Forum post"), array('term' => "Image", 'count' => 0, 'display' => "Image"), array('term' => "Journal", 'count' => 0, 'display' => "Journal"), array('term' => "Journalentry", 'count' => 0, 'display' => "Journal entry"), array('term' => "Note", 'count' => 0, 'display' => "Note"), array('term' => "Plan", 'count' => 0, 'display' => "Plan"), array('term' => "Profile", 'count' => 0, 'display' => "Profile"), array('term' => "Resume", 'count' => 0, 'display' => "Résumé"), array('term' => "Video", 'count' => 0, 'display' => "Video"), array('term' => "Wallpost", 'count' => 0, 'display' => "Wall post"), array('term' => "Collection", 'count' => 0, 'display' => "Collection"), array('term' => "Page", 'count' => 0, 'display' => "Page")), 'content-filter-selected' => isset($options['secfacetterm']) && strlen($options['secfacetterm']) > 0 ? $options['secfacetterm'] : 'all', 'owner-filter' => array(array('term' => "all", 'count' => 0, 'display' => "All"), array('term' => "me", 'count' => 0, 'display' => "Me"), array('term' => "others", 'count' => 0, 'display' => "Others")), 'owner-filter-selected' => isset($options['owner']) && strlen($options['owner']) > 0 ? $options['owner'] : 'all', 'tagsonly' => isset($options['tagsonly']) && $options['tagsonly'] == true ? true : Null, 'sort' => isset($options['sort']) && strlen($options['sort']) > 0 ? $options['sort'] : 'score', 'license' => isset($options['license']) && strlen($options['license']) > 0 ? $options['license'] : 'all');
if (strlen($query_string) <= 0) {
return $result;
}
// 1- Get main facet
// ------------------------------------------------------------------------------------------
$records = array();
$elasticaClient = PluginSearchElasticsearch::make_client();
$elasticaIndex = $elasticaClient->getIndex(get_config_plugin('search', 'elasticsearch', 'indexname'));
$elasticaQueryString = new \Elastica\Query\QueryString();
$elasticaAnalyzer = get_config_plugin('search', 'elasticsearch', 'analyzer');
$elasticaQueryString->setAnalyzer($elasticaAnalyzer);
$elasticaQueryString->setDefaultOperator('AND');
$elasticaQueryString->setQuery($query_string);
// if tags only => set fields to tags
if ($result['tagsonly'] === true) {
$elasticaQueryString->setFields(array('tags'));
}
// Create the $elasticaQuery object
$elasticaQuery = new \Elastica\Query();
$elasticaQuery->setFrom($offset);
$elasticaQuery->setLimit($limit);
$elasticaQuery->setQuery($elasticaQueryString);
$elasticaFilterAnd = new \Elastica\Filter\BoolAnd();
// Apply ACL filters
$elasticaFilterACL = new ElasticsearchFilterAcl($USER);
$elasticaFilterAnd->addFilter($elasticaFilterACL);
$elasticaQuery->setFilter($elasticaFilterAnd);
// Define a new facet: mainFacetTerm - WARNING: don't forget to apply the same filter to the facet
$elasticaFacet = new \Elastica\Facet\Terms('mainFacetTerm');
$elasticaFacet->setField('mainfacetterm');
$elasticaFacet->setOrder('count');
$elasticaFacet->setFilter($elasticaFilterAnd);
$elasticaQuery->addFacet($elasticaFacet);
$elasticaResultSet = $elasticaIndex->search($elasticaQuery);
$result['totalresults'] = $elasticaResultSet->getTotalHits();
$elasticaFacets = $elasticaResultSet->getFacets();
$facets = self::process_facets($elasticaFacets['mainFacetTerm']['terms']);
if (count($facets) == 0) {
return $result;
}
array_walk($result['facets'], 'self::process_tabs', $facets);
if ($result['selected'] === false || $facets[$result['selected']] == 0) {
$result['selected'] = self::get_selected_facet($result['facets']);
}
// 2- Retrieve results of selected facet
// ------------------------------------------------------------------------------------------
$elasticaFilterType = new \Elastica\Filter\Term(array('mainfacetterm' => $result['selected']));
$elasticaFilterAnd->addFilter($elasticaFilterType);
$elasticaQuery->setFilter($elasticaFilterAnd);
// Define a new facet: secFacetTerm - WARNING: don't forget to apply the same filter to the facet
$elasticaFacet = new \Elastica\Facet\Terms('secFacetTerm');
$elasticaFacet->setField('secfacetterm');
$elasticaFacet->setOrder('count');
$elasticaFacet->setFilter($elasticaFilterAnd);
$elasticaQuery->addFacet($elasticaFacet);
// Sorting
// Sorting is defined on a per field level, so we must make sure the field exists in the mapping
$sort = explode('_', $result['sort']);
if ($sort[0] == 'score') {
$sort[0] = '_score';
}
// set the second column to sort by the score (to break any 'ties').
$elasticaQuery->setSort(array(array($sort[0] => array('order' => isset($sort[1]) ? $sort[1] : 'desc')), array('_score' => array('order' => 'desc'))));
$elasticaResultSet = $elasticaIndex->search($elasticaQuery);
$result['count'] = $elasticaResultSet->getTotalHits();
$elasticaFacets = $elasticaResultSet->getFacets();
$facets = $elasticaFacets['secFacetTerm']['terms'];
$facets = self::process_facets($elasticaFacets['secFacetTerm']['terms']);
array_walk($result['content-filter'], 'self::process_tabs', $facets);
// set the count of "all" to the total hits
$result['content-filter'][0]['count'] = $result['count'];
// 3- Apply filters and retrieve final results
// ------------------------------------------------------------------------------------------
// Apply Content filter if different from "all"
if ($result['content-filter-selected'] != 'all') {
$elasticaFilterContent = new \Elastica\Filter\Term(array('secfacetterm' => $result['content-filter-selected']));
$elasticaFilterAnd->addFilter($elasticaFilterContent);
}
// Apply Owner filter if different from "all"
if ($result['owner-filter-selected'] != 'all') {
$uid = $USER->get('id');
$elasticaFilterOwner = new \Elastica\Filter\Term(array('owner' => $uid));
if ($result['owner-filter-selected'] == 'others') {
$elasticaFilterOwner = new \Elastica\Filter\BoolNot($elasticaFilterOwner);
}
$elasticaFilterAnd->addFilter($elasticaFilterOwner);
}
// Apply license filter if different from "all"
if ($result['license'] != 'all') {
$elasticaFilterLicense = new \Elastica\Filter\Term(array('license' => $result['license']));
$elasticaFilterAnd->addFilter($elasticaFilterLicense);
}
$elasticaQuery->setFilter($elasticaFilterAnd);
$elasticaResultSet = $elasticaIndex->search($elasticaQuery);
$elasticaResults = $elasticaResultSet->getResults();
$result['count'] = $elasticaResultSet->getTotalHits();
foreach ($elasticaResults as $elasticaResult) {
$tmp = array();
$tmp['type'] = $elasticaResult->getType();
$ES_class = 'ElasticsearchType_' . $tmp['type'];
$tmp = $tmp + $elasticaResult->getData();
// Get all the data from the DB table
$dbrec = $ES_class::getRecordDataById($tmp['type'], $tmp['id']);
if ($dbrec) {
$tmp['db'] = $dbrec;
$tmp['db']->deleted = false;
} else {
// If the record has been deleted, so just pass the cached data
// from the search result. Let the template decide how to handle
// it.
$tmp['db'] = (object) $tmp;
$tmp['db']->deleted = true;
}
$records[] = $tmp;
}
$result['data'] = $records;
return $result;
}
public function applyAction($actionName, $httpVars, $fileVars)
{
$messages = ConfService::getMessages();
$repoId = $this->accessDriver->repository->getId();
if ($actionName == "search") {
// TMP
if (strpos($httpVars["query"], "keyword:") === 0) {
$parts = explode(":", $httpVars["query"]);
$this->applyAction("search_by_keyword", array("field" => $parts[1]), array());
return;
}
try {
$this->loadIndex($repoId, false);
} catch (Exception $ex) {
$this->applyAction("index", array(), array());
throw new Exception($messages["index.lucene.7"]);
}
$textQuery = $httpVars["query"];
if ($this->getFilteredOption("AUTO_WILDCARD") === true && strlen($textQuery) > 0 && ctype_alnum($textQuery)) {
if ($textQuery[0] == '"' && $textQuery[strlen($textQuery) - 1] == '"') {
$textQuery = substr($textQuery, 1, -1);
} else {
if ($textQuery[strlen($textQuery) - 1] != "*") {
$textQuery .= "*";
}
}
}
$this->currentIndex->open();
$fieldQuery = new Elastica\Query\QueryString();
$fieldQuery->setAllowLeadingWildcard(false);
$fieldQuery->setFuzzyMinSim(0.8);
if ($textQuery == "*") {
$fields = array("ajxp_node");
$fieldQuery->setQuery("yes");
$fieldQuery->setFields($fields);
} else {
if (strpos($textQuery, ":") !== false) {
// USE LUCENE DSL DIRECTLY (key1:value1 AND key2:value2...)
$textQuery = str_replace("ajxp_meta_ajxp_document_content:", "body:", $textQuery);
$textQuery = $this->filterSearchRangesKeywords($textQuery);
$fieldQuery->setQuery($textQuery);
} else {
$fields = array("basename", "ajxp_meta_*", "node_*", "body");
$fieldQuery->setQuery($textQuery);
$fieldQuery->setFields($fields);
}
}
/*
TODO : READAPT QUERY WITH EACH FIELD
if ((isSet($this->metaFields) || $this->indexContent) && isSet($httpVars["fields"])) {
$sParts = array();
foreach (explode(",",$httpVars["fields"]) as $searchField) {
if ($searchField == "filename") {
$sParts[] = "basename:".$httpVars["query"];
} else if (in_array($searchField, $this->metaFields)) {
$sParts[] = "ajxp_meta_".$searchField.":".$httpVars["query"];
} else if ($searchField == "ajxp_document_content") {
$sParts[] = "title:".$httpVars["query"];
$sParts[] = "body:".$httpVars["query"];
$sParts[] = "keywords:".$httpVars["query"];
}
}
$query = implode(" OR ", $sParts);
$query = "ajxp_scope:shared AND ($query)";
$this->logDebug("Query : $query");
} else {
*/
//}
/*
We create this object search because it'll allow us to fetch the number of results we want at once.
We just have to set some parameters, the query type and the size of the result set.
*/
$search = new Elastica\Search($this->client);
$search->addIndex($this->currentIndex)->addType($this->currentType);
$maxResults = $this->getFilteredOption("MAX_RESULTS");
if (isset($httpVars['limit'])) {
$maxResults = intval($httpVars['limit']);
}
$searchOptions = array(\Elastica\Search::OPTION_SEARCH_TYPE => \Elastica\Search::OPTION_SEARCH_TYPE_QUERY_THEN_FETCH, \Elastica\Search::OPTION_SIZE => $maxResults);
$this->logDebug(__FUNCTION__, "Executing query: ", $textQuery);
$fullQuery = new Elastica\Query();
$fullQuery->setQuery($fieldQuery);
$qb = new Elastica\QueryBuilder();
$fullQuery = new Elastica\Query();
$fullQuery->setQuery($qb->query()->filtered($fieldQuery, $qb->filter()->bool()->addMust(new Elastica\Filter\Term(array("ajxp_scope" => "shared")))));
$result = $search->search($fullQuery, $searchOptions);
$this->logDebug(__FUNCTION__, "Search finished. ");
$hits = $result->getResults();
AJXP_XMLWriter::header();
foreach ($hits as $hit) {
$source = $hit->getSource();
if ($source["serialized_metadata"] != null) {
$meta = unserialize(base64_decode($source["serialized_metadata"]));
$tmpNode = new AJXP_Node(SystemTextEncoding::fromUTF8($source["node_url"]), $meta);
} else {
$tmpNode = new AJXP_Node(SystemTextEncoding::fromUTF8($source["node_url"]), array());
$tmpNode->loadNodeInfo();
}
if (!file_exists($tmpNode->getUrl())) {
$this->currentType->deleteById($hit->getId());
continue;
}
$tmpNode->search_score = sprintf("%0.2f", $hit->getScore());
AJXP_XMLWriter::renderAjxpNode($tmpNode);
}
AJXP_XMLWriter::close();
} else {
if ($actionName == "search_by_keyword") {
$scope = "user";
try {
$this->loadIndex($repoId, false);
} catch (Exception $ex) {
throw new Exception($messages["index.lucene.7"]);
}
$sParts = array();
$searchField = $httpVars["field"];
if ($scope == "user") {
if (AuthService::usersEnabled() && AuthService::getLoggedUser() == null) {
throw new Exception("Cannot find current user");
}
$sParts[] = "ajxp_scope:user";
$sParts[] = "ajxp_user:"******"ajxp_scope:shared";
}
$query = implode(" AND ", $sParts);
$this->logDebug("Query : {$query}");
$fieldQuery = new Elastica\Query\QueryString();
$fields = array($searchField);
$fieldQuery->setQuery($searchField == "ajxp_node" ? "yes" : "true");
$fieldQuery->setFields($fields);
$fieldQuery->setAllowLeadingWildcard(false);
$fieldQuery->setFuzzyMinSim(0.8);
$search = new Elastica\Search($this->client);
$search->addIndex($this->currentIndex)->addType($this->currentType);
$maxResults = $this->getFilteredOption("MAX_RESULTS");
if (isset($httpVars['limit'])) {
$maxResults = intval($httpVars['limit']);
}
$searchOptions = array(\Elastica\Search::OPTION_SEARCH_TYPE => \Elastica\Search::OPTION_SEARCH_TYPE_QUERY_THEN_FETCH, \Elastica\Search::OPTION_SIZE => $maxResults);
// ADD SCOPE FILTER
$term = new Elastica\Filter\Term();
$term->setTerm("ajxp_scope", "user");
$qb = new Elastica\QueryBuilder();
$fullQuery = new Elastica\Query();
$fullQuery->setQuery($qb->query()->filtered($fieldQuery, $qb->filter()->bool()->addMust(new Elastica\Filter\Term(array("ajxp_scope" => "user")))->addMust(new Elastica\Filter\Term(array("user" => AuthService::getLoggedUser()->getId())))));
$result = $search->search($fullQuery, $searchOptions);
$this->logDebug(__FUNCTION__, "Search finished. ");
$hits = $result->getResults();
AJXP_XMLWriter::header();
foreach ($hits as $hit) {
if ($hit->serialized_metadata != null) {
$meta = unserialize(base64_decode($hit->serialized_metadata));
$tmpNode = new AJXP_Node(SystemTextEncoding::fromUTF8($hit->node_url), $meta);
} else {
$tmpNode = new AJXP_Node(SystemTextEncoding::fromUTF8($hit->node_url), array());
$tmpNode->loadNodeInfo();
}
if (!file_exists($tmpNode->getUrl())) {
$this->currentType->deleteById($hit->id);
continue;
}
$tmpNode->search_score = sprintf("%0.2f", $hit->score);
AJXP_XMLWriter::renderAjxpNode($tmpNode);
}
AJXP_XMLWriter::close();
}
}
}
public function searchSample($criteria, $dataset, $sorts = array(), $operator = 'OR')
{
/*if($limit <= 0) {
$limit = Yii::app()->params['es_search']['limits']['default'];
}*/
$keyword = $criteria['keyword'];
$eQueryString = new \Elastica\Query\QueryString();
$eQueryString->setDefaultOperator($operator);
$eQueryString->setQuery($keyword);
$eQuery = new \Elastica\Query();
$eQuery->setQuery($eQueryString);
//$eQuery->setFrom($offset);
//$eQuery->setLimit($limit);
$filterAnd = new \Elastica\Filter\BoolAnd();
if (isset($criteria['common_name'])) {
$filterAnd->addFilter($this->newTerms('common_name', $criteria['common_name']));
}
if (is_array($dataset) && !empty($dataset)) {
$ids = new \Elastica\Filter\Ids();
$ids->setIds($dataset);
$filterAnd->addFilter($ids);
}
$arrayAnd = $filterAnd;
$arrayAnd = $arrayAnd->toArray();
if (count($arrayAnd['and']) > 0) {
$eQuery->setPostFilter($filterAnd);
}
$sortList = array_merge(array('_score' => array('order' => 'desc')), $sorts);
$eQuery->setSort($sortList);
$index = Yii::app()->elastic->client->getIndex('gigadb');
$type = $index->getType('sample');
$eResultSet = $type->search($eQuery);
$results = $eResultSet->getResults();
$total = $eResultSet->getTotalHits();
$data = array();
foreach ($results as $result) {
if ($result) {
$data[] = $result->getData();
}
}
$re = array('data' => $data, 'total' => $total);
//Yii::log(print_r($re, true), 'debug');
return $re;
}
/**
* @param string $queryString
* @param array $options
* @return \Elastica\Query
*/
protected function buildQueryObject($queryString, $options)
{
// trying to match everything, make a MatchAll query
if ($queryString == '*') {
$queryObj = new \Elastica\Query\MatchAll();
} else {
$qString = html_entity_decode($queryString, ENT_QUOTES);
// we need to escape slash for lucene query_string query
$qString = str_replace('/', '\\/', $qString);
$queryObj = new \Elastica\Query\QueryString($qString);
$queryObj->setAnalyzeWildcard(true);
$queryObj->setAutoGeneratePhraseQueries(false);
// set query string fields
$options['addSearchBoosts'] = true;
$fields = $this->getSearchFields($options);
$options['addSearchBoosts'] = false;
if (!empty($options['searchFields'])) {
$queryObj->setFields($options['searchFields']);
} else {
$queryObj->setFields($fields);
}
}
return $queryObj;
}
/**
* Builds a query based on QueryString syntax
* @param array $fields the fields
* @param string $queryString the query
* @param integer $phraseSlop phrase slop
* @param string $defaultOperator the default operator AND or OR
* @return \Elastica\Query\QueryString
*/
public function buildQueryString(array $fields, $queryString, $phraseSlop, $defaultOperator = 'AND')
{
$query = new \Elastica\Query\QueryString($queryString);
$query->setFields($fields);
$query->setAutoGeneratePhraseQueries(true);
$query->setPhraseSlop($phraseSlop);
$query->setDefaultOperator($defaultOperator);
$query->setAllowLeadingWildcard($this->context->isAllowLeadingWildcards());
$query->setFuzzyPrefixLength(2);
$query->setRewrite('top_terms_boost_1024');
return $query;
}
/**
* @param string $q
* @return \Elastica\Query\AbstractQuery
*/
protected function _getBaseQuery($q)
{
if (empty($q)) {
$baseQuery = new \Elastica\Query\MatchAll();
} else {
$q = $this->_helper->_searchQuery($q);
$baseQuery = new \Elastica\Query\Bool();
if ($this->isFuzzyQueryEnabled()) {
$fuzzy = new \Elastica\Query\FuzzyLikeThis();
$fuzzy->addFields($this->_getSearchFields(true, $q))->setLikeText($q)->setMinSimilarity($this->getFuzzyMinSimilarity())->setPrefixLength($this->getFuzzyPrefixLength())->setMaxQueryTerms($this->getFuzzyMaxQueryTerms())->setBoost($this->getFuzzyQueryBoost());
$baseQuery->addShould($fuzzy);
}
$queryString = new \Elastica\Query\QueryString($q);
$queryString->setFields($this->_getSearchFields(true, $q));
$queryString->setDefaultOperator($this->getQueryOperator());
$queryString->setBoost('2');
$baseQuery->addShould($queryString);
}
return $baseQuery;
}
/**
* Apply PageType specific and Page specific boosts
*
* @return \Elastica\Query\BoolQuery
*/
protected function getPageBoosts()
{
$rescoreQueryBool = new \Elastica\Query\BoolQuery();
//Apply page type boosts
$pageClasses = $this->em->getRepository('KunstmaanNodeBundle:Node')->findAllDistinctPageClasses();
foreach ($pageClasses as $pageClass) {
$page = new $pageClass['refEntityName']();
if ($page instanceof SearchBoostInterface) {
$elasticaQueryTypeBoost = new \Elastica\Query\QueryString();
$elasticaQueryTypeBoost->setBoost($page->getSearchBoost())->setDefaultField('page_class')->setQuery(addslashes($pageClass['refEntityName']));
$rescoreQueryBool->addShould($elasticaQueryTypeBoost);
}
}
//Apply page specific boosts
$nodeSearches = $this->em->getRepository('KunstmaanNodeSearchBundle:NodeSearch')->findAll();
foreach ($nodeSearches as $nodeSearch) {
$elasticaQueryNodeId = new \Elastica\Query\QueryString();
$elasticaQueryNodeId->setBoost($nodeSearch->getBoost())->setDefaultField('node_id')->setQuery($nodeSearch->getNode()->getId());
$rescoreQueryBool->addShould($elasticaQueryNodeId);
}
return $rescoreQueryBool;
}
/**
* Builds a query based on QueryString syntax
* @param array $fields the fields
* @param string $queryString the query
* @param integer $phraseSlop phrase slop
* @param string $defaultOperator the default operator AND or OR
* @return \Elastica\Query\QueryString
*/
public function buildQueryString(array $fields, $queryString, $phraseSlop, $defaultOperator = 'AND')
{
$query = new \Elastica\Query\QueryString($queryString);
$query->setFields($fields);
$query->setAutoGeneratePhraseQueries(true);
$query->setPhraseSlop($phraseSlop);
$query->setDefaultOperator($defaultOperator);
$query->setAllowLeadingWildcard($this->context->isAllowLeadingWildcards());
$query->setFuzzyPrefixLength(2);
$query->setRewrite('top_terms_boost_1024');
$states = $this->context->getConfig()->get('CirrusSearchQueryStringMaxDeterminizedStates');
if (isset($states)) {
// Requires ES 1.4+
$query->setParam('max_determinized_states', $states);
}
return $query;
}
/**
* Main method to make a search
*/
public function search()
{
$this->getSearchFields();
$word = JRequest::getString('searchword', null, 'get');
$offset = JRequest::getInt('start', 0, 'get');
$limit = JRequest::getInt('limit', 10, 'get');
if ($limit == 0) {
// no limit
$limit = 10000;
}
$this->getSearchAreas();
$elasticaQueryString = new \Elastica\Query\QueryString();
// Log search word only on the first page
if ($offset == 0) {
SearchHelper::logSearch($word);
}
// Convert accents
$word = htmlentities($word, ENT_NOQUOTES, 'utf-8');
$word = preg_replace('#\\&([A-za-z])(?:uml|circ|tilde|acute|grave|cedil|ring)\\;#', '\\1', $word);
$word = preg_replace('#\\&([A-za-z]{2})(?:lig)\\;#', '\\1', $word);
$word = preg_replace('#\\&[^;]+\\;#', '', $word);
// Check if there are quotes ( for exact search )
$exactSearch = false;
if (strlen($word) > 1 && $word[0] == '"' && $word[strlen($word) - 1] == '"') {
$exactSearch = true;
$word = substr($word, 1, strlen($word) - 2);
// Remove external "
}
$word = Elastica\Util::replaceBooleanWordsAndEscapeTerm($word);
// Escape ElasticSearch specials char
if ($exactSearch) {
$word = '"' . $word . '"';
}
if ($word == "") {
$word = "*";
}
$elasticaQueryString->setQuery($word);
//Create the actual search object with some data.
$elasticaQuery = new Elastica\Query();
$elasticaQuery->setQuery($elasticaQueryString);
if (ElasticSearchConfig::getHighLigthEnable()) {
$fields = $this->getHighlightFields();
$hlfields = array();
foreach ($fields as $field) {
foreach ($field as $highlight) {
$hlfields[] = array($highlight => array('fragment_size' => 1000, 'number_of_fragments' => 1));
}
}
$highlightFields = array('pre_tags' => array(ElasticSearchConfig::getHighLigthPre()), 'post_tags' => array(ElasticSearchConfig::getHighLigthPost()), "order" => "score", 'fields' => $hlfields);
$elasticaQuery->setHighlight($highlightFields);
}
// Set offset and limit for pagination
$elasticaQuery->setFrom($offset);
$elasticaQuery->setLimit($limit);
//Create a filter for _type
$elasticaFilterype = $this->createFilterType($this->areas);
// Add filter to the search object.
$elasticaQuery->setFilter($elasticaFilterype);
//Search on the index.
$elasticaResultSet = $this->elasticaIndex->search($elasticaQuery);
$this->results = $elasticaResultSet->getResults();
$this->totalHits = $elasticaResultSet->getTotalHits();
}
public function searchArtistAction(Request $request)
{
$query = $request->get('query', null);
// notre index est directement disponible sous forme de service
$index = $this->container->get('fos_elastica.index.wte.artiste');
$searchQuery = new \Elastica\Query\QueryString();
$searchQuery->setParam('query', $query);
// nous forçons l'opérateur de recherche à AND, car on veut les résultats qui
// correspondent à tous les mots de la recherche, plutôt qu'à au moins un
// d'entre eux (opérateur OR)
$searchQuery->setDefaultOperator('AND');
// on exécute une requête de type "fields", qui portera sur les colonnes "name"
$searchQuery->setParam('fields', array('prenom'));
// exécution de la requête, limitée aux 20 premiers résultats
$results = $index->search($searchQuery, 20)->getResults();
$data = array();
// on arrange les données des résultats...
foreach ($results as $result) {
$source = $result->getSource();
$data[] = array('id' => $source['id'], 'name' => $source['prenom']);
}
return new JsonResponse($data, 200, array('Cache-Control' => 'no-cache'));
}
/**
* Méthode utilisée pour la loupe dans les recherches classique qui affiche les volets avec les résultats de chaque type.
*
* @param string $words Les mots recherchés
* @param string $name Le nom de l'index
* @param array $types Les types sur lesquels on effectue la recherche
*
* @return \Elastica\ResultSet
*/
function queryByType($words, $name, $types)
{
// La query de recherche
$query_words = new Elastica\Query\QueryString();
$query_words->setQuery($words);
$query_words->setFields(array("body", "title"));
$query_words->setDefaultOperator("and");
// Aggregation par type
$agg_by_type = new CSearchAggregation("Terms", "ref_type", "_type", 100);
$query = new Query($query_words);
$query->addAggregation($agg_by_type->_aggregation);
//Search on the index.
$this->_index = $this->loadIndex($name);
$search = new \Elastica\Search($this->_client);
$search->addIndex($this->_index);
$search->addTypes($types);
return $search->search($query);
}