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;
}
/// <summary>
/// Utility method to get the most-relevant simple faceted search.
/// </summary>
/// <param name="targetFolder"></param>
/// <param name="groupByFields"></param>
/// <returns></returns>
public static SimpleFacetedSearch GetSimpleFacetedSearch(SPFolder targetFolder, params string[] groupByFields)
{
SimpleFacetedSearch facetedSearch;
if (HasIndexWriterSingleton(targetFolder))
{
var indexWriter = GetIndexWriterSingleton(targetFolder, false);
var reader = indexWriter.GetReader();
facetedSearch = new SimpleFacetedSearch(reader, groupByFields);
}
else
{
var directory = new SPDirectory(targetFolder);
var reader = IndexReader.Open(directory, true);
facetedSearch = new SimpleFacetedSearch(reader, groupByFields);
}
return(facetedSearch);
}
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);
}
