public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var parentQuery = ctx.GetSourceAs <IParentQuery>();
bool hasIds = ctx.GetSourceAs <IIdentityQuery>()?.Ids.Count > 0;
if (parentQuery == null)
{
return;
}
var options = ctx.GetOptionsAs <IElasticQueryOptions>();
IQueryOptions parentOptions = null;
if (options != null && options.HasParent == false)
{
return;
}
if (options != null && options.ParentSupportsSoftDeletes && hasIds == false)
{
if (parentQuery.ParentQuery == null)
{
parentQuery.ParentQuery = new ParentQuery();
}
var parentType = options.ChildType.GetParentIndexType();
if (parentType == null)
{
throw new ApplicationException("ParentIndexTypeName on child index type must match the name of the parent type.");
}
parentOptions = new ElasticQueryOptions(parentType);
}
if (parentQuery.ParentQuery == null)
{
return;
}
var parentContext = new QueryBuilderContext <object>(parentQuery.ParentQuery, parentOptions, null, ctx, ContextType.Parent);
await _queryBuilder.BuildAsync(parentContext).AnyContext();
if ((parentContext.Query == null || parentContext.Query.IsConditionless) &&
(parentContext.Filter == null || parentContext.Filter.IsConditionless))
{
return;
}
ctx.Filter &= new HasParentFilter {
Query = parentContext.Query,
Filter = parentContext.Filter,
Type = options?.ChildType?.GetParentIndexType().Name
};
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var childQuery = ctx.GetSourceAs <IChildQuery>();
if (childQuery?.ChildQuery == null)
{
return;
}
if (String.IsNullOrEmpty(childQuery.ChildQuery.Type))
{
throw new ArgumentException("Must specify a child type for child queries.");
}
// this should pass an options object that is for the child index type
var childContext = new QueryBuilderContext <T>(childQuery.ChildQuery, ctx.Options, null, ctx, ContextType.Child);
await _queryBuilder.BuildAsync(childContext).AnyContext();
if ((childContext.Query == null || childContext.Query.IsConditionless) &&
(childContext.Filter == null || childContext.Filter.IsConditionless))
{
return;
}
ctx.Filter &= new HasChildFilter {
Query = childContext.Query,
Filter = childContext.Filter,
Type = childQuery.ChildQuery.Type
};
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var elasticQuery = ctx.GetSourceAs <IElasticFilterQuery>();
if (elasticQuery?.ElasticFilter == null)
{
return(Task.CompletedTask);
}
ctx.Filter &= elasticQuery.ElasticFilter;
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var searchQuery = ctx.GetSourceAs <ISearchQuery>();
if (searchQuery == null)
{
return(Task.CompletedTask);
}
if (!String.IsNullOrEmpty(searchQuery.Filter))
{
var result = _parser.Parse(searchQuery.Filter);
searchQuery.Filter = GenerateQueryVisitor.Run(AliasedQueryVisitor.Run(result, _aliasMap, ctx), ctx);
ctx.Filter &= new QueryFilter {
Query = new QueryStringQuery {
Query = searchQuery.Filter,
DefaultOperator = Operator.And,
AnalyzeWildcard = false
}.ToContainer()
};
}
if (!String.IsNullOrEmpty(searchQuery.Criteria))
{
var result = _parser.Parse(searchQuery.Criteria);
searchQuery.Criteria = GenerateQueryVisitor.Run(AliasedQueryVisitor.Run(result, _aliasMap, ctx), ctx);
ctx.Query &= new QueryStringQuery {
Query = searchQuery.Criteria,
DefaultOperator = searchQuery.DefaultCriteriaOperator == SearchOperator.Or ? Operator.Or : Operator.And,
AnalyzeWildcard = true
};
}
if (!String.IsNullOrEmpty(searchQuery.Sort))
{
var result = _parser.Parse(searchQuery.Sort);
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
TermToFieldVisitor.Run(result, ctx);
AliasedQueryVisitor.Run(result, _aliasMap, ctx);
var fields = GetReferencedFieldsQueryVisitor.Run(result);
// TODO: Check referenced fields against opt.AllowedSortFields
var sort = GetSortFieldsVisitor.Run(result, ctx);
ctx.Search.Sort(sort);
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var selectedFieldsQuery = ctx.GetSourceAs <ISelectedFieldsQuery>();
if (selectedFieldsQuery?.SelectedFields?.Count > 0)
{
ctx.Search.Source(s => s.Include(selectedFieldsQuery.SelectedFields.ToArray()));
return(Task.CompletedTask);
}
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
if (opt?.DefaultExcludes?.Count > 0)
{
ctx.Search.Source(s => s.Exclude(opt.DefaultExcludes.ToArray()));
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var fieldValuesQuery = ctx.GetSourceAs <IFieldConditionsQuery>();
if (fieldValuesQuery?.FieldConditions == null || fieldValuesQuery.FieldConditions.Count <= 0)
{
return(Task.CompletedTask);
}
foreach (var fieldValue in fieldValuesQuery.FieldConditions)
{
switch (fieldValue.Operator)
{
case ComparisonOperator.Equals:
ctx.Filter &= new TermFilter {
Field = fieldValue.Field, Value = fieldValue.Value
};
break;
case ComparisonOperator.NotEquals:
ctx.Filter &= new NotFilter {
Filter = FilterContainer.From(new TermFilter {
Field = fieldValue.Field, Value = fieldValue.Value
})
};
break;
case ComparisonOperator.IsEmpty:
ctx.Filter &= new MissingFilter {
Field = fieldValue.Field
};
break;
case ComparisonOperator.HasValue:
ctx.Filter &= new ExistsFilter {
Field = fieldValue.Field
};
break;
}
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var sortableQuery = ctx.GetSourceAs <ISortableQuery>();
if (sortableQuery?.SortFields == null || sortableQuery.SortFields.Count <= 0)
{
return(Task.CompletedTask);
}
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
// TODO: Check SortFields against opt.AllowedSortFields
//foreach (var sort in sortableQuery.SortFields.Where(s => CanSortByField(opt?.AllowedSortFields, s.Field.ToString())))
// ctx.Search.Sort(s => s.OnField(sort.Field)
// .Order(sort.Order == Foundatio.Repositories.Models.SortOrder.Ascending ? SortOrder.Ascending : SortOrder.Descending));
ctx.Search.Sort(sortableQuery.SortFields);
return(Task.CompletedTask);
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var aggregationQuery = ctx.GetSourceAs <IAggregationQuery>();
if (String.IsNullOrEmpty(aggregationQuery?.Aggregations))
{
return;
}
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
if (opt?.AllowedAggregationFields?.Count > 0 && !(await GetAggregationFieldsAsync(aggregationQuery.Aggregations).AnyContext()).All(f => opt.AllowedAggregationFields.Contains(f)))
{
throw new InvalidOperationException("All aggregation fields must be allowed.");
}
var result = await _parser.BuildAggregationsAsync(aggregationQuery.Aggregations, ctx).AnyContext();
ctx.Search.Aggregations(result);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var dateRangeQuery = ctx.GetSourceAs <IDateRangeQuery>();
if (dateRangeQuery?.DateRanges == null || dateRangeQuery.DateRanges.Count <= 0)
{
return(Task.CompletedTask);
}
foreach (var dateRange in dateRangeQuery.DateRanges.Where(dr => dr.UseDateRange))
{
ctx.Filter &= new RangeFilter {
Field = dateRange.Field,
GreaterThanOrEqualTo = dateRange.GetStartDate().ToString("o"),
LowerThanOrEqualTo = dateRange.GetEndDate().ToString("O")
};
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var pagableQuery = ctx.GetSourceAs <IPagableQuery>();
if (pagableQuery == null)
{
return(Task.CompletedTask);
}
// add 1 to limit if not auto paging so we can know if we have more results
if (pagableQuery.ShouldUseLimit())
{
ctx.Search.Size(pagableQuery.GetLimit() + (pagableQuery.ShouldUseSnapshotPaging() == false ? 1 : 0));
}
if (pagableQuery.ShouldUseSkip())
{
ctx.Search.Skip(pagableQuery.GetSkip());
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var identityQuery = ctx.GetSourceAs <IIdentityQuery>();
if (identityQuery == null)
{
return(Task.CompletedTask);
}
if (identityQuery.Ids != null && identityQuery.Ids.Count > 0)
{
ctx.Filter &= new IdsFilter {
Values = identityQuery.Ids
}
}
;
if (identityQuery.ExcludedIds != null && identityQuery.ExcludedIds.Count > 0)
{
ctx.Filter &= !new IdsFilter {
Values = identityQuery.ExcludedIds
}
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
if (ctx.Type == ContextType.SystemFilter)
{
return;
}
var systemFilter = ctx.GetSourceAs <ISystemFilterQuery>();
if (systemFilter == null)
{
return;
}
var innerContext = new QueryBuilderContext <T>(systemFilter.SystemFilter, ctx.Options, ctx.Search, ctx, ContextType.SystemFilter)
{
Filter = ctx.Filter,
Query = ctx.Query
};
await _queryBuilder.BuildAsync <T>(innerContext).AnyContext();
ctx.Filter = innerContext.Filter;
ctx.Query = innerContext.Query;
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var searchQuery = ctx.GetSourceAs <ISearchQuery>();
if (searchQuery == null)
{
return;
}
if (!String.IsNullOrEmpty(searchQuery.Criteria))
{
ctx.Query &= await _parser.BuildQueryAsync(searchQuery.Criteria, ctx).AnyContext();
}
if (!String.IsNullOrEmpty(searchQuery.Filter))
{
ctx.Filter &= await _parser.BuildFilterAsync(searchQuery.Filter, ctx).AnyContext();
}
if (!String.IsNullOrEmpty(searchQuery.Sort))
{
ctx.Search.Sort(await _parser.BuildSortAsync(searchQuery.Sort, ctx).AnyContext());
}
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
// wait until the system filter query is being built if the query supports it
if (ctx.Type != ContextType.SystemFilter && ctx.Source is ISystemFilterQuery)
{
return(Task.CompletedTask);
}
// dont add filter to child query system filters
if (ctx.Parent?.Type == ContextType.Child)
{
return(Task.CompletedTask);
}
var mode = ctx.GetSourceAs <ISoftDeletesQuery>()?.SoftDeleteMode;
// if no mode was specified, then try using the parent query mode
if (mode == null && ctx.Parent != null)
{
mode = ctx.Parent.GetSourceAs <ISoftDeletesQuery>()?.SoftDeleteMode;
}
// default to active only if no mode has been specified
if (mode.HasValue == false)
{
mode = SoftDeleteQueryMode.ActiveOnly;
}
// no filter needed if we want all
if (mode.Value == SoftDeleteQueryMode.All)
{
return(Task.CompletedTask);
}
// check to see if the model supports soft deletes
var options = ctx.GetOptionsAs <IElasticQueryOptions>();
if (options == null || !options.SupportsSoftDeletes)
{
return(Task.CompletedTask);
}
// if we are querying for specific ids then we don't need a deleted filter
var idsQuery = ctx.GetSourceAs <IIdentityQuery>();
if (idsQuery != null && idsQuery.Ids.Count > 0)
{
return(Task.CompletedTask);
}
if (mode.Value == SoftDeleteQueryMode.ActiveOnly)
{
ctx.Filter &= new TermFilter {
Field = Fields.Deleted, Value = false
}
}
;
else if (mode.Value == SoftDeleteQueryMode.DeletedOnly)
{
ctx.Filter &= new TermFilter {
Field = Fields.Deleted, Value = true
}
}
;
return(Task.CompletedTask);
}
