protected virtual IQueryable <TEntity> BuildQuery(EntitySelectQuery <TReadModel> request, IQueryable <TEntity> query) { if (request is null) { throw new ArgumentNullException(nameof(request)); } if (query is null) { throw new ArgumentNullException(nameof(query)); } var entitySelect = request?.Select; // build query from filter if (entitySelect?.Filter != null) { query = query.Filter(entitySelect.Filter); } // add raw query if (!string.IsNullOrEmpty(entitySelect?.Query)) { query = query.Where(entitySelect.Query); } return(query); }
public async Task <ActionResult <IReadOnlyCollection <TemplateEditorModel> > > Get(CancellationToken cancellationToken) { var command = new EntitySelectQuery <TemplateEditorModel>(User, new EntitySelect()); var result = await Mediator.Send(command, cancellationToken); return(Ok(result)); }
public async Task <IActionResult> OnGetAsync() { var select = new EntitySelect(); select.Filter = CreateFilter(); select.Sort = new List <EntitySort> { new EntitySort { Name = nameof(TopicListModel.CalendarYear) }, new EntitySort { Name = nameof(TopicListModel.TargetMonth) }, new EntitySort { Name = nameof(TopicListModel.Title) } }; var query = new EntitySelectQuery <TopicListModel>(User, select); var topics = await Mediator.Send(query); var fileName = $"Topics-{DateTime.Now:yyyy-MM-dd-HH-mm-ss}.csv"; return(Export(topics, fileName)); }
protected virtual async Task <IReadOnlyCollection <TReadModel> > SelectQuery(EntitySelect entitySelect, CancellationToken cancellationToken = default) { var command = new EntitySelectQuery <TReadModel>(User, entitySelect); var result = await Mediator.Send(command, cancellationToken); return(result); }
public async Task EntitySelectQueryDeleteNested() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); var filter = new EntityFilter { Filters = new List <EntityFilter> { new EntityFilter { Name = "IsDeleted", Value = true }, new EntityFilter { Name = "StatusId", Value = StatusConstants.NotStarted.Id } } }; var select = new EntitySelect(filter); var selectQuery = new EntitySelectQuery <TaskReadModel>(MockPrincipal.Default, select); var selectResult = await mediator.Send(selectQuery).ConfigureAwait(false); selectResult.Should().NotBeNull(); }
protected virtual IReadOnlyCollection <TReadModel> QueryList(EntitySelectQuery <TReadModel> request, IQueryable <TEntity> query, CancellationToken cancellationToken) { var results = query .Sort(request?.Select?.Sort) .ToList(); return(Mapper.Map <IList <TEntity>, IReadOnlyCollection <TReadModel> >(results)); }
protected virtual async Task <IReadOnlyCollection <TReadModel> > QueryList(EntitySelectQuery <TReadModel> request, IQueryable <TEntity> query, CancellationToken cancellationToken) { return(await query .Sort(request?.Select?.Sort) .ProjectTo <TReadModel>(Mapper.ConfigurationProvider) .ToListAsync(cancellationToken) .ConfigureAwait(false)); }
private async Task LoadRoles() { var command = new EntitySelectQuery <RoleReadModel>(User, new EntitySelect()); var roles = await Mediator.Send(command); Roles = roles .OrderBy(m => m.Name) .ToList(); }
protected virtual IQueryable <TEntity> BuildQuery(EntitySelectQuery <TReadModel> request, IQueryable <TEntity> query) { // build query from filter if (request?.Select?.Filter != null) { query = query.Filter(request.Select.Filter); } return(query); }
protected override async Task <IReadOnlyCollection <TEntityModel> > Process( EntitySelectQuery <TEntityModel> request, CancellationToken cancellationToken, RequestHandlerDelegate <IReadOnlyCollection <TEntityModel> > next) { // add tenant filter request.Filter = await RewriteFilter(request.Filter, request.Principal).ConfigureAwait(false); // continue pipeline return(await next().ConfigureAwait(false)); }
protected virtual async Task <IReadOnlyCollection <TReadModel> > QueryList(EntitySelectQuery <TReadModel> request, IQueryable <TEntity> query, CancellationToken cancellationToken) { if (request is null) { throw new ArgumentNullException(nameof(request)); } var results = await query .Sort(request.Select?.Sort) .ToListAsync(cancellationToken) .ConfigureAwait(false); return(Mapper.Map <IList <TEntity>, IReadOnlyCollection <TReadModel> >(results)); }
private async Task LoadAttendances() { var filter = new EntityFilter { Operator = EntityFilterOperators.Equal, Name = nameof(AttendanceSessionModel.SessionId), Value = Id }; var select = new EntitySelect(filter); var command = new EntitySelectQuery <AttendanceSessionModel>(User, select); var results = await Mediator.Send(command); Attendances = results.ToList(); }
protected override async Task <IReadOnlyCollection <TReadModel> > Process(EntitySelectQuery <TReadModel> request, CancellationToken cancellationToken) { var query = DataContext .Set <TEntity>() .AsNoTracking(); // build query from filter query = BuildQuery(request, query); // page the query and convert to read model var result = await QueryList(request, query, cancellationToken) .ConfigureAwait(false); return(result); }
public static TObject GetModel <TObject>(TObject workingObject, EntitySelectQuery selectQuery) where TObject : class, IEntityObject, IEntityObject <TObject> { using (var context = new ModelsDbContext()) { context.Configuration.ProxyCreationEnabled = false; try { return(EntitySelectQuery.GetQueryable(workingObject, selectQuery, context).FirstOrDefault()); } catch (Exception ex) { throw new Exception("Failed To Get Object From Db", ex); } } }
private async Task <List <SignUpTopicReadModel> > LoadSignUpTopics() { var filter = new EntityFilter { Name = nameof(SignUpTopicReadModel.SignUpId), Value = Id, Operator = EntityFilterOperators.Equal }; var select = new EntitySelect(filter); var command = new EntitySelectQuery <SignUpTopicReadModel>(User, select); var result = await Mediator.Send(command); return(result .OrderBy(p => p.TopicCalendarYear) .ThenBy(p => p.TopicTargetMonth) .ThenBy(p => p.TopicTitle) .ToList()); }
protected virtual IQueryable <TEntity> BuildQuery(EntitySelectQuery <TReadModel> request, IQueryable <TEntity> query) { var entitySelect = request?.Select; // build query from filter if (entitySelect?.Filter != null) { query = query.Filter(entitySelect.Filter); } // add raw query if (!string.IsNullOrEmpty(entitySelect?.Query)) { query = query.Where(entitySelect.Query); } return(query); }
protected override Task <IReadOnlyCollection <TReadModel> > Process(EntitySelectQuery <TReadModel> request, CancellationToken cancellationToken) { if (request is null) { throw new ArgumentNullException(nameof(request)); } var query = Repository.All(); // build query from filter query = BuildQuery(request, query); // page the query and convert to read model var result = QueryList(request, query, cancellationToken); //TODO make async? return(Task.FromResult(result)); }
protected override async Task <IReadOnlyCollection <TEntityModel> > Process(EntitySelectQuery <TEntityModel> request, CancellationToken cancellationToken, RequestHandlerDelegate <IReadOnlyCollection <TEntityModel> > next) { if (request is null) { throw new ArgumentNullException(nameof(request)); } if (next is null) { throw new ArgumentNullException(nameof(next)); } // add delete filter request.Select.Filter = RewriteFilter(request.Select?.Filter, request.Principal); // continue pipeline return(await next().ConfigureAwait(false)); }
private async Task <IReadOnlyCollection <TopicReadModel> > LoadTopics() { var filter = new EntityFilter { Name = nameof(TopicReadModel.CalendarYear), Value = DateTime.Now.Year, Operator = EntityFilterOperators.GreaterThanOrEqual }; var select = new EntitySelect(filter); var command = new EntitySelectQuery <TopicReadModel>(User, select); var result = await Mediator.Send(command); return(result .OrderBy(p => p.CalendarYear) .ThenBy(p => p.TargetMonth) .ThenBy(p => p.Title) .ToList()); }
public static EList <TObject> GetModels <TObject>(TObject workingObject, EntitySelectQuery selectQuery) where TObject : class, IEntityObject, IEntityObject <TObject> { using (var context = new ModelsDbContext()) { context.Configuration.ProxyCreationEnabled = false; try { var query = EntitySelectQuery.GetQueryable(workingObject, selectQuery, context); var eList = new EList <TObject>(); eList.AddRange(query.ToList()); return(eList); } catch (Exception ex) { throw new Exception("Failed To Get Object From Db", ex); } } }
protected override async Task <IReadOnlyCollection <TReadModel> > Process(EntitySelectQuery <TReadModel> request, CancellationToken cancellationToken) { if (request is null) { throw new ArgumentNullException(nameof(request)); } var cosmosQuery = await Repository .GetQueryableAsync() .ConfigureAwait(false); // build query from filter var query = BuildQuery(request, cosmosQuery); // page the query and convert to read model var result = await QueryList(request, query, cancellationToken).ConfigureAwait(false); return(result); }
private async Task <IReadOnlyCollection <TopicDropdownModel> > LoadTopics() { var select = new EntitySelect(); if (Year.HasValue) { var filter = new EntityFilter(); filter.Name = nameof(Core.Data.Entities.Topic.CalendarYear); filter.Value = Year.Value; select.Filter = filter; } var query = new EntitySelectQuery <TopicDropdownModel>(User, select); var topics = await Mediator.Send(query); return(topics .OrderBy(p => p.Text) .ToList()); }