private static IAggregationContainer GetAgg_name_FamilyName(AggregationContainerDescriptor <familyname> agg, FamilyNameSearchParam ci, List <string> fns = null)
{
var size = ci.pg_index == 0 ? ci.name_num_max : 1;
if (!string.IsNullOrWhiteSpace(ci.Familyname))
{
size = ci.familyname_num_max * ci.name_num_max * ci.com_num_max;
}
agg.Filters("fn", fs => fs
.NamedFilters(nf => GetNamedFilters_FamilyName(nf, "fn_" + ci.ptype.ToString(), fns))
.Aggregations(ca => ca.Terms("name", t => t.Field(ci.ptype.ToString()).Size(size))));
if (!string.IsNullOrWhiteSpace(ci.Familyname))
{
if (string.IsNullOrWhiteSpace(ci.areacode))
{
agg.Terms("carea", t => t
.Field("cmarea").Size(32));
}
else if (ci.areacode.Length == 2)
{
agg.Terms("carea", t => t
.Field("carea").Size(24));
}
}
return(agg);
}
/// <summary>
/// 获取聚合
/// </summary>
/// <param name="agg"></param>
/// <param name="ci"></param>
/// <returns></returns>
private IAggregationContainer Get_Agg(AggregationContainerDescriptor <T> agg, QueryDes qd)
{
var ls = qd.Aggs;
if (ls == null)
{
return(agg);
}
foreach (var s in ls)
{
switch (s)
{
case 1:
agg.Terms("m_area", t => t.Field("m_area").Size(33));
break;
case 2:
agg.Range("od_regm", r => r.Field("od_regm").Ranges(rs => rs.To(100), rs => rs.From(100).To(500), rs => rs.From(500).To(1000),
rs => rs.From(1000)));
break;
case 3:
agg.DateHistogram("od_regdate", t => t.Field("od_regdate").Interval(DateInterval.Year)
.MinimumDocumentCount(1).ExtendedBounds(new DateTime(1900, 1, 1), DateTime.Now));
break;
}
}
return(agg);
}
protected override AggregationContainerDescriptor <PersonDocument> ApplyAggregations(AggregationContainerDescriptor <PersonDocument> descriptor, PersonSearchParameters parameters)
{
return
(descriptor
.Terms(nameof(PersonSearchParameters.Tags), t => t
.AsSearchifyFilter(c => c.WithDisplayName("Search Tags"))
.Field(f => f.Tags.First().Key)
)
.Terms(nameof(PersonSearchParameters.Country), t => t
.AsSearchifyFilter()
.Field(f => f.Country.Key)
)
.Range(PersonSearchParameters.AgeRangeParameter, r => r
.AsSearchifyFilter(c => c.WithDisplayName("Age Range"))
.Field(f => f.Age)
.Ranges(
rng => rng.Key(FilterField.Create(AgeRangeEnum.Young))
.From(0)
.To(20),
rng => rng.Key(FilterField.Create(AgeRangeEnum.MiddleAge))
.From(21)
.To(40),
rng => rng.Key(FilterField.Create(AgeRangeEnum.Older)).From(41)
)
)
);
}
private AggregationContainerDescriptor <TEntity> GetAggregation(List <AggregationItem> aggregations)
{
AggregationContainerDescriptor <TEntity> aggregation = new AggregationContainerDescriptor <TEntity>();
if (aggregations != null)
{
foreach (var item in aggregations)
{
string name = item.Name;
switch (item.Type)
{
case AggregationExpressionType.Count:
aggregation.Terms(name, aggr =>
{
aggr.Field(item.Name)
.Size(item.Size)
//.Exclude(item.ExcludedItems)
.Aggregations(child => GetAggregation(item.Children));
if (!string.IsNullOrEmpty(item.SortField))
{
aggr.Order(new TermsOrder()
{
Key = item.SortField,
Order = item.SortType == "asc" ? SortOrder.Ascending : SortOrder.Descending
});
}
return(aggr);
});
break;
case AggregationExpressionType.Range:
SetRangeAggregationContainer(item, aggregation);
break;
case AggregationExpressionType.Sum:
aggregation.Sum(name, d => d.Field(item.Name));
break;
case AggregationExpressionType.Avg:
aggregation.Average(name, d => d.Field(item.Name));
break;
case AggregationExpressionType.Min:
aggregation.Min(name, d => d.Field(item.Name));
break;
case AggregationExpressionType.Max:
aggregation.Max(name, d => d.Field(item.Name));
break;
default:
break;
}
}
}
return(aggregation);
}
private static IAggregationContainer GetAgg_fn_FamilyName(AggregationContainerDescriptor <familyname> agg, FamilyNameSearchParam ci)
{
if (string.IsNullOrWhiteSpace(ci.areacode))
{
agg.Terms("carea", t => t
.Field("cmarea").Size(32));
}
else if (ci.areacode.Length == 2)
{
agg.Terms("carea", t => t
.Field("carea").Size(24));
}
agg.Terms("fn", t => t
.Field("fn_" + ci.ptype.ToString())
.Size(ci.familyname_num_max));
return(agg);
}
private static AggregationContainerDescriptor <EssayDocument> MakeAggregations(AggregationContainerDescriptor <EssayDocument> acd)
{
return(acd
.Terms(
MatchedTermsAggregateIdentifier,
t => t
.Field(x => x.Terms)
.Order(TermsOrder.CountDescending)
.Size(EssayLibraryMetadata.Themes.Count)));
}
/// <summary>
/// Creates a nested aggregation. Wraps the aggregation on which it is called by a new Terms aggregation, using the provided fieldName.
/// </summary>
public static AggregationContainerDescriptor <T> GroupBy <T>(this AggregationContainerDescriptor <T> innerAggregation, string fieldName) where T : class
{
var v = new AggregationContainerDescriptor <T>();
v.Terms(fieldName, tr =>
{
var trmAggDescriptor = new TermsAggregationDescriptor <T>();
trmAggDescriptor.Field(fieldName);
trmAggDescriptor.Size(int.MaxValue);
return(trmAggDescriptor.Aggregations(x => innerAggregation));
});
return(v);
}
public static AggregationContainerDescriptor <T> GroupBy <T>(this AggregationContainerDescriptor <T> innerAggregation, String key) where T : class
{
AggregationContainerDescriptor <T> v = new AggregationContainerDescriptor <T>();
v.Terms(key, tr =>
{
TermsAggregationDescriptor <T> trmAggDescriptor = new TermsAggregationDescriptor <T>();
trmAggDescriptor.Field(key);
trmAggDescriptor.Size(int.MaxValue);
return(trmAggDescriptor.Aggregations(x => innerAggregation));
});
return(v);
}
/// <summary>
/// Creates a nested aggregation. Wraps the aggregation on which it is called by a new Terms aggregation, using the provided fieldGetter function to terms on the field.
/// </summary>
public static AggregationContainerDescriptor <T> GroupBy <T>(this AggregationContainerDescriptor <T> innerAggregation, Expression <Func <T, object> > fieldGetter) where T : class
{
var fieldName = fieldGetter.GetAggName(AggType.GroupBy);
var v = new AggregationContainerDescriptor <T>();
v.Terms(fieldName, tr =>
{
var trmAggDescriptor = new TermsAggregationDescriptor <T>();
trmAggDescriptor.Field(fieldGetter);
trmAggDescriptor.Size(int.MaxValue);
return(trmAggDescriptor.Aggregations(x => innerAggregation));
});
return(v);
}
private static IAggregationContainer GetAggContainer(AggregationContainerDescriptor <Person> agg, SearchParam p)
{
if (p.aggs != null)
{
foreach (var a in p.aggs)
{
switch (a)
{
case PersonEnum.age:
agg.Range("age", r => r.Field(f => f.age).Ranges(rs => rs.To(20),
rs => rs.From(20).To(30),
rs => rs.From(30).To(40),
rs => rs.From(40).To(50),
rs => rs.From(50).To(60),
rs => rs.From(60)));
break;
case PersonEnum.graduate:
agg.DateHistogram("graduate", d => d.Field(f => f.graduate)
.Interval(DateInterval.Year)
.MinimumDocumentCount(1)
.ExtendedBounds("1980", "2050"));
break;
case PersonEnum.isMan:
agg.Terms("isMan", t => t.Field(f => f.isMan));
break;
case PersonEnum.city:
agg.Terms("city", t => t.Field(f => f.city));
break;
}
}
}
return(agg);
}
///// <summary>
///// 获得排序脚本
///// </summary>
///// <param name="sort">排序规则</param>
///// <param name="field">排序字段</param>
///// <returns></returns>
//private static string GetOrderScript(Sort sort, string field)
//{
// var value = sort.Promotion;
// var sb = new StringBuilder();
// for (int i = 0; i < value.Count + 1; i++)
// {
// string scriptText;
// string itemValue;
// if (i == 0)
// {
// itemValue = value[i].Trim();
// // scriptText = $"if('{itemValue}' == doc['{field.KeyWord()}'].value)return 0;";
// scriptText = $"'{itemValue}'==doc['{field.KeyWord()}'].value?0";
// }
// else if (i == value.Count)
// {
// // scriptText = $"else return {value.Count}";
// scriptText = $":{i}";
// for (var j = 0; j < value.Count - 1; j++)
// {
// scriptText += ")";
// }
// }
// else
// {
// itemValue = value[i];
// //scriptText = $"else if('{itemValue}' == doc['{field.KeyWord()}'].value)return {i};";
// scriptText = $":('{itemValue}'==doc['{field.KeyWord()}'].value?{i}";
// }
// sb.Append(scriptText);
// }
// return sb.ToString();
//}
/// <summary>
/// 根据聚合条件构建聚合器
/// </summary>
/// <param name="groups">聚合条件</param>
/// <returns></returns>
public AggregationContainerDescriptor <T> BuildAggs(SearchGroupRules groups)
{
if (groups == null || groups.Fields.Count == 0)
{
return(null);
}
var aggsDesc = new AggregationContainerDescriptor <T>();
foreach (var gfield in groups.Fields)
{
aggsDesc.Terms(gfield, s => s.Field(KeyWord(gfield)).Size(groups.Top).OrderDescending("_count"));
}
return(aggsDesc);
}
public static AggregationContainerDescriptor <T> FirstBy <T>(this AggregationContainerDescriptor <T> agg, Expression <Func <T, object> > fieldGetter, Expression <Func <T, bool> > filterRule = null) where T : class
{
var aggName = fieldGetter.GetAggName(AggType.Sum);
if (filterRule == null)
{
return(agg.Terms(aggName, x => x.Field(fieldGetter)));
}
var filterName = filterRule.GenerateFilterName();
agg.Filter(filterName,
f =>
f.Filter(fd => filterRule.Body.GenerateFilterDescription <T>())
.Aggregations(innerAgg => innerAgg.Terms(aggName, field => field.Field(fieldGetter))));
return(agg);
}
public override AggregationContainerDescriptor <T> ToAggregationContainerDescriptor(AggregationContainerDescriptor <T> aggregationDescriptor)
{
if ((MinValue != null && !string.IsNullOrEmpty(MinValue?.ToString())) || (MaxValue != null && !string.IsNullOrEmpty(MaxValue.ToString())))
{
int.TryParse(MinValue?.ToString(), out var minValue);
int.TryParse(MaxValue?.ToString(), out var maxValue);
return(aggregationDescriptor
.Filter(Name, f => f.Filter(f =>
{
QueryContainer query = null;
if (minValue > 0 && maxValue > 0)
{
var values = new List <int>();
for (var i = minValue; i <= maxValue; i++)
{
values.Add(i);
}
query = f.Terms(t => t.Field(Field).Terms(values));
}
else
{
if (minValue > 0)
{
query = f.Term(Field, minValue);
}
else if (maxValue > 0)
{
query = f.Term(Field, maxValue);
}
}
return query;
}))
.Terms(Name, t => t
.Field(Field)));
}
else
{
return(aggregationDescriptor
.Terms(Name, t => t
.Field(Field)));
}
}
protected override AggregationContainerDescriptor <PersonDocument> ApplyAggregations(AggregationContainerDescriptor <PersonDocument> descriptor, PersonSearchParameters parameters)
{
return
(descriptor
.Terms(nameof(PersonSearchParameters.Tags), t => t
.AsSearchifyFilter(c => c.WithDisplayName("Search Tags"))
.Field(f => f.Tags.First().Key)
)
.Terms(nameof(PersonSearchParameters.Country), t => t
.AsSearchifyFilter()
.Field(f => f.Country.Key)
)
.Range(PersonSearchParameters.AgeRangeParameter, r => r
.AsSearchifyFilter(c => c.WithDisplayName("Age Range"))
.Field(f => f.Age)
.Ranges(
rng => rng.Key(FilterField.Create(AgeRangeEnum.Young))
.From(0)
.To(20),
rng => rng.Key(FilterField.Create(AgeRangeEnum.MiddleAge))
.From(21)
.To(40),
rng => rng.Key(FilterField.Create(AgeRangeEnum.Older)).From(41)
)
)
.GeoDistance(nameof(PersonSearchParameters.LocationRange), g => g
.AsSearchifyFilter()
.Field(f => f.Location)
.Origin(parameters.Location)
.Unit(DistanceUnit.Miles)
.Ranges(
r => r.Key("1||up to 10 miles").To(10),
r => r.Key("2||up to 20 miles").To(20),
r => r.Key("3||up to 30 miles").To(30),
r => r.Key("4||up to 40 miles").To(40),
r => r.Key("5||up to 50 miles").To(50),
r => r.Key("6||up to 100 miles").To(100),
r => r.Key("7||more than 100 miles").From(100)
)));
}
private static AggregationContainerDescriptor <ExpandoObject> BuildAggregationContainer(AggregationContainerDescriptor <ExpandoObject> a,
int i, int max, List <string> categories, string fact,
string aggFunc)
{
return(a.Terms("level" + i, ta => ta
.Size(1000)
.Field(categories[i].ToLower())
.Aggregations(aa =>
{
if (i == max)
{
if (aggFunc == "avg")
{
return aa.Average("summe", ts => ts.Field(fact.ToLower()));
}
if (aggFunc == "min")
{
return aa.Min("summe", ts => ts.Field(fact.ToLower()));
}
if (aggFunc == "max")
{
return aa.Max("summe", ts => ts.Field(fact.ToLower()));
}
return aa.Sum("summe", ts => ts.Field(fact.ToLower()));
}
else
{
i++;
return BuildAggregationContainer(aa, i, categories.Count - 1, categories, fact.ToLower(), aggFunc);
}
}
)
));
}
public static AggregationContainerDescriptor <T> DistinctBy <T>(this AggregationContainerDescriptor <T> agg, Expression <Func <T, object> > fieldGetter) where T : class
{
var aggName = fieldGetter.GetAggName(AggType.Distinct);
return(agg.Terms(aggName, x => x.Field(fieldGetter).Size(int.MaxValue)));
}
public virtual AggregationContainerDescriptor <T> ToAggregationContainerDescriptor(AggregationContainerDescriptor <T> aggregationDescriptor) =>
aggregationDescriptor
.Terms(Name, t => t
.Field(Field));
private static AggregationContainerDescriptor <Customer> NewMethod(AggregationContainerDescriptor <Customer> a)
{
return(a.Terms("school.suburb", t => t.Field(f => f.school.suburb)).Terms("school.suburb", t => t.Field(f => f.school.state)));//.Max("maxId", t => t.Field(f => f.CustomerId));
}
_topSmluvniStranyPerYear(
string property,
string query,
int[] interestedInYearsOnly,
int maxList
)
{
AggregationContainerDescriptor <HlidacStatu.Lib.Data.Smlouva> aggs = new AggregationContainerDescriptor <HlidacStatu.Lib.Data.Smlouva>();
aggs
.Terms("perIco", m => m
.Field(property)
.Size(maxList)
).Terms("perPrice", m => m
.Order(o => o.Descending("sumincome"))
.Field(property)
.Size(maxList)
.Aggregations(agg => agg
.Sum("sumincome", s => s
.Field(ff => ff.CalculatedPriceWithVATinCZK)
)
)
);
Func <AggregationContainerDescriptor <Lib.Data.Smlouva>, AggregationContainerDescriptor <Lib.Data.Smlouva> > aggrFunc
= (aggr) => { return(aggs); };
AggregationContainerDescriptor <HlidacStatu.Lib.Data.Smlouva> aggYSum =
new AggregationContainerDescriptor <HlidacStatu.Lib.Data.Smlouva>()
.DateHistogram("y-agg", h => h
.Field(f => f.datumUzavreni)
.CalendarInterval(Nest.DateInterval.Year)
.Aggregations(aggrFunc)
);
var res = HlidacStatu.Lib.Data.Smlouva.Search.SimpleSearch(query, 1, 0,
HlidacStatu.Lib.Data.Smlouva.Search.OrderResult.FastestForScroll, aggYSum, exactNumOfResults: true);
Dictionary <int, (List <(string ico, BasicData stat)> topPodlePoctu, List <(string ico, BasicData stat)> topPodleKc)> result =
new Dictionary <int, (List <(string ico, BasicData stat)> topPodlePoctu, List <(string ico, BasicData stat)> topPodleKc)>();
if (interestedInYearsOnly != null)
{
foreach (int year in interestedInYearsOnly)
{
result.Add(year,
(new List <(string ico, BasicData stat)>(),
new List <(string ico, BasicData stat)>())
);
}
}
foreach (Nest.DateHistogramBucket val in ((BucketAggregate)res.ElasticResults.Aggregations["y-agg"]).Items)
{
if (interestedInYearsOnly == null)
{
result.Add(val.Date.Year,
(new List <(string ico, BasicData stat)>(),
new List <(string ico, BasicData stat)>())
);
}
if (result.ContainsKey(val.Date.Year))
{
result[val.Date.Year] =
(topPodlePoctu : ((BucketAggregate)val["perIco"]).Items
.Select(m => ((KeyedBucket <object>)m))
.Select(m => (m.Key.ToString(), new BasicData()
{
Pocet = m.DocCount ?? 0
}))
.ToList(),
topPodleKc : ((BucketAggregate)val["perPrice"]).Items
.Select(m => ((KeyedBucket <object>)m))
.Select(m => (m.Key.ToString(), new BasicData()
{
Pocet = m.DocCount ?? 0
}))
.ToList()
);
}
}
return(result);
}
