private async Task <ClrQuery> ParseClrQueryAsync(Context context, Q q, ISchemaEntity?schema) { var components = ResolvedComponents.Empty; if (schema != null) { components = await appprovider.GetComponentsAsync(schema); } var query = q.Query; if (!string.IsNullOrWhiteSpace(q.QueryAsJson)) { query = ParseJson(context, schema, q.QueryAsJson, components); } else if (q?.JsonQuery != null) { query = ParseJson(context, schema, q.JsonQuery, components); } else if (!string.IsNullOrWhiteSpace(q?.QueryAsOdata)) { query = ParseOData(context, schema, q.QueryAsOdata, components); } return(query); }
private ClrQuery ParseJson(Context context, ISchemaEntity?schema, Query <IJsonValue> query, ResolvedComponents components) { var jsonSchema = BuildJsonSchema(context, schema, components); return(jsonSchema.Convert(query)); }
private ClrQuery ParseJson(Context context, ISchemaEntity?schema, Query <IJsonValue> query, ResolvedComponents components) { var queryModel = BuildQueryModel(context, schema, components); return(queryModel.Convert(query)); }
private ClrQuery ParseOData(Context context, ISchemaEntity?schema, string odata, ResolvedComponents components) { try { var model = BuildEdmModel(context, schema, components); return(model.ParseQuery(odata).ToQuery()); } catch (ValidationException) { throw; } catch (NotSupportedException) { throw new ValidationException(T.Get("common.odataNotSupported", new { odata })); } catch (ODataException ex) { var message = ex.Message; throw new ValidationException(T.Get("common.odataFailure", new { odata, message }), ex); } catch (Exception) { throw new ValidationException(T.Get("common.odataNotSupported", new { odata })); } }
private ClrQuery ParseJson(Context context, ISchemaEntity?schema, string json, ResolvedComponents components) { var queryModel = BuildQueryModel(context, schema, components); return(queryModel.Parse(json, jsonSerializer)); }
public async Task <ISchemaEntity?> GetSchemaAsync(Context context, string schemaIdOrName) { Guard.NotNull(context, nameof(context)); Guard.NotNullOrEmpty(schemaIdOrName, nameof(schemaIdOrName)); ISchemaEntity?schema = null; var canCache = !context.IsFrontendClient; if (Guid.TryParse(schemaIdOrName, out var guid)) { var schemaId = DomainId.Create(guid); schema = await appProvider.GetSchemaAsync(context.App.Id, schemaId, canCache); } if (schema == null) { schema = await appProvider.GetSchemaAsync(context.App.Id, schemaIdOrName, canCache); } if (schema != null && !HasPermission(context, schema, Permissions.AppContentsReadOwn)) { throw new DomainForbiddenException(T.Get("schemas.noPermission")); } return(schema); }
public async Task <ISchemaEntity> GetSchemaOrThrowAsync(Context context, string schemaIdOrName) { ISchemaEntity?schema = null; var canCache = !context.IsFrontendClient; if (Guid.TryParse(schemaIdOrName, out var guid)) { var schemaId = DomainId.Create(guid); schema = await appProvider.GetSchemaAsync(context.App.Id, schemaId, false, canCache); } if (schema == null) { schema = await appProvider.GetSchemaAsync(context.App.Id, schemaIdOrName, canCache); } if (schema == null) { throw new DomainObjectNotFoundException(schemaIdOrName); } return(schema); }
private static string BuildJsonCacheKey(IAppEntity app, ISchemaEntity?schema, bool withHidden) { if (schema == null) { return($"JSON/__generic"); } return($"JSON/{app.Version}/{schema.Id}_{schema.Version}/{withHidden}"); }
private QueryModel BuildQueryModel(Context context, ISchemaEntity?schema, ResolvedComponents components) { var cacheKey = BuildJsonCacheKey(context.App, schema, context.IsFrontendClient); var result = cache.GetOrCreate(cacheKey, entry => { entry.AbsoluteExpirationRelativeToNow = CacheTime; return(ContentQueryModel.Build(schema?.SchemaDef, context.App.PartitionResolver(), components)); }); return(result); }
private IEdmModel BuildEdmModel(Context context, ISchemaEntity?schema, ResolvedComponents components) { var cacheKey = BuildEmdCacheKey(context.App, schema, context.IsFrontendClient); var result = cache.GetOrCreate <IEdmModel>(cacheKey, entry => { entry.AbsoluteExpirationRelativeToNow = CacheTime; return(BuildQueryModel(context, schema, components).ConvertToEdm("Contents", schema?.SchemaDef.Name ?? "Generic")); }); return(result); }
public virtual ValueTask <Q> ParseAsync(Context context, Q q, ISchemaEntity?schema = null) { Guard.NotNull(context, nameof(context)); Guard.NotNull(q, nameof(q)); using (Profiler.TraceMethod <ContentQueryParser>()) { var query = q.Query; if (!string.IsNullOrWhiteSpace(q.JsonQueryString)) { query = ParseJson(context, schema, q.JsonQueryString); } else if (q?.JsonQuery != null) { query = ParseJson(context, schema, q.JsonQuery); } else if (!string.IsNullOrWhiteSpace(q?.ODataQuery)) { query = ParseOData(context, schema, q.ODataQuery); } if (query.Sort.Count == 0) { query.Sort.Add(new SortNode(new List <string> { "lastModified" }, SortOrder.Descending)); } if (!query.Sort.Any(x => string.Equals(x.Path.ToString(), "id", StringComparison.OrdinalIgnoreCase))) { query.Sort.Add(new SortNode(new List <string> { "id" }, SortOrder.Ascending)); } if (query.Take == long.MaxValue) { query.Take = options.DefaultPageSize; } else if (query.Take > options.MaxResults) { query.Take = options.MaxResults; } q = q !.WithQuery(query); return(new ValueTask <Q>(q)); } }
private IEdmModel BuildEdmModel(Context context, ISchemaEntity?schema) { if (schema == null) { return(genericEdmModel); } var cacheKey = BuildEmdCacheKey(context.App, schema, context.IsFrontendClient); var result = cache.GetOrCreate <IEdmModel>(cacheKey, entry => { entry.AbsoluteExpirationRelativeToNow = CacheTime; return(BuildEdmModel(schema.SchemaDef, context.App, context.IsFrontendClient)); }); return(result); }
public static async Task <ContentsDto> FromContentsAsync(IResultList <IEnrichedContentEntity> contents, Resources resources, ISchemaEntity?schema, IContentWorkflow workflow) { var result = new ContentsDto { Total = contents.Total, Items = contents.Select(x => ContentDto.FromDomain(x, resources)).ToArray() }; if (schema != null) { await result.AssignStatusesAsync(workflow, schema); await result.CreateLinksAsync(resources, workflow, schema); } return(result); }
public static async Task <ContentsDto> FromContentsAsync(IResultList <IEnrichedContentEntity> contents, Context context, ApiController controller, ISchemaEntity?schema, IContentWorkflow workflow) { var result = new ContentsDto { Total = contents.Total, Items = contents.Select(x => ContentDto.FromContent(context, x, controller)).ToArray() }; if (schema != null) { await result.AssignStatusesAsync(workflow, schema); result.CreateLinks(controller, schema.AppId.Name, schema.SchemaDef.Name); } return(result); }
private JsonSchema BuildJsonSchema(Context context, ISchemaEntity?schema, ResolvedComponents components) { if (schema == null) { return(genericJsonSchema); } var cacheKey = BuildJsonCacheKey(context.App, schema, context.IsFrontendClient); var result = cache.GetOrCreate(cacheKey, entry => { entry.AbsoluteExpirationRelativeToNow = CacheTime; return(BuildJsonSchema(schema.SchemaDef, context.App, components, context.IsFrontendClient)); }); return(result); }
private ClrQuery ParseQuery(Context context, Q q, ISchemaEntity?schema) { var query = q.Query; if (!string.IsNullOrWhiteSpace(q.JsonQueryString)) { query = ParseJson(context, schema, q.JsonQueryString); } else if (q?.JsonQuery != null) { query = ParseJson(context, schema, q.JsonQuery); } else if (!string.IsNullOrWhiteSpace(q?.ODataQuery)) { query = ParseOData(context, schema, q.ODataQuery); } return(query); }
public virtual async Task <Q> ParseAsync(Context context, Q q, ISchemaEntity?schema = null) { Guard.NotNull(context, nameof(context)); Guard.NotNull(q, nameof(q)); using (Profiler.TraceMethod <ContentQueryParser>()) { var query = ParseQuery(context, q, schema); await TransformFilterAsync(query, context, schema); WithSorting(query); WithPaging(query); q = q !.WithQuery(query); return(q); } }
public async Task <ISchemaEntity> GetSchemaOrThrowAsync(Context context, string schemaIdOrName) { ISchemaEntity?schema = null; if (Guid.TryParse(schemaIdOrName, out var id)) { schema = await appProvider.GetSchemaAsync(context.App.Id, id); } if (schema == null) { schema = await appProvider.GetSchemaAsync(context.App.Id, schemaIdOrName); } if (schema == null) { throw new DomainObjectNotFoundException(schemaIdOrName, typeof(ISchemaEntity)); } return(schema); }
private async Task TransformFilterAsync(ClrQuery query, Context context, ISchemaEntity?schema) { if (query.Filter != null && schema != null) { query.Filter = await GeoQueryTransformer.TransformAsync(query.Filter, context, schema, textIndex); } if (!string.IsNullOrWhiteSpace(query.FullText)) { if (schema == null) { throw new InvalidOperationException(); } var textQuery = new TextQuery(query.FullText, 1000) { PreferredSchemaId = schema.Id }; var fullTextIds = await textIndex.SearchAsync(context.App, textQuery, context.Scope()); var fullTextFilter = ClrFilter.Eq("id", "__notfound__"); if (fullTextIds?.Any() == true) { fullTextFilter = ClrFilter.In("id", fullTextIds.Select(x => x.ToString()).ToList()); } if (query.Filter != null) { query.Filter = ClrFilter.And(query.Filter, fullTextFilter); } else { query.Filter = fullTextFilter; } query.FullText = null; } }
public virtual async Task <Q> ParseAsync(Context context, Q q, ISchemaEntity?schema = null) { Guard.NotNull(context, nameof(context)); Guard.NotNull(q, nameof(q)); using (Telemetry.Activities.StartActivity("ContentQueryParser/ParseAsync")) { var query = await ParseClrQueryAsync(context, q, schema); await TransformFilterAsync(query, context, schema); WithSorting(query); WithPaging(query, q); q = q.WithQuery(query); if (context.ShouldSkipTotal()) { q = q.WithoutTotal(); } return(q); } }
public async Task <List <(IContentEntity Content, ISchemaEntity Schema)> > DoAsync(Guid appId, ISchemaEntity?schema, HashSet <Guid> ids, Status[]?status, bool includeDraft) { Guard.NotNull(ids); var find = Collection.Find(CreateFilter(appId, ids, status)).WithoutDraft(includeDraft); var contentItems = await find.ToListAsync(); var contentSchemas = await GetSchemasAsync(appId, schema, contentItems); var result = new List <(IContentEntity Content, ISchemaEntity Schema)>(); foreach (var contentEntity in contentItems) { if (contentEntity.HasStatus(status) && contentSchemas.TryGetValue(contentEntity.IndexedSchemaId, out var contentSchema)) { contentEntity.ParseData(contentSchema.SchemaDef, serializer); result.Add((contentEntity, contentSchema)); } } return(result); }
public async Task <List <(IContentEntity Content, ISchemaEntity Schema)> > DoAsync(DomainId appId, ISchemaEntity?schema, HashSet <DomainId> ids, bool canCache) { Guard.NotNull(ids, nameof(ids)); var find = Collection.Find(CreateFilter(appId, ids)); var contentItems = await find.ToListAsync(); var contentSchemas = await GetSchemasAsync(appId, schema, contentItems, canCache); var result = new List <(IContentEntity Content, ISchemaEntity Schema)>(); foreach (var contentEntity in contentItems) { if (contentSchemas.TryGetValue(contentEntity.IndexedSchemaId, out var contentSchema)) { contentEntity.ParseData(contentSchema.SchemaDef, converter); result.Add((contentEntity, contentSchema)); } } return(result); }
private async Task <IDictionary <DomainId, ISchemaEntity> > GetSchemasAsync(DomainId appId, ISchemaEntity?schema, List <MongoContentEntity> contentItems, bool canCache) { var schemas = new Dictionary <DomainId, ISchemaEntity>(); if (schema != null) { schemas[schema.Id] = schema; } var schemaIds = contentItems.Select(x => x.IndexedSchemaId).Distinct(); foreach (var schemaId in schemaIds) { if (!schemas.ContainsKey(schemaId)) { var found = await appProvider.GetSchemaAsync(appId, schemaId, false, canCache); if (found != null) { schemas[schemaId] = found; } } } return(schemas); }
private ClrQuery ParseJson(Context context, ISchemaEntity?schema, Query <IJsonValue> query) { var jsonSchema = BuildJsonSchema(context, schema); return(jsonSchema.Convert(query)); }
private ClrQuery ParseJson(Context context, ISchemaEntity?schema, string json) { var jsonSchema = BuildJsonSchema(context, schema); return(jsonSchema.Parse(json, jsonSerializer)); }