protected void BindFacets(FacetResults facets, String types, List<string> tags)
{
litType.Visible = true;
litTags.Visible = true;
foreach (FacetCategory fc in facets.Categories)
{
if (fc.Name == "_templatename")
{
TypeFacetCheckList.Items.Clear();
if (fc.Values.Count == 0) litType.Visible = false;
foreach (var a in fc.Values)
{
ListItem li = new ListItem(String.Format("{0} ({1})", a.Name, a.AggregateCount), a.Name);
if (li.Value == types) li.Selected = true;
TypeFacetCheckList.Items.Add(li);
}
}
if (fc.Name == "__semantics")
{
TagsFacetCheckList.Items.Clear();
if (fc.Values.Count == 0) litTags.Visible = false;
foreach (var a in fc.Values)
{
Item tag = Sitecore.Context.Database.GetItem(new ID(a.Name));
ListItem li = new ListItem(String.Format("{0} ({1})", tag.Name, a.AggregateCount), a.Name);
if (tags.Contains(li.Value)) li.Selected = true;
TagsFacetCheckList.Items.Add(li);
}
}
}
}
private RangeFacetResult <T>[] GetRangeFacetsForField <T>(FacetResults facets, string expectedField, int expectedCount)
where T : struct
{
IList <FacetResult> facetCollection = GetFacetsForField(facets, expectedField, expectedCount);
return(facetCollection.Select(f => f.AsRangeFacetResult <T>()).ToArray());
}
public AnalyticsIndexablesFacetResult(FacetResults facetResults)
: this()
{
var byType = facetResults?.Categories?.FirstOrDefault(x => x.Name.ToLower() == "type");
if (byType != null)
{
var nonEmpty = byType.Values.Where(x => x.AggregateCount > 0);
var facets = nonEmpty.Select(x => new AnalyticsIndexablesFacet(x.Name.ToLower(), x.AggregateCount));
foreach (var facet in facets.OrderByDescending(c => c.ActionsAvailable).ThenBy(c => c.Type))
{
var existingFacet = this.Facets.FirstOrDefault(x =>
x.Type.Equals(facet.Type, StringComparison.CurrentCultureIgnoreCase));
if (existingFacet != null)
{
existingFacet.Count = facet.Count;
}
else
{
this.Facets.Add(facet);
}
}
}
}
private bool AreFacetsEquiv(FacetResults left, FacetResults right)
{
//check if same number of ranges.
if (left.Results.Count != right.Results.Count
// || left.Results.Select(r=> r.Key).Intersect(right.Results.Select(r=> r.Key)).Count() != left.Results.Count
)
{
return(false);
}
//deeper check onthe ranges.
if (left.Results.Sum(r => r.Value.Values.Sum(var => var.Hits)) != right.Results.Sum(r => r.Value.Values.Sum(var => var.Hits)))
{
return(false);
}
//all the way down...
foreach (var lfr in left.Results)
{
var leftFacetResult = lfr.Value;
var rightFacetResult = right.Results.First(r => r.Key.Contains(lfr.Key) || lfr.Key.Contains(r.Key)).Value;
for (int i = 0; i < leftFacetResult.Values.Count; i++)
{
if (leftFacetResult.Values[i].Hits != rightFacetResult.Values[i].Hits)
{
return(false);
}
}
}
return(true);
}
public void ShouldWorkWithEmbeddedRavenWithoutHavingToQueryFirst()
{
//arrange
using (var store = NewDocumentStore())
{
try
{
(store).RegisterListener(new NoStaleQueriesListener());
store.Initialize();
SetupTestData(store);
WaitForIndexing(store);
//Act
FacetResults result = ExecuteTest(store);
//Assert
CheckResults(result);
}
finally
{
store.Dispose();
}
}
}
private void UpdateFacets(FacetResults facets, bool bindExistingFacets = false)
{
var existingSelectedFacets =
SearchFacets.Select(e => new FacetGroup()
{
FacetName = e.FacetName,
FacetValues = e.FacetValues.Where(f => f.IsSelected.HasValue && f.IsSelected.Value).ToList()
}).ToList();
SearchFacets.Clear();
if (facets != null)
{
foreach (var result in facets)
{
SearchFacets.Add(new FacetGroup()
{
FacetName = result.Key,
FacetDisplayName = JobSearchService.FacetDefinitions.ContainsKey(result.Key) ? JobSearchService.FacetDefinitions[result.Key] : result.Key,
FacetValues =
result.Value.Select(e => new FacetSelection()
{
FacetValue = e.Value.ToString(), IsSelected = bindExistingFacets && existingSelectedFacets.Any(ef => ef.FacetName == result.Key && ef.FacetValues.Any(fv => fv.FacetValue == e.Value.ToString())), FacetCount = e.Count
})
.ToList()
});
}
}
OnPropertyChanged(nameof(ShowFacets));
}
private void CheckFacetResultsMatchInMemoryData(FacetResults facetResults, List <Camera> filteredData)
{
//Make sure we get all range values
Assert.Equal(filteredData.GroupBy(x => x.Manufacturer).Count(),
facetResults.Results["Manufacturer"].Values.Count());
foreach (var facet in facetResults.Results["Manufacturer"].Values)
{
var inMemoryCount = filteredData.Count(x => x.Manufacturer.ToLower() == facet.Range);
Assert.Equal(inMemoryCount, facet.Hits);
}
//Go through the expected (in-memory) results and check that there is a corresponding facet result
//Not the prettiest of code, but it works!!!
var costFacets = facetResults.Results["Cost_Range"].Values;
CheckFacetCount(filteredData.Count(x => x.Cost <= 200.0m), costFacets.FirstOrDefault(x => x.Range == "[NULL TO Dx200]"));
CheckFacetCount(filteredData.Count(x => x.Cost >= 200.0m && x.Cost <= 400), costFacets.FirstOrDefault(x => x.Range == "[Dx200 TO Dx400]"));
CheckFacetCount(filteredData.Count(x => x.Cost >= 400.0m && x.Cost <= 600.0m), costFacets.FirstOrDefault(x => x.Range == "[Dx400 TO Dx600]"));
CheckFacetCount(filteredData.Count(x => x.Cost >= 600.0m && x.Cost <= 800.0m), costFacets.FirstOrDefault(x => x.Range == "[Dx600 TO Dx800]"));
CheckFacetCount(filteredData.Count(x => x.Cost >= 800.0m), costFacets.FirstOrDefault(x => x.Range == "[Dx800 TO NULL]"));
//Test the Megapixels_Range facets using the same method
var megapixelsFacets = facetResults.Results["Megapixels_Range"].Values;
CheckFacetCount(filteredData.Count(x => x.Megapixels <= 3.0m), megapixelsFacets.FirstOrDefault(x => x.Range == "[NULL TO Dx3]"));
CheckFacetCount(filteredData.Count(x => x.Megapixels >= 3.0m && x.Megapixels <= 7.0m), megapixelsFacets.FirstOrDefault(x => x.Range == "[Dx3 TO Dx7]"));
CheckFacetCount(filteredData.Count(x => x.Megapixels >= 7.0m && x.Megapixels <= 10.0m), megapixelsFacets.FirstOrDefault(x => x.Range == "[Dx7 TO Dx10]"));
CheckFacetCount(filteredData.Count(x => x.Megapixels >= 10.0m), megapixelsFacets.FirstOrDefault(x => x.Range == "[Dx10 TO NULL]"));
}
private IList <FacetResult> GetFacetsForField(FacetResults facets, string expectedField, int expectedCount)
{
Assert.True(facets.ContainsKey(expectedField));
IList <FacetResult> facetCollection = facets[expectedField];
Assert.Equal(expectedCount, facetCollection.Count);
return(facetCollection);
}
private static FacetResults ExecuteTest(IDocumentStore store)
{
FacetResults result = store.DatabaseCommands.GetFacets("Product/AvailableForSale2", new IndexQuery {
Query = "MyName1", DefaultField = "Any"
}, "facets/ProductFacets");
return(result);
}
private void CheckFacetResultsMatchInMemoryData(FacetResults facetResults, List <Camera> filteredData, IList <DateTime> dates)
{
//Test the Megapixels_Range facets using the same method
var dateOfListingFacets = facetResults.Results["DateOfListing_Range"].Values;
CheckFacetCount(filteredData.Count(x => x.DateOfListing <= dates.First()), dateOfListingFacets.FirstOrDefault(x => x.Range.Contains("NULL TO")));
CheckFacetCount(filteredData.Count(x => x.DateOfListing >= dates.Last()), dateOfListingFacets.FirstOrDefault(x => x.Range.Contains("TO NULL")));
}
public ActionResult FacetList(SearchQuery query)
{
var parameters = GetRenderingParameters <FacetParameters>();
FacetResults results = GetFacetsForParameters(parameters, query);
Reboot.Core.Search.FacetResults facets = results;
return(View(facets));
}
public DynamicAggregation()
{
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region dynamic_aggregation_1
FacetResults facetResults = session
.Query <Order, Orders_All>()
.Where(x => x.Total > 500)
.AggregateBy(x => x.Product)
.SumOn(x => x.Total)
.ToList();
#endregion
}
using (var session = store.OpenSession())
{
#region dynamic_aggregation_range
FacetResults facetResults = session.Query <Order, Orders_All>()
.AggregateBy(x => x.Product)
.AddRanges(
x => x.Total < 100,
x => x.Total >= 100 && x.Total < 500,
x => x.Total >= 500 && x.Total < 1500,
x => x.Total >= 1500
)
.SumOn(x => x.Total)
.ToList();
#endregion
}
using (var session = store.OpenSession())
{
#region dynamic_aggregation_multiple_items
FacetResults facetResults = session.Query <Order, Orders_All>()
.AggregateBy(x => x.Product)
.SumOn(x => x.Total)
.CountOn(x => x.Total)
.AndAggregateOn(x => x.Currency)
.MinOn(x => x.Total)
.ToList();
#endregion
}
using (var session = store.OpenSession())
{
#region dynamic_aggregation_different_fieldss
FacetResults facetResults = session.Query <Order, Orders_All>()
.AggregateBy(x => x.Product)
.MaxOn(x => x.Total)
.MinOn(x => x.Currency)
.ToList();
#endregion
}
}
}
private static void CheckResults(FacetResults result)
{
Assert.Contains("Brand", result.Results.Select(x => x.Key));
FacetResult facetResult = result.Results["Brand"];
Assert.Equal(1, facetResult.Values.Count);
facetResult.Values[0] = new FacetValue {
Range = "mybrand1", Hits = 1
};
}
public FacetResults GetFacets(string index, IndexQuery indexQuery, List <Facet> facets, int start = 0, int?pageSize = null)
{
var results = new FacetResults();
var defaultFacets = new Dictionary <string, Facet>();
var rangeFacets = new Dictionary <string, List <ParsedRange> >();
foreach (var facet in facets)
{
var key = string.IsNullOrWhiteSpace(facet.DisplayName) ? facet.Name : facet.DisplayName;
defaultFacets[key] = facet;
if (facet.Aggregation != FacetAggregation.Count && facet.Aggregation != FacetAggregation.None)
{
if (string.IsNullOrEmpty(facet.AggregationField))
{
throw new InvalidOperationException("Facet " + facet.Name + " cannot have aggregation set to " +
facet.Aggregation + " without having a value in AggregationField");
}
if (facet.AggregationField.EndsWith("_Range") == false)
{
facet.AggregationField = facet.AggregationField + "_Range";
}
}
switch (facet.Mode)
{
case FacetMode.Default:
results.Results[key] = new FacetResult();
break;
case FacetMode.Ranges:
rangeFacets[key] = facet.Ranges.Select(range => ParseRange(facet.Name, range)).ToList();
results.Results[key] = new FacetResult
{
Values = facet.Ranges.Select(range => new FacetValue
{
Range = range,
}).ToList()
};
break;
default:
throw new ArgumentException(string.Format("Could not understand '{0}'", facet.Mode));
}
}
var queryForFacets = new QueryForFacets(database, index, defaultFacets, rangeFacets, indexQuery, results, start, pageSize);
queryForFacets.Execute();
return(results);
}
public QueryResults(ISearchRequest request, SearchResults <T> results, FacetResults facets)
{
Request = request;
Results = results.Hits.Select(x => x.Document).Where(x => x != null).ToList();
_totalResults = new Lazy <int>(() => results.TotalSearchResults);
_facets = new Lazy <IEnumerable <FacetGroup> >(() => facets == null
? new List <FacetGroup>()
: BuildFacetResults(request.QueryParameters, facets.Categories));
_availableRefinements = new Lazy <IEnumerable <ISearchRefinement> >(request.GetRefinements);
}
public HowToPerformQueriesLazily()
{
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region lazy_2
Lazy <IEnumerable <Employee> > employeesLazy = session
.Query <Employee>()
.Where(x => x.FirstName == "Robert")
.Lazily();
IEnumerable <Employee> employees = employeesLazy.Value; // query will be executed here
#endregion
}
using (var session = store.OpenSession())
{
#region lazy_5
Lazy <int> countLazy = session
.Query <Employee>()
.Where(x => x.FirstName == "Robert")
.CountLazily();
int count = countLazy.Value; // query will be executed here
#endregion
}
using (var session = store.OpenSession())
{
#region lazy_7
Lazy <SuggestionQueryResult> suggestLazy = session
.Query <Employee>()
.SuggestLazy();
SuggestionQueryResult suggest = suggestLazy.Value; // query will be executed here
string[] suggestions = suggest.Suggestions;
#endregion
}
using (var session = store.OpenSession())
{
#region lazy_9
Lazy <FacetResults> facetsLazy = session
.Query <Camera>("Camera/Costs")
.ToFacetsLazy("facets/CameraFacets");
FacetResults facets = facetsLazy.Value; // query will be executed here
Dictionary <string, FacetResult> results = facets.Results;
#endregion
}
}
}
private FacetResults HandlRenames(FacetResults facetResults)
{
foreach (var rename in renames)
{
FacetResult value;
if (facetResults.Results.TryGetValue(rename.Value, out value) &&
facetResults.Results.ContainsKey(rename.Key) == false)
{
facetResults.Results[rename.Key] = value;
}
}
return(facetResults);
}
private FacetResults GetFacetsForParameters(IFacetParameters parameters, SearchQuery query)
{
IEnumerable <Guid> facetOns = parameters.FilterOnFields;
IEnumerable <Models.Glass.Reboot.Facet> facets =
facetOns.Select(i => SitecoreContext.GetItem <Models.Glass.Reboot.Facet>(i)).Reverse();
// predicate = predicate.And(a => a.Status.Equals("released"));
FacetResults results = _siteSearchService.GetFacetResultsAs <FacetableContent>(
//Where Conditions
w =>
{
var predicate = Reboot.Core.Search.SearchHelper.GetPredicate <FacetableContent>(parameters, SitecoreContext);
w = w.Where(predicate);
return(w);
}
//Facet Set up
, f =>
{
foreach (var facet in facets)
{
switch (facet.FacetName)
{
case "Genres":
f = f.FacetOn(o => o.Genres, 1);
break;
case "Production Company":
f = f.FacetOn(o => o.ProductionCompanies, 1);
break;
case "Status":
f = f.FacetOn(o => o.Status, 1);
break;
case "Spoken Language":
f = f.FacetOn(o => o.SpokenLanguages, 1);
break;
}
}
//Expression<Func<FacetableContent, object>> expression = o => (o.GetType().InvokeMember(parameters.FacetBy, BindingFlags.GetProperty, null, o, null));
//f =f.FacetOn(expression, 1);
return(f);
}
//Sort order setup
, s => s
, query
);
return(results);
}
public virtual SearchFacetResults ProcessFacetResults(FacetResults results)
{
return(new SearchFacetResults
{
Total = results.Categories.Count,
Facets = results.Categories.Select(facet =>
new Facets.FacetCategory(facet.Name,
facet.Values
.Select(x => new FacetValue(x.Name, x.AggregateCount))
.Where(x => x?.Name != null)
.ToArray())
).ToArray()
});
}
private static void PrintFacets(FacetResults facets)
{
if (facets != null)
{
foreach (var f in facets)
{
Console.WriteLine("Facet: {0}", f.Name);
if (f is TermsFacet)
{
foreach (var t in (f as TermsFacet).Terms.OrderBy(t => t.Term))
{
Console.WriteLine("\t{0} ({1})", t.Term, t.Count);
}
}
else if (f is FilterFacet)
{
Console.WriteLine("\tMatching: {0}", (f as FilterFacet).Count);
}
else if (f is StatisticalFacet)
{
var sf = f as StatisticalFacet;
Console.WriteLine("\tMean: {0}\n\tMax: {1}\n\tMin: {2}\n\tTotal: {3}\n\tVariance: {4}\n", sf.Mean,
sf.Max, sf.Min, sf.Total, sf.Variance);
}
else if (f is NumericRangeFacet)
{
foreach (var r in (f as NumericRangeFacet).Ranges)
{
Console.WriteLine("\t{0}-{1} ({2})", r.From, r.To, r.Count);
}
}
else if (f is HistogramFacet)
{
foreach (var r in (f as HistogramFacet).Entries)
{
Console.WriteLine("\t{0} ({1})", r.Key, r.Count);
}
}
else if (f is GeoDistanceFacet)
{
foreach (var r in (f as GeoDistanceFacet).Ranges)
{
Console.WriteLine("\t{0}-{1} ({2})", r.From.Value, r.To.Value, r.TotalCount);
}
}
Console.WriteLine();
}
}
}
public QueryForFacets(
DocumentDatabase database,
string index,
Dictionary <string, Facet> facets,
Dictionary <string, List <ParsedRange> > ranges,
IndexQuery indexQuery,
FacetResults results)
{
Database = database;
Index = index;
Facets = facets;
Ranges = ranges;
IndexQuery = indexQuery;
Results = results;
}
private void PrintFacetResults(FacetResults facetResults)
{
foreach (var kvp in facetResults.Results)
{
if (kvp.Value.Values.Count() > 0)
{
Console.WriteLine(kvp.Key + ":");
foreach (var facet in kvp.Value.Values)
{
Console.WriteLine(" {0}: {1}", facet.Range, facet.Hits);
}
Console.WriteLine();
}
}
}
public FacetResults GetFacets(string index, IndexQuery indexQuery, string facetSetupDoc, int start = 0, int?pageSize = null)
{
var facetSetup = database.Get(facetSetupDoc, null);
if (facetSetup == null)
{
throw new InvalidOperationException("Could not find facets document: " + facetSetupDoc);
}
var facets = facetSetup.DataAsJson.JsonDeserialization <FacetSetup>().Facets;
var results = new FacetResults();
var defaultFacets = new Dictionary <string, Facet>();
var rangeFacets = new Dictionary <string, List <ParsedRange> >();
foreach (var facet in facets)
{
switch (facet.Mode)
{
case FacetMode.Default:
//Remember the facet, so we can run them all under one query
defaultFacets[facet.Name] = facet;
results.Results[facet.Name] = new FacetResult();
break;
case FacetMode.Ranges:
rangeFacets[facet.Name] = facet.Ranges.Select(range => ParseRange(facet.Name, range)).ToList();
results.Results[facet.Name] = new FacetResult
{
Values = facet.Ranges.Select(range => new FacetValue
{
Range = range,
}).ToList()
};
break;
default:
throw new ArgumentException(string.Format("Could not understand '{0}'", facet.Mode));
}
}
var queryForFacets = new QueryForFacets(database, index, defaultFacets, rangeFacets, indexQuery, results, start, pageSize);
queryForFacets.Execute();
return(results);
}
public void HandleResponses(GetResponse[] responses, ShardStrategy shardStrategy)
{
var result = new FacetResults();
foreach (var response in responses.Select(response => (RavenJObject)response.Result))
{
var facet = response.JsonDeserialization <FacetResults>();
foreach (var facetResult in facet.Results)
{
if (!result.Results.ContainsKey(facetResult.Key))
{
result.Results[facetResult.Key] = new FacetResult();
}
var newFacetResult = result.Results[facetResult.Key];
foreach (var facetValue in facetResult.Value.Values)
{
var existingFacetValueRange = newFacetResult.Values.Find((x) => x.Range == facetValue.Range);
if (existingFacetValueRange != null)
{
existingFacetValueRange.Hits += facetValue.Hits;
}
else
{
newFacetResult.Values.Add(new FacetValue()
{
Hits = facetValue.Hits, Range = facetValue.Range
});
}
}
foreach (var facetTerm in facetResult.Value.RemainingTerms)
{
if (!newFacetResult.RemainingTerms.Contains(facetTerm))
{
newFacetResult.RemainingTerms.Add(facetTerm);
}
}
}
}
Result = result;
}
/// <summary>
/// Updates the content search result with facets.
/// </summary>
/// <param name="facetResults">All possible facets.</param>
/// <param name="facetResultsAfterSearch">Facets that contain results after querying using the search text. This is used to get the result count per facet.</param>
/// <param name="searchResults">The collection of SearchResultItems after the search on searchtext and filtering on templates.</param>
/// <param name="contentSearchResult">Result object which is updated with facets.</param>
private void UpdateResultWithFacets(FacetResults facetResults, FacetResults facetResultsAfterSearch, SearchResults <SearchResultItem> searchResults, ContentSearchResult contentSearchResult)
{
var allFacets = facetResults.Categories.FirstOrDefault();
FacetCategory searchFacets = null;
if (facetResultsAfterSearch != null)
{
searchFacets = facetResultsAfterSearch.Categories.FirstOrDefault();
}
var searchResultFacets = searchResults.Facets.Categories.FirstOrDefault();
if (allFacets != null && searchFacets != null)
{
contentSearchResult.Facets = allFacets.Values.Select(facet => GetFacet(facet, searchFacets, searchResultFacets)).OrderBy(facet => facet.Name).ToList();
}
}
public void Step3()
{
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
List <Facet> facets = new List <Facet>();
#region step_3_0
FacetResults facetResults = session
.Query <Camera, Cameras_ByManufacturerModelCostDateOfListingAndMegapixels>()
.Where(x => x.Cost >= 100 && x.Cost <= 300)
.ToFacets(facets);
#endregion
}
using (var session = store.OpenSession())
{
List <Facet> facets = new List <Facet>();
#region step_3_1
FacetResults facetResults = session
.Advanced
.DocumentQuery <Camera, Cameras_ByManufacturerModelCostDateOfListingAndMegapixels>()
.WhereBetweenOrEqual(x => x.Cost, 100, 300)
.ToFacets(facets);
#endregion
}
}
using (var store = new DocumentStore())
{
List <Facet> facets = new List <Facet>();
#region step_3_2
FacetResults facetResults = store
.DatabaseCommands
.GetFacets(
"Cameras/ByManufacturerModelCostDateOfListingAndMegapixels",
new IndexQuery
{
Query = "Cost_Range:[Dx100 TO Dx300]"
},
facets);
#endregion
}
}
protected void BindFacets(FacetResults facets, String types, List <string> tags)
{
litType.Visible = true;
litTags.Visible = true;
foreach (FacetCategory fc in facets.Categories)
{
if (fc.Name == "_templatename")
{
TypeFacetCheckList.Items.Clear();
if (fc.Values.Count == 0)
{
litType.Visible = false;
}
foreach (var a in fc.Values)
{
ListItem li = new ListItem(String.Format("{0} ({1})", a.Name, a.AggregateCount), a.Name);
if (li.Value == types)
{
li.Selected = true;
}
TypeFacetCheckList.Items.Add(li);
}
}
if (fc.Name == "__semantics")
{
TagsFacetCheckList.Items.Clear();
if (fc.Values.Count == 0)
{
litTags.Visible = false;
}
foreach (var a in fc.Values)
{
Item tag = Sitecore.Context.Database.GetItem(new ID(a.Name));
ListItem li = new ListItem(String.Format("{0} ({1})", tag.Name, a.AggregateCount), a.Name);
if (tags.Contains(li.Value))
{
li.Selected = true;
}
TagsFacetCheckList.Items.Add(li);
}
}
}
}
private FacetResults FormatFacetResults(Dictionary <string, ICollection <KeyValuePair <string, int> > > facetResults, List <FacetQuery> facetQueries)
{
var fieldTranslator = this.context.Index.FieldNameTranslator as SolrFieldNameTranslator;
var processedFacets = ProcessFacetsPipeline.Run(this.pipeline, new ProcessFacetsArgs(facetResults, facetQueries, facetQueries, this.context.Index.Configuration.VirtualFieldProcessors, fieldTranslator));
foreach (var originalQuery in facetQueries)
{
if (originalQuery.FilterValues == null || !originalQuery.FilterValues.Any())
{
continue;
}
if (!processedFacets.ContainsKey(originalQuery.CategoryName))
{
continue;
}
var categoryValues = processedFacets[originalQuery.CategoryName];
processedFacets[originalQuery.CategoryName] = categoryValues.Where(cv => originalQuery.FilterValues.Contains(cv.Key)).ToList();
}
var facetFormattedResults = new FacetResults();
foreach (var group in processedFacets)
{
if (fieldTranslator == null)
{
continue;
}
var key = group.Key;
if (key.Contains(","))
{
key = fieldTranslator.StripKnownExtensions(key.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
}
else
{
key = fieldTranslator.StripKnownExtensions(key);
}
var values = @group.Value.Select(v => new FacetValue(v.Key, v.Value));
facetFormattedResults.Categories.Add(new FacetCategory(key, values));
}
return(facetFormattedResults);
}
/// <summary>
/// ContentSearch based on search text and templates (facets).
/// </summary>
/// <param name="filter">The ContentSearchFilter.</param>
/// <returns></returns>
public ContentSearchResult SearchWithFacets(ContentSearchFilter filter)
{
var contentSearchResult = new ContentSearchResult
{
Paging = new Paging(),
ContentSearchResultItems = new List <ContentSearchResultItem>()
};
string index = GetSearchIndexName();
using (var context = ContentSearchManager.GetIndex(index).CreateSearchContext())
{
// Null query, will be updated with search text and template filter.
var query = context.GetQueryable <SearchResultItem>();
// Retrieve all possible facets before a query is done with the search text.
var facetResults = query.FacetOn(item => item.TemplateId).GetFacets();
FacetResults facetResultsAfterSearch = null;
if (filter != null)
{
ApplySearchStringQuery(filter.SearchText, ref query);
facetResultsAfterSearch = query.FacetOn(item => item.TemplateId).GetFacets();
ApplyTemplateQuery(filter.Templates, ref query);
}
var searchResult = query.FacetOn(item => item.TemplateId).GetResults();
UpdateResultWithFacets(facetResults, facetResultsAfterSearch, searchResult, contentSearchResult);
var distinctHits = searchResult.Hits.Distinct().ToList();
UpdateResultWithItem(
contentSearchResult,
distinctHits,
NewsTemplate.ID);
UpdateResultWithItem(
contentSearchResult,
distinctHits,
EventTemplate.ID);
contentSearchResult.ResultCount = contentSearchResult.ContentSearchResultItems.Count;
int numberToSkip;
UpdateResultWithPaging(contentSearchResult, filter, out numberToSkip);
contentSearchResult.ContentSearchResultItems = contentSearchResult.ContentSearchResultItems.Skip(numberToSkip).Take(contentSearchResult.Paging.PageSize).ToList();
return(contentSearchResult);
}
}
private FacetResults FormatFacetResults(Dictionary <string, ICollection <KeyValuePair <string, int> > > facetResults, List <FacetQuery> facetQueries)
{
var fieldNameTranslator = _context.Index.FieldNameTranslator as ElasticSearchFieldNameTranslator;
var dictionary = ProcessFacetsPipeline.Run(new ProcessFacetsArgs(facetResults, facetQueries, facetQueries, _context.Index.Configuration.VirtualFieldProcessors, fieldNameTranslator));
using (var enumerator = facetQueries.GetEnumerator())
{
while (enumerator.MoveNext())
{
var originalQuery = enumerator.Current;
if (originalQuery == null || originalQuery.FilterValues == null || !originalQuery.FilterValues.Any() || !dictionary.ContainsKey(originalQuery.CategoryName))
{
continue;
}
var is2 = dictionary[originalQuery.CategoryName];
Func <KeyValuePair <string, int>, bool> func = cv => originalQuery.FilterValues.Contains(cv.Key);
dictionary[originalQuery.CategoryName] = is2.Where(func).ToList();
}
}
var results = new FacetResults();
foreach (var pair in dictionary)
{
if (fieldNameTranslator == null)
{
continue;
}
var key = pair.Key;
if (key.Contains(","))
{
key = fieldNameTranslator.StripKnownExtensions(key.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries));
}
else
{
key = fieldNameTranslator.StripKnownExtensions(key);
}
var enumerable = from v in pair.Value select new FacetValue(v.Key, v.Value);
results.Categories.Add(new FacetCategory(key, enumerable));
}
return(results);
}
public void ShouldWorkWithRavenServer()
{
//arrange
using (var store = NewRemoteDocumentStore())
{
store.RegisterListener(new NoStaleQueriesListener());
SetupTestData(store);
WaitForIndexing(store);
//Act
FacetResults result = ExecuteTest(store);
WaitForUserToContinueTheTest();
//Assert
CheckResults(result);
}
}
private static void PrintFacets(FacetResults facets)
{
if (facets != null)
{
foreach (var f in facets)
{
Console.WriteLine("Facet: {0}", f.Name);
if (f is TermsFacet)
{
foreach (var t in (f as TermsFacet).Terms.OrderBy(t => t.Term))
{
Console.WriteLine("\t{0} ({1})", t.Term, t.Count);
}
}
else if (f is FilterFacet)
{
Console.WriteLine("\tMatching: {0}", (f as FilterFacet).Count);
}
else if (f is StatisticalFacet)
{
var sf = f as StatisticalFacet;
Console.WriteLine("\tMean: {0}\n\tMax: {1}\n\tMin: {2}\n\tTotal: {3}\n\tVariance: {4}\n", sf.Mean,
sf.Max, sf.Min, sf.Total, sf.Variance);
}
else if (f is NumericRangeFacet)
{
foreach (var r in (f as NumericRangeFacet).Ranges)
{
Console.WriteLine("\t{0}-{1} ({2})", r.From, r.To, r.Count);
}
}
else if (f is HistogramFacet)
{
foreach (var r in (f as HistogramFacet).Entries)
{
Console.WriteLine("\t{0} ({1})", r.Key, r.Count);
}
}
else if (f is GeoDistanceFacet)
{
foreach (var r in (f as GeoDistanceFacet).Ranges)
{
Console.WriteLine("\t{0}-{1} ({2})", r.From.Value, r.To.Value, r.TotalCount);
}
}
Console.WriteLine();
}
}
}
