public static FieldsDescriptor <T> FieldAnalyzed <T>(this FieldsDescriptor <T> descriptor, Expression <Func <T, object> > field, double?boost = null, DefaultContractResolver resolver = null) where T : class
{
MemberExpression memberExpression = null;
if (field.Body.NodeType == ExpressionType.Convert)
{
memberExpression = ((UnaryExpression)field.Body).Operand as MemberExpression;
}
else if (field.Body.NodeType == ExpressionType.MemberAccess)
{
memberExpression = field.Body as MemberExpression;
}
if (memberExpression != null)
{
resolver = resolver ?? fallbackNameResolver;
var name = resolver.GetResolvedPropertyName(memberExpression.Member.Name);
if (memberExpression.Type == typeof(string))
{
return(descriptor.Field($"{name}.{VulcanFieldConstants.AnalyzedModifier}", boost));
}
return(descriptor.Field(name, boost));
}
return(descriptor);
}
private static FieldsDescriptor <OrderSearch> Fields(FieldsDescriptor <OrderSearch> f)
{
var newFields = new FieldsDescriptor <OrderSearch>();
string[] allFields = new string[searchParameters.Count];
for (int i = 0; i < searchParameters.Count; i++)
{
switch (searchParameters[i])
{
case "Detail":
newFields.Field(p => p.OrderDetails.First().Detail);
break;
case "Order Amount":
newFields.Field(p => p.OrderAmount);
break;
case "Order #":
newFields.Field(p => p.OrderId);
break;
default:
break;
}
}
return(newFields);
}
private static FieldsDescriptor <Customer> NewMethod1(FieldsDescriptor <Customer> f)
{
return(f.Field(p => p.Email).
Field(p => p.FirstName).
Field(p => p.LastName).
Field(p => p.school.schoolname));
}
private static IPromise <Fields> GetTextFields(FieldsDescriptor <Meme> f, IEnumerable <string> fields)
{
foreach (var field in fields.Where(f => SearchableTextFields.Contains(f)))
{
f = f.Field(GetField(field));
}
return(f);
}
public static IPromise <Fields> Multi <T>(this FieldsDescriptor <T> descriptor, params System.Linq.Expressions.Expression <Func <T, object> >[] fields)
where T : class
{
IPromise <Fields> promise = descriptor as IPromise <Fields>;
foreach (var expression in fields)
{
promise = descriptor.Field(expression) as IPromise <Fields>;
}
return(promise);
}
protected override FieldsDescriptor <BookIndexItem> Fields(
FieldsDescriptor <BookIndexItem> fields)
=> fields
.Field(f => f.Title)
.Field(f => f.Description)
.Field(f => f.Authors)
.Field(f => f.Tags)
.Field(f => f.DatePublication)
.Field(f => f.Issue)
.Field(f => f.Publisher)
.Field(f => f.Language);
protected SearchLocaleFields(FieldsDescriptor parent, string name) : base(parent, name)
{
MakeFields <SearchLocale>();
}
public SearchLocaleFields(FieldsDescriptor parent) : this(parent, "search_locale")
{
}
public RankingDistributionFields(FieldsDescriptor parent) : base(parent, "ranking_distribution")
{
MakeFields <RankingDistribution>();
}
protected LandingPageFields(FieldsDescriptor parent, string name) : base(parent, name)
{
MakeFields <LandingPage>();
}
public PreferredLandingPageFields(FieldsDescriptor parent) : base(parent, "preferred_landing_page")
{
}
public Field(FieldsDescriptor parent, string name)
{
_name = name;
_parent = parent;
}
public DomainFields(FieldsDescriptor parent) : base(parent, "domain")
{
MakeFields <Domain>();
}
public FiltersFields(FieldsDescriptor parent) : base(parent, "filters")
{
MakeFields <Filter>();
}
public SearchEngineFields(FieldsDescriptor parent) : base(parent, "search_engine")
{
MakeFields <SearchEngine>();
}
public SuiteCollectionItemFields(FieldsDescriptor parent) : base(parent, string.Empty)
{
MakeFields <SuiteCollectionItem>();
}
public ApiFiltersFields(FieldsDescriptor parent) : base(parent, "api_filters")
{
MakeFields <ApiFilters>();
}
protected abstract FieldsDescriptor <TContentIndexItem> Fields(
FieldsDescriptor <TContentIndexItem> fields);
public DefaultSearchLocaleFields(FieldsDescriptor parent) : base(parent, "default_search_locale")
{
}
public CompetitorRankFields(FieldsDescriptor parent) : base(parent, "competitor_ranks")
{
MakeFields <CompetitorRank>();
}
/// <summary>
/// Creates field search for all analyzed fields.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="descriptor"></param>
/// <returns></returns>
public static FieldsDescriptor <T> AllAnalyzed <T>(this FieldsDescriptor <T> descriptor) where T : class =>
descriptor.Field($"*.{VulcanFieldConstants.AnalyzedModifier}");
public SerpFeaturesFields(FieldsDescriptor parent) : base(parent, "page_serp_features")
{
MakeFields <SerpFeatures>();
}
public async Task <SearchResponse <PlantInfo> > SearchAsync(FindParams <Data.Shared.Models.PlantInfo> findParams, Data.Shared.Models.User user)
{
var plantInfoFindParams = findParams as PlantInfoFindParams;
var searchTerm = findParams.SearchText;
var shoulds = new List <QueryContainer>();
var query = new QueryContainerDescriptor <PlantInfo>();
if (!string.IsNullOrEmpty(searchTerm))
{
var fields = new FieldsDescriptor <PlantInfo>();
fields = fields.Field(m => m.CommonName)
.Field(m => m.ScientificName)
.Field(m => m.Lifeform.CommonName)
.Field(m => m.Lifeform.ScientificName)
.Field("commonName.nameSearch")
.Field("scientificName.nameSearch")
.Field("lifeform.commonName.nameSearch")
.Field("lifeform.scientificName.nameSearch");
shoulds.Add(query.MultiMatch(mm => mm.Fields(mmf => fields)
.Query(searchTerm)
.Fuzziness(Fuzziness.AutoLength(3, 5))));
shoulds.Add(query.Nested(n => n
.Path(p => p.Synonyms)
.Query(q => q
.Match(sq => sq
.Field("synonyms.name")
.Query(searchTerm)
.Fuzziness(Fuzziness.AutoLength(3, 5))))));
}
var filters = plantInfoFindParams.Filters;
var searchFilters = new List <SearchFilter <PlantInfo> >
{
new NestedSearchValueFilter <PlantInfo, string>(filters.RegionFilter.Name, "location.region.keyword", "plantLocations", filters.RegionFilter.Value),
new SearchValuesFilter <PlantInfo, string>(filters.WaterFilter.Name, "waterTypes", filters.WaterFilter.MinimumValue, filters.WaterFilter.MaximumValue),
new SearchValuesFilter <PlantInfo, string>(filters.LightFilter.Name, "lightTypes", filters.LightFilter.MinimumValue, filters.LightFilter.MaximumValue),
new SearchValuesFilter <PlantInfo, string>(filters.BloomFilter.Name, "bloomTimes", filters.BloomFilter.MinimumValue?.ToString(), filters.BloomFilter.MaximumValue?.ToString()),
new NestedSearchValueFilter <PlantInfo, string>(filters.ZoneFilter.Name, "id", "zones", filters.ZoneFilter.Value?.ToString()),
new SearchRangeFilter <PlantInfo, double>(filters.HeightFilter.Name, "minHeight", "maxHeight", filters.HeightFilter.Values, filters.HeightFilter.Value, filters.HeightFilter.MaximumValue),
new SearchRangeFilter <PlantInfo, double>(filters.SpreadFilter.Name, "minSpread", "maxSpread", filters.SpreadFilter.Values, filters.SpreadFilter.Value, filters.SpreadFilter.MaximumValue),
new NestedSearchMultiValueFilter <PlantInfo, string, LocationStatus>(filters.NativeFilter.Name, "location.stateOrProvince.keyword", "plantLocations", "status",
filters.NativeFilter.Value, filters.NativeFilter.Status)
};
var musts = GetFilters(plantInfoFindParams, searchFilters);
musts.Add(FilterByVisibility(query, user));
if (plantInfoFindParams.Lifeform != null)
{
musts.Add(query.Bool(b => b.Must(m => m.Term(t => t.Lifeform.Id, plantInfoFindParams.Lifeform.LifeformId))));
}
var searchDescriptor = new SearchDescriptor <PlantInfo>()
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())
.Must(musts.ToArray()).MinimumShouldMatch(string.IsNullOrEmpty(searchTerm) ? 0 : 1)));
var countDescriptor = new CountDescriptor <PlantInfo>()
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())
.Must(musts.ToArray()).MinimumShouldMatch(string.IsNullOrEmpty(searchTerm) ? 0 : 1)));
var aggregations = new AggregationContainerDescriptor <PlantInfo>();
foreach (var filter in searchFilters)
{
if (filter is NestedSearchMultiValueFilter <PlantInfo, string, LocationStatus> nestedMultiFilter)
{
aggregations = nestedMultiFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is NestedSearchValueFilter <PlantInfo, string> nestedFilter)
{
aggregations = nestedFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchRangeFilter <PlantInfo, double> searchRangeFilter)
{
aggregations = searchRangeFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchValuesFilter <PlantInfo, string> searchValuesFilter)
{
aggregations = searchValuesFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchValueFilter <PlantInfo, string> searchValueFilter)
{
aggregations = searchValueFilter.ToAggregationContainerDescriptor(aggregations);
}
}
searchDescriptor.Aggregations(a => aggregations);
// Sort
var plantInfoSorts = GetPlantInfoSorts();
if (!string.IsNullOrEmpty(findParams.SortBy))
{
if (findParams.SortDirection == SortDirection.Ascending)
{
searchDescriptor.Sort(s => s.Field(f => f.Field(plantInfoSorts[findParams.SortBy]).Ascending()));
}
else
{
searchDescriptor.Sort(s => s.Field(f => f.Field(plantInfoSorts[findParams.SortBy]).Descending()));
}
}
else if (string.IsNullOrEmpty(findParams.SearchText))
{
searchDescriptor.Sort(s => s.Field(f => f.Field(plantInfoSorts["DateModified"]).Descending()).Field(f => f.Field(plantInfoSorts["DateCreated"]).Descending()));
}
var response = await _searchClient.SearchAsync(pi => searchDescriptor.Skip(findParams.Skip).Take(findParams.Take), pi => countDescriptor);
response.AggregationResult = ProcessAggregations(response, plantInfoFindParams);
return(response);
}
public AccountFields(FieldsDescriptor parent) : base(parent, "account")
{
MakeFields <Account>();
}
public async Task <SearchResponse <Specimen> > SearchAsync(FindParams <Data.Shared.Models.Specimen> findParams, Data.Shared.Models.User user)
{
var specimenFindParams = findParams as SpecimenFindParams;
var searchTerm = findParams.SearchText;
var musts = GetFilters(findParams);
var shoulds = new List <QueryContainer>();
var query = new QueryContainerDescriptor <Specimen>();
if (!string.IsNullOrEmpty(searchTerm))
{
var fields = new FieldsDescriptor <Specimen>();
fields = fields.Field(f => f.Name)
.Field(f => f.Lifeform.CommonName)
.Field(f => f.Lifeform.ScientificName);
if (findParams.UseNGrams)
{
fields = fields.Field("name.nameSearch");
}
shoulds.Add(query.MultiMatch(mm => mm.Fields(mmf => fields)
.Query(searchTerm)
.Fuzziness(Fuzziness.AutoLength(1, 5))));
}
musts.Add(FilterByVisibility(query, user));
var searchDescriptor = new SearchDescriptor <Specimen>()
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())
.Must(musts.ToArray()).MinimumShouldMatch(string.IsNullOrEmpty(searchTerm) ? 0 : 1)));
var countDescriptor = new CountDescriptor <Specimen>()
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())
.Must(musts.ToArray()).MinimumShouldMatch(string.IsNullOrEmpty(searchTerm) ? 0 : 1)));
// Sort
var specimenSorts = GetSpecimenSorts();
if (!string.IsNullOrEmpty(findParams.SortBy))
{
if (findParams.SortDirection == SortDirection.Ascending)
{
searchDescriptor.Sort(s => s.Field(f => f.Field(specimenSorts[findParams.SortBy]).Ascending()));
}
else
{
searchDescriptor.Sort(s => s.Field(f => f.Field(specimenSorts[findParams.SortBy]).Descending()));
}
}
else if (string.IsNullOrEmpty(findParams.SearchText))
{
searchDescriptor.Sort(s => s.Field(f => f.Field(specimenSorts["DateModified"]).Descending()).Field(f => f.Field(specimenSorts["DateCreated"]).Descending()));
}
var aggregations = new AggregationContainerDescriptor <Specimen>();
var searchFilters = new List <SearchFilter <Specimen> >
{
new SearchValueFilter <Specimen, string>("Stage", "specimenStage", specimenFindParams.Filters.StageFilter.Value)
};
foreach (var filter in searchFilters)
{
if (filter is NestedSearchValueFilter <Specimen, string> nestedFilter)
{
aggregations = nestedFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchRangeFilter <Specimen, double> searchRangeFilter)
{
aggregations = searchRangeFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchValueFilter <Specimen, string> searchValueFilter)
{
aggregations = searchValueFilter.ToAggregationContainerDescriptor(aggregations);
}
}
searchDescriptor.Aggregations(a => aggregations);
var response = await _searchClient.SearchAsync(pi => searchDescriptor.Skip(findParams.Skip).Take(findParams.Take), pi => countDescriptor);
response.AggregationResult = ProcessAggregations(response, specimenFindParams);
return(response);
}
public LandingPageFields(FieldsDescriptor parent) : this(parent, "landing_page")
{
}
public SearchVolumeFields(FieldsDescriptor parent) : base(parent, "search_volume")
{
MakeFields <SearchVolume>();
}
public RankFields(FieldsDescriptor parent) : base(parent, "ranks")
{
MakeFields <Rank>();
}
public AnalyticsDateRangeFields(FieldsDescriptor parent) : base(parent, string.Empty)
{
OwnerFullName = new Field(null, "ownerFullName");
MakeFields <AnalyticsDateRange>();
}
public GroupFields(FieldsDescriptor parent) : base(parent, "group")
{
MakeFields <Group>();
}
