public virtual List <SearchFacet> GetSearchFacets(IQueryExpression expression, string[] groupByFields, Directory directory = null) { if (directory == null) { directory = LuceneContext.Directory; } groupByFields = groupByFields.Select(x => ContentIndexHelpers.GetIndexFieldName(x)).ToArray(); var result = new List <SearchFacet>(); using (IndexReader indexReader = IndexReader.Open(directory, true)) { var queryParser = new MultiFieldQueryParser(LuceneConfiguration.LuceneVersion, expression.GetFieldName() , LuceneConfiguration.Analyzer); queryParser.AllowLeadingWildcard = true; var query = queryParser.Parse(expression.GetExpression()); SimpleFacetedSearch facetSearch = new SimpleFacetedSearch(indexReader, groupByFields); SimpleFacetedSearch.Hits hits = facetSearch.Search(query, int.MaxValue); long totalHits = hits.TotalHitCount; foreach (SimpleFacetedSearch.HitsPerFacet hitPerGroup in hits.HitsPerFacet) { long hitCountPerGroup = hitPerGroup.HitCount; result.Add(new SearchFacet() { Count = hitPerGroup.HitCount, Term = hitPerGroup.Name.ToString() }); } } return(result); }
/// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> /// <param name="query"></param> /// <param name="facets"></param> /// <returns></returns> public static IEnumerable<Property> propertySearch(Query query, IEnumerable<Property> properties) { foreach (Property p in properties) { using (SimpleFacetedSearch sfs = new SimpleFacetedSearch(_Reader, new string[] { "property_" + p.Name })) { SimpleFacetedSearch.Hits hits = sfs.Search(query); int cCount = 0; List<string> tmp = new List<string>(); foreach (SimpleFacetedSearch.HitsPerFacet hpg in hits.HitsPerFacet) { if (!String.IsNullOrEmpty(hpg.Name.ToString())) { if ((int)hpg.HitCount > 0) tmp.Add(hpg.Name.ToString()); } } p.Values = tmp; } } return properties; }
/// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> /// <param name="query"></param> /// <param name="facets"></param> /// <returns></returns> public static IEnumerable<Facet> facetSearch(Query query, IEnumerable<Facet> facets) { List<Facet> l = new List<Facet>(); foreach (Facet f in facets) { Facet c = new Facet(); c.Name = f.Name; c.Text = f.Text; c.Value = f.Value; c.DisplayName = f.DisplayName; c.Childrens = new List<Facet>(); using (SimpleFacetedSearch sfs = new SimpleFacetedSearch(_Reader, new string[] { "facet_" + f.Name })) { SimpleFacetedSearch.Hits hits = sfs.Search(query); int cCount = 0; foreach (SimpleFacetedSearch.HitsPerFacet hpg in hits.HitsPerFacet) { if (!hpg.Name.ToString().Equals("")) { Facet cc = new Facet(); cc.Name = hpg.Name.ToString(); cc.Text = hpg.Name.ToString(); cc.Value = hpg.Name.ToString(); cc.Count = (int)hpg.HitCount; if (cc.Count > 0) cCount++; c.Childrens.Add(cc); } } c.Count = cCount; l.Add(c); } } return l; }
public IDictionary <IDictionary <string, string>, long> SearchGetFacets(string term, string prefix, bool usePrefixQuery, DateTime?start, DateTime?end, int numResults, bool canViewAndSearchAll, bool includeRestrictedSources, string uploadedByUserId, IList <string> owners) { IDictionary <IDictionary <string, string>, long> facetCount = new Dictionary <IDictionary <string, string>, long>(); try { string[] fieldNames = new string[] { //"IsRestricted", //"IsReadOnly", "UploadedBy" //"IsPublic" }; using (SimpleFacetedSearch sfs = new SimpleFacetedSearch(SourceIndexWriterSingleton.Instance.GetReader(), fieldNames)) { Query query = this.BuildQuery(term, prefix, usePrefixQuery, start, end, canViewAndSearchAll, includeRestrictedSources, uploadedByUserId, owners); SimpleFacetedSearch.Hits hits = sfs.Search(query, numResults); //long totalHits = hits.TotalHitCount; foreach (SimpleFacetedSearch.HitsPerFacet hpg in hits.HitsPerFacet) { // HitsPerFacet.Name can be treated like an array whose values match the fieldNames array we fed into SimpleFacetedSearch() // constructor above. IDictionary <string, string> key = new Dictionary <string, string>(); for (int i = 0; i < hpg.Name.Length; i++) { key.Add(fieldNames[i], hpg.Name[i]); } facetCount.Add(key, hpg.HitCount); } } } catch (NullReferenceException e) { log.Error("SimpleFacetedSearch constructor fails when source index is empty: could this be the case?", e); } return(facetCount); }
public IList <FacetedSearchResult> FacetedSearch(BaristaIndexDefinition indexDefinition, SearchArguments arguments) { if (arguments == null) { arguments = new SearchArguments(); } try { var index = GetOrAddIndex(indexDefinition, true); var searchParams = GetLuceneSearchParams(arguments); IndexSearcher indexSearcher; using (index.GetSearcher(out indexSearcher)) { var reader = indexSearcher.IndexReader; if (arguments.GroupByFields == null) { arguments.GroupByFields = new List <string>(); } var facetedSearch = new SimpleFacetedSearch(reader, arguments.GroupByFields.ToArray()); var hits = facetedSearch.Search(searchParams.Query, searchParams.MaxResults); var result = hits.HitsPerFacet .AsQueryable() .OrderByDescending(hit => hit.HitCount) .Select(facetHits => RetrieveFacetSearchResults(facetHits)) .ToList(); return(result); } } catch (Exception ex) { throw new FaultException(ex.Message); } }
/// <summary> /// Perform a Look search /// </summary> /// <param name="lookQuery">A LookQuery model for the search criteria</param> /// <returns>A LookResult model for the search response</returns> internal static LookResult Search(LookQuery lookQuery) { if (lookQuery == null) { return(LookResult.Error("LookQuery object was null")); } if (lookQuery.SearchingContext == null) // supplied by unit test to skip examine dependency { // attempt to get searching context from examine searcher name lookQuery.SearchingContext = LookService.GetSearchingContext(lookQuery.SearcherName); if (lookQuery.SearchingContext == null) { return(LookResult.Error("SearchingContext was null")); } } if (lookQuery.Compiled == null) { var parsingContext = new ParsingContext(); // for building/compiling the query try { LookService.ParseRawQuery(parsingContext, lookQuery); LookService.ParseExamineQuery(parsingContext, lookQuery); LookService.ParseNodeQuery(parsingContext, lookQuery); LookService.ParseNameQuery(parsingContext, lookQuery); LookService.ParseDateQuery(parsingContext, lookQuery); LookService.ParseTextQuery(parsingContext, lookQuery); LookService.ParseTagQuery(parsingContext, lookQuery); LookService.ParseLocationQuery(parsingContext, lookQuery); } catch (ParsingException parsingException) { return(LookResult.Error(parsingException.Message)); } if (parsingContext.HasQuery) { lookQuery.Compiled = new LookQueryCompiled(lookQuery, parsingContext); } else { return(LookResult.Error("Unable to compile query - a query clause is required")); // empty failure } } TopDocs topDocs = lookQuery .SearchingContext .IndexSearcher .Search( lookQuery.Compiled.Query, lookQuery.Compiled.Filter, lookQuery.MaxResults, lookQuery.Compiled.Sort); if (topDocs.TotalHits > 0) { List <Facet> facets = null; if (lookQuery.TagQuery != null && lookQuery.TagQuery.FacetOn != null) { facets = new List <Facet>(); Query facetQuery = lookQuery.Compiled.Filter != null ? (Query) new FilteredQuery(lookQuery.Compiled.Query, lookQuery.Compiled.Filter) : lookQuery.Compiled.Query; // do a facet query for each group in the array foreach (var group in lookQuery.TagQuery.FacetOn.TagGroups) { var simpleFacetedSearch = new SimpleFacetedSearch( lookQuery.SearchingContext.IndexSearcher.GetIndexReader(), LookConstants.TagsField + group); var facetResult = simpleFacetedSearch.Search(facetQuery); facets.AddRange( facetResult .HitsPerFacet .Select( x => new Facet() { Tags = new LookTag[] { new LookTag(group, x.Name.ToString()) }, Count = Convert.ToInt32(x.HitCount) } )); } } return(new LookResult( lookQuery, topDocs, facets != null ? facets.ToArray() : new Facet[] { })); } return(LookResult.Empty()); // empty success }
/// <summary> /// Perform a Look search /// </summary> /// <param name="lookQuery">A LookQuery model for the search criteria</param> /// <returns>A LookResult model for the search response</returns> public static LookResult RunQuery(LookQuery lookQuery) { // flag to indicate whether there are any query clauses in the supplied LookQuery bool hasQuery = lookQuery?.Compiled != null ? true : false; if (lookQuery == null) { return(new LookResult("LookQuery object was null")); } if (lookQuery.SearchingContext == null) // supplied by unit test to skip examine dependency { // attempt to get searching context from examine searcher name lookQuery.SearchingContext = LookService.GetSearchingContext(lookQuery.SearcherName); if (lookQuery.SearchingContext == null) { return(new LookResult("SearchingContext was null")); } } if (lookQuery.Compiled == null) { BooleanQuery query = null; // the lucene query being built Filter filter = null; // used for geospatial queries Sort sort = null; Func <string, IHtmlString> getHighlight = x => null; Func <int, double?> getDistance = x => null; query = new BooleanQuery(); #region RawQuery if (!string.IsNullOrWhiteSpace(lookQuery.RawQuery)) { hasQuery = true; query.Add( new QueryParser(Lucene.Net.Util.Version.LUCENE_29, null, lookQuery.SearchingContext.Analyzer).Parse(lookQuery.RawQuery), BooleanClause.Occur.MUST); } #endregion #region ExamineQuery if (lookQuery.ExamineQuery != null) { var luceneSearchCriteria = lookQuery.ExamineQuery as LuceneSearchCriteria; if (luceneSearchCriteria.Query != null) { hasQuery = true; query.Add(luceneSearchCriteria.Query, BooleanClause.Occur.MUST); } } #endregion #region NodeQuery if (lookQuery.NodeQuery != null) { hasQuery = true; query.Add(new TermQuery(new Term(LookConstants.HasNodeField, "1")), BooleanClause.Occur.MUST); if (lookQuery.NodeQuery.Types != null && lookQuery.NodeQuery.Types.Any()) { var nodeTypeQuery = new BooleanQuery(); foreach (var nodeType in lookQuery.NodeQuery.Types) { nodeTypeQuery.Add( new TermQuery( new Term(LookConstants.NodeTypeField, nodeType.ToString())), BooleanClause.Occur.SHOULD); } query.Add(nodeTypeQuery, BooleanClause.Occur.MUST); } switch (lookQuery.NodeQuery.DetachedQuery) { case DetachedQuery.ExcludeDetached: query.Add( new TermQuery(new Term(LookConstants.IsDetachedField, "1")), BooleanClause.Occur.MUST_NOT); break; case DetachedQuery.OnlyDetached: query.Add( new TermQuery(new Term(LookConstants.IsDetachedField, "1")), BooleanClause.Occur.MUST); break; } if (lookQuery.NodeQuery.Cultures != null && lookQuery.NodeQuery.Cultures.Any()) { var nodeCultureQuery = new BooleanQuery(); foreach (var nodeCulture in lookQuery.NodeQuery.Cultures) { nodeCultureQuery.Add( new TermQuery( new Term(LookConstants.CultureField, nodeCulture.LCID.ToString())), BooleanClause.Occur.SHOULD); } query.Add(nodeCultureQuery, BooleanClause.Occur.MUST); } if (lookQuery.NodeQuery.Aliases != null && lookQuery.NodeQuery.Aliases.Any()) { var nodeAliasQuery = new BooleanQuery(); foreach (var typeAlias in lookQuery.NodeQuery.Aliases) { nodeAliasQuery.Add( new TermQuery(new Term(LookConstants.NodeAliasField, typeAlias.ToLower())), BooleanClause.Occur.SHOULD); } query.Add(nodeAliasQuery, BooleanClause.Occur.MUST); } if (lookQuery.NodeQuery.NotIds != null && lookQuery.NodeQuery.NotIds.Any()) { foreach (var exculudeId in lookQuery.NodeQuery.NotIds) { query.Add( new TermQuery(new Term(LookConstants.NodeIdField, exculudeId.ToString())), BooleanClause.Occur.MUST_NOT); } } if (lookQuery.NodeQuery.NotKeys != null && lookQuery.NodeQuery.NotKeys.Any()) { foreach (var excludeKey in lookQuery.NodeQuery.NotKeys) { query.Add( new TermQuery(new Term(LookConstants.NodeKeyField, excludeKey)), BooleanClause.Occur.MUST_NOT); } } } #endregion #region NameQuery if (lookQuery.NameQuery != null) { hasQuery = true; query.Add(new TermQuery(new Term(LookConstants.HasNameField, "1")), BooleanClause.Occur.MUST); string wildcard1 = null; string wildcard2 = null; // incase Contains specified with StartsWith and/or EndsWith if (!string.IsNullOrEmpty(lookQuery.NameQuery.StartsWith)) { if (!string.IsNullOrEmpty(lookQuery.NameQuery.Is)) { if (!lookQuery.NameQuery.Is.StartsWith(lookQuery.NameQuery.StartsWith)) { return(new LookResult("Conflict in NameQuery between Is and StartsWith")); } } else { wildcard1 = lookQuery.NameQuery.StartsWith + "*"; } } if (!string.IsNullOrEmpty(lookQuery.NameQuery.EndsWith)) { if (!string.IsNullOrEmpty(lookQuery.NameQuery.Is)) { if (!lookQuery.NameQuery.Is.EndsWith(lookQuery.NameQuery.EndsWith)) { return(new LookResult("Conflict in NameQuery between Is and EndsWith")); } } else { if (wildcard1 == null) { wildcard1 = "*" + lookQuery.NameQuery.EndsWith; } else { wildcard1 += lookQuery.NameQuery.EndsWith; } } } if (!string.IsNullOrEmpty(lookQuery.NameQuery.Contains)) { if (!string.IsNullOrEmpty(lookQuery.NameQuery.Is)) { if (!lookQuery.NameQuery.Is.Contains(lookQuery.NameQuery.Contains)) { return(new LookResult("Conflict in NameQuery between Is and Contains")); } } else { if (wildcard1 == null) { wildcard1 = "*" + lookQuery.NameQuery.Contains + "*"; } else { wildcard2 = "*" + lookQuery.NameQuery.Contains + "*"; } } } var nameField = lookQuery.NameQuery.CaseSensitive ? LookConstants.NameField : LookConstants.NameField + "_Lowered"; if (wildcard1 != null) { var wildcard = lookQuery.NameQuery.CaseSensitive ? wildcard1 : wildcard1.ToLower(); query.Add(new WildcardQuery(new Term(nameField, wildcard)), BooleanClause.Occur.MUST); if (wildcard2 != null) { wildcard = lookQuery.NameQuery.CaseSensitive ? wildcard2 : wildcard2.ToLower(); query.Add(new WildcardQuery(new Term(nameField, wildcard)), BooleanClause.Occur.MUST); } } if (!string.IsNullOrEmpty(lookQuery.NameQuery.Is)) { var isText = lookQuery.NameQuery.CaseSensitive ? lookQuery.NameQuery.Is : lookQuery.NameQuery.Is.ToLower(); query.Add(new TermQuery(new Term(nameField, isText)), BooleanClause.Occur.MUST); } } #endregion #region DateQuery if (lookQuery.DateQuery != null) { hasQuery = true; query.Add(new TermQuery(new Term(LookConstants.HasDateField, "1")), BooleanClause.Occur.MUST); if (lookQuery.DateQuery.After.HasValue || lookQuery.DateQuery.Before.HasValue) { var includeLower = lookQuery.DateQuery.After == null || lookQuery.DateQuery.Boundary == DateBoundary.Inclusive || lookQuery.DateQuery.Boundary == DateBoundary.BeforeExclusiveAfterInclusive; var includeUpper = lookQuery.DateQuery.Before == null || lookQuery.DateQuery.Boundary == DateBoundary.Inclusive || lookQuery.DateQuery.Boundary == DateBoundary.BeforeInclusiveAfterExclusive; query.Add( new TermRangeQuery( LookConstants.DateField, lookQuery.DateQuery.After.DateToLuceneString() ?? DateTime.MinValue.DateToLuceneString(), lookQuery.DateQuery.Before.DateToLuceneString() ?? DateTime.MaxValue.DateToLuceneString(), includeLower, includeUpper), BooleanClause.Occur.MUST); } } #endregion #region TextQuery if (lookQuery.TextQuery != null) { hasQuery = true; query.Add(new TermQuery(new Term(LookConstants.HasTextField, "1")), BooleanClause.Occur.MUST); if (!string.IsNullOrWhiteSpace(lookQuery.TextQuery.SearchText)) { var queryParser = new QueryParser(Lucene.Net.Util.Version.LUCENE_29, LookConstants.TextField, lookQuery.SearchingContext.Analyzer); Query searchTextQuery = null; try { searchTextQuery = queryParser.Parse(lookQuery.TextQuery.SearchText); } catch { return(new LookResult($"Unable to parse LookQuery.TextQuery.SearchText: '{ lookQuery.TextQuery.SearchText }' into a Lucene query")); } if (searchTextQuery != null) { query.Add(searchTextQuery, BooleanClause.Occur.MUST); if (lookQuery.TextQuery.GetHighlight) { var queryScorer = new QueryScorer(searchTextQuery.Rewrite(lookQuery.SearchingContext.IndexSearcher.GetIndexReader())); var highlighter = new Highlighter(new SimpleHTMLFormatter("<strong>", "</strong>"), queryScorer); getHighlight = (x) => { var tokenStream = lookQuery.SearchingContext.Analyzer.TokenStream(LookConstants.TextField, new StringReader(x)); var highlight = highlighter.GetBestFragments( tokenStream, x, 1, // max number of fragments "..."); return(new HtmlString(highlight)); }; } } } } #endregion #region TagQuery if (lookQuery.TagQuery != null) { hasQuery = true; query.Add(new TermQuery(new Term(LookConstants.HasTagsField, "1")), BooleanClause.Occur.MUST); if (lookQuery.TagQuery.All != null) { if (lookQuery.TagQuery.Not != null) { var conflictTags = lookQuery.TagQuery.All.Where(x => !lookQuery.TagQuery.Not.Contains(x)); if (conflictTags.Any()) { return(new LookResult($"Conflict in TagQuery, tags: '{ string.Join(",", conflictTags) }' are in both AllTags and NotTags")); } } if (lookQuery.TagQuery.All.Any()) { foreach (var tag in lookQuery.TagQuery.All) { query.Add( new TermQuery(new Term(LookConstants.TagsField + tag.Group, tag.Name)), BooleanClause.Occur.MUST); } } } if (lookQuery.TagQuery.Any != null) { if (lookQuery.TagQuery.Not != null) { var conflictTags = lookQuery.TagQuery.Any.Where(x => !lookQuery.TagQuery.Not.Contains(x)); if (conflictTags.Any()) { return(new LookResult($"Conflict in TagQuery, tags: '{ string.Join(",", conflictTags) }' are in both AnyTags and NotTags")); } } if (lookQuery.TagQuery.Any.Any()) { var anyTagQuery = new BooleanQuery(); foreach (var tag in lookQuery.TagQuery.Any) { anyTagQuery.Add( new TermQuery(new Term(LookConstants.TagsField + tag.Group, tag.Name)), BooleanClause.Occur.SHOULD); } query.Add(anyTagQuery, BooleanClause.Occur.MUST); } } if (lookQuery.TagQuery.Not != null && lookQuery.TagQuery.Not.Any()) { foreach (var tag in lookQuery.TagQuery.Not) { query.Add( new TermQuery(new Term(LookConstants.TagsField + tag.Group, tag.Name)), BooleanClause.Occur.MUST_NOT); } } } #endregion #region LocationQuery if (lookQuery.LocationQuery != null) { hasQuery = true; query.Add(new TermQuery(new Term(LookConstants.HasLocationField, "1")), BooleanClause.Occur.MUST); if (lookQuery.LocationQuery.Location != null) { double maxDistance = LookService.MaxDistance; if (lookQuery.LocationQuery.MaxDistance != null) { maxDistance = Math.Min(lookQuery.LocationQuery.MaxDistance.GetMiles(), maxDistance); } var distanceQueryBuilder = new DistanceQueryBuilder( lookQuery.LocationQuery.Location.Latitude, lookQuery.LocationQuery.Location.Longitude, maxDistance, LookConstants.LocationField + "_Latitude", LookConstants.LocationField + "_Longitude", LookConstants.LocationTierFieldPrefix, true); filter = distanceQueryBuilder.Filter; if (lookQuery.SortOn == SortOn.Distance) { sort = new Sort( new SortField( LookConstants.DistanceField, new DistanceFieldComparatorSource(distanceQueryBuilder.DistanceFilter))); } getDistance = new Func <int, double?>(x => { if (distanceQueryBuilder.DistanceFilter.Distances.ContainsKey(x)) { return(distanceQueryBuilder.DistanceFilter.Distances[x]); } return(null); }); } } #endregion if (hasQuery) { switch (lookQuery.SortOn) { case SortOn.Name: // a -> z sort = new Sort(new SortField(LuceneIndexer.SortedFieldNamePrefix + LookConstants.NameField, SortField.STRING)); break; case SortOn.DateAscending: // oldest -> newest sort = new Sort(new SortField(LuceneIndexer.SortedFieldNamePrefix + LookConstants.DateField, SortField.LONG, false)); break; case SortOn.DateDescending: // newest -> oldest sort = new Sort(new SortField(LuceneIndexer.SortedFieldNamePrefix + LookConstants.DateField, SortField.LONG, true)); break; // SortOn.Distance already set (if valid) } lookQuery.Compiled = new LookQueryCompiled( lookQuery, query, filter, sort ?? new Sort(SortField.FIELD_SCORE), getHighlight, getDistance); } } if (!hasQuery) { return(new LookResult("No query clauses supplied")); // empty failure } TopDocs topDocs = lookQuery .SearchingContext .IndexSearcher .Search( lookQuery.Compiled.Query, lookQuery.Compiled.Filter, LookService.MaxLuceneResults, lookQuery.Compiled.Sort); if (topDocs.TotalHits > 0) { List <Facet> facets = null; if (lookQuery.TagQuery != null && lookQuery.TagQuery.FacetOn != null) { facets = new List <Facet>(); Query facetQuery = lookQuery.Compiled.Filter != null ? (Query) new FilteredQuery(lookQuery.Compiled.Query, lookQuery.Compiled.Filter) : lookQuery.Compiled.Query; // do a facet query for each group in the array foreach (var group in lookQuery.TagQuery.FacetOn.TagGroups) { var simpleFacetedSearch = new SimpleFacetedSearch( lookQuery.SearchingContext.IndexSearcher.GetIndexReader(), LookConstants.TagsField + group); var facetResult = simpleFacetedSearch.Search(facetQuery); facets.AddRange( facetResult .HitsPerFacet .Select( x => new Facet() { Tags = new LookTag[] { new LookTag(group, x.Name.ToString()) }, Count = Convert.ToInt32(x.HitCount) } )); } } return(new LookResult( LookService.GetLookMatches( lookQuery.SearchingContext.IndexSearcher, topDocs, lookQuery.RequestFields ?? LookService.Instance.RequestFields, lookQuery.Compiled.GetHighlight, lookQuery.Compiled.GetDistance), topDocs.TotalHits, facets != null ? facets.ToArray() : new Facet[] { })); } return(new LookResult()); // empty success }
/// <summary> /// /// </summary> /// <param name="searcher"></param> /// <param name="request"></param> /// <param name="query"></param> /// <returns></returns> protected List <Refinement> LoadRefinements(IndexSearcher searcher, SearchRequest request, Query query) { var refinements = new List <Refinement>(); var currentFilterQueries = QueryOptions.ParseRefinementString(request.Refinements); foreach (var facet in request.Facets) { var sfs = new SimpleFacetedSearch(searcher.IndexReader, facet.FieldName); var hits = sfs.Search(query); var refinement = new Refinement() { Name = facet.FieldName, Label = facet.FieldLabel, Items = new List <RefinementItem>(), }; var categoryFacet = facet as CategoryFacet; var groupLabel = refinement.Label.ToLower(); foreach (var hit in hits.HitsPerFacet) { if (hit.HitCount == 0) { continue; } var hitValue = hit.Name.ToString(); if (categoryFacet != null) { if (!hit.Name.ToString().Contains(categoryFacet.CategoryName.ToLower())) { continue; } if (hitValue == groupLabel) { continue; } } var regex = new Regex(groupLabel); var displayName = regex.Replace(hitValue, "", 1).Trim(); var item = new RefinementItem() { Name = refinement.Name, GroupLabel = groupLabel, DisplayName = displayName, Count = hit.HitCount, Value = hitValue, Selected = currentFilterQueries.Any(f => f.FieldValue.ToString().Contains(string.Format("{0}", hit.Name.ToString()))), }; item.Refinement = RefinementBuilder.AddRemoveRefinement(item, request.Refinements, facet.RefinementOption); item.Link = string.Format("&ref={0}", item.Refinement); refinement.Items.Add(item); } if (refinement.Items.Any()) { refinement.Items = refinement.Items.OrderByDescending(p => p.Count).ToList(); refinements.Add(refinement); } } foreach (var facet in request.Facets.OfType <CategoryFacet>()) { var refinement = refinements.FirstOrDefault(r => r.Label == facet.FieldLabel); } return(refinements); }
static void Main(string[] args) { Lucene.Net.Util.Version version = Lucene.Net.Util.Version.LUCENE_29; Directory dir = new RAMDirectory(); //Analyzer analyzer = new StandardAnalyzer(version); Analyzer analyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer(version), new Dictionary <string, Analyzer> { { "organization", new KeywordAnalyzer() } }); // Add content to the index var indexWriter = new IndexWriter(dir, analyzer, IndexWriter.MaxFieldLength.UNLIMITED); //indexWriter.SetInfoStream(new System.IO.StreamWriter(Console.OpenStandardOutput())); foreach (var document in CreateDocuments(CreateTestData())) { indexWriter.AddDocument(document); } indexWriter.Commit(); indexWriter.Dispose(); //// Search for the content //var parser = new MultiFieldQueryParser(version, new[] { "organization" }, analyzer); //Query q = parser.Parse("A/D"); //var searcher = new IndexSearcher(dir, true); //TopDocs hits = searcher.Search(q, null, 5, Sort.RELEVANCE); //Console.WriteLine("Found {0} document(s) that matched query '{1}':", hits.TotalHits, q); //foreach (ScoreDoc match in hits.ScoreDocs) //{ // Document doc = searcher.Doc(match.Doc); // Console.WriteLine("Matched id = {0}, Name = {1}, Organizations = {{{2}}}", doc.Get("id"), doc.Get("name"), string.Join(", ", doc.GetValues("organization"))); // //Console.WriteLine(Explain(searcher, q, match)); //} //searcher.Dispose(); var reader = IndexReader.Open(dir, true); var sfs = new SimpleFacetedSearch(reader, new string[] { "organization", "title" }); // then pass in the query into the search like you normally would with a typical search class. Query query = new QueryParser(version, "name", new StandardAnalyzer(version)).Parse("An*"); var hits = sfs.Search(query, 10); // what comes back is different than normal. // the result documents & hits are grouped by facets. // you'll need to iterate over groups of hits-per-facet. long totalHits = hits.TotalHitCount; foreach (SimpleFacetedSearch.HitsPerFacet hpg in hits.HitsPerFacet) { long hitCountPerGroup = hpg.HitCount; SimpleFacetedSearch.FacetName facetName = hpg.Name; Console.WriteLine(">>" + facetName + ": " + hpg.HitCount); //foreach (Document doc in hpg.Documents) //{ // string text = doc.Get("name"); // // replace with logging or your desired output writer // Console.WriteLine(">>" + facetName + ": " + text); //} } }
/// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> private static void Load() { configXML = new XmlDocument(); configXML.Load(FileHelper.ConfigFilePath); XmlNodeList fieldProperties = configXML.GetElementsByTagName("field"); Category categoryDefault = new Category(); categoryDefault.Name = "All"; categoryDefault.Value = "All"; categoryDefault.DisplayName = "All"; categoryDefault.DefaultValue = "nothing"; AllCategoriesDefault.Add(categoryDefault); foreach (XmlNode fieldProperty in fieldProperties) { if (!fieldProperty.Attributes.GetNamedItem("type").Value.ToLower().Equals("primary_data_field")) { String headerItem = fieldProperty.Attributes.GetNamedItem("header_item").Value; String storeItem = fieldProperty.Attributes.GetNamedItem("store").Value; if (headerItem.ToLower().Equals("yes") && storeItem.ToLower().Equals("yes")) { headerItemXmlNodeList.Add(fieldProperty); } String fieldType = fieldProperty.Attributes.GetNamedItem("type").Value; String fieldName = fieldProperty.Attributes.GetNamedItem("lucene_name").Value; String primitiveType = fieldProperty.Attributes.GetNamedItem("primitive_type").Value; if (!primitiveType.ToLower().Equals("string")) { numericProperties.Add(fieldName.ToLower()); } if (fieldType.ToLower().Equals("facet_field")) { facetXmlNodeList.Add(fieldProperty); Facet cDefault = new Facet(); cDefault.Name = fieldName; cDefault.Text = fieldName; cDefault.Value = fieldName; cDefault.DisplayName = fieldProperty.Attributes.GetNamedItem("display_name").Value; cDefault.Childrens = new List <Facet>(); List <Facet> lcDefault = new List <Facet>(); try { Query query = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "id", new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30)).Parse("*:*"); SimpleFacetedSearch sfs = new SimpleFacetedSearch(_Reader, new string[] { "facet_" + fieldName }); SimpleFacetedSearch.Hits hits = sfs.Search(query); int cCount = 0; foreach (SimpleFacetedSearch.HitsPerFacet hpg in hits.HitsPerFacet) { if (!hpg.Name.ToString().Equals("")) { Facet ccDefault = new Facet(); ccDefault.Name = hpg.Name.ToString(); ccDefault.Text = hpg.Name.ToString(); ccDefault.Value = hpg.Name.ToString(); ccDefault.Count = (int)hpg.HitCount; if (ccDefault.Count > 0) { cCount++; } cDefault.Childrens.Add(ccDefault); } } cDefault.Count = cCount; AllFacetsDefault.Add(cDefault); } catch { } } else if (fieldType.ToLower().Equals("property_field")) { propertyXmlNodeList.Add(fieldProperty); Property cDefault = new Property(); //c.Id = x.Attributes[Property.ID].InnerText; cDefault.Name = fieldProperty.Attributes.GetNamedItem("lucene_name").Value; cDefault.DisplayName = fieldProperty.Attributes.GetNamedItem("display_name").Value; cDefault.DisplayTitle = fieldProperty.Attributes.GetNamedItem("display_name").Value; cDefault.DataSourceKey = fieldProperty.Attributes.GetNamedItem("metadata_name").Value; cDefault.UIComponent = fieldProperty.Attributes.GetNamedItem("uiComponent").Value;; cDefault.AggregationType = "distinct"; cDefault.DefaultValue = "All"; cDefault.DataType = fieldProperty.Attributes.GetNamedItem("primitive_type").Value; if (cDefault.UIComponent.ToLower().Equals("range") && cDefault.DataType.ToLower().Equals("date")) { String direction = fieldProperty.Attributes.GetNamedItem("direction").Value; if (direction.ToLower().Equals("increase")) { cDefault.Direction = Direction.increase; } else { cDefault.Direction = Direction.decrease; } } Query query = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "id", new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29)).Parse("*:*"); try { SimpleFacetedSearch sfs = new SimpleFacetedSearch(_Reader, new string[] { "property_" + fieldName }); SimpleFacetedSearch.Hits hits = sfs.Search(query); List <string> laDefault = new List <string>(); foreach (SimpleFacetedSearch.HitsPerFacet hpg in hits.HitsPerFacet) { laDefault.Add(hpg.Name.ToString()); } if (!cDefault.UIComponent.ToLower().Equals("range")) { laDefault.Add("All"); } ; laDefault.Sort(); cDefault.Values = laDefault; AllPropertiesDefault.Add(cDefault); } catch { } } else if (fieldType.ToLower().Equals("category_field")) { categoryXmlNodeList.Add(fieldProperty); Category cDefault = new Category(); cDefault.Name = fieldProperty.Attributes.GetNamedItem("lucene_name").Value; cDefault.DisplayName = fieldProperty.Attributes.GetNamedItem("display_name").Value; cDefault.Value = fieldProperty.Attributes.GetNamedItem("lucene_name").Value;; cDefault.DefaultValue = "nothing"; AllCategoriesDefault.Add(cDefault); } else if (fieldType.ToLower().Equals("general_field")) { generalXmlNodeList.Add(fieldProperty); } } else if (fieldProperty.Attributes.GetNamedItem("type").Value.ToLower().Equals("primary_data_field")) { categoryXmlNodeList.Add(fieldProperty); Category cDefault = new Category(); cDefault.Name = fieldProperty.Attributes.GetNamedItem("lucene_name").Value; cDefault.DisplayName = fieldProperty.Attributes.GetNamedItem("display_name").Value; cDefault.Value = fieldProperty.Attributes.GetNamedItem("lucene_name").Value;; cDefault.DefaultValue = "nothing"; AllCategoriesDefault.Add(cDefault); } } }
public IList <SearchFilter> GetFilter(IList <Filter> searchFilters) { var reader = IndexReader.Open(_directory, true); var filters = new List <SearchFilter>(); foreach (var searchFilter in searchFilters) { var items = new List <SearchFilterItem>(); var filter = new SearchFilter { FilterName = searchFilter.FieldName, Items = items }; filters.Add(filter); var query = CreateQuery(searchFilters, searchFilter.FieldName); SimpleFacetedSearch search = new SimpleFacetedSearch(reader, searchFilter.FieldName); var facets = search.Search(query); foreach (var facet in facets.HitsPerFacet) { var hitCount = facet.HitCount; if (hitCount == 0) { continue; } string value = string.Empty; foreach (var document in facet.Documents) { value = document.Get(searchFilter.FieldName); if (!string.IsNullOrWhiteSpace(value)) { break; } } if (string.IsNullOrEmpty(value)) { continue; } var isQueried = searchFilter.Values.Any(s => string.Equals(s, value, StringComparison.InvariantCultureIgnoreCase)); var item = new SearchFilterItem { Label = value, Value = value, Hits = (int)facet.HitCount, IsQueried = isQueried }; filter.Items.Add(item); } items.Sort((s1, s2) => string.Compare(s1.Value, s2.Value, StringComparison.Ordinal)); } return(filters); }