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); }