protected virtual async Task <EntityPagedResult <TReadModel> > PagedQuery(EntityQuery entityQuery, CancellationToken cancellationToken = default) { var command = new EntityPagedQuery <TReadModel>(User, entityQuery); var result = await Mediator.Send(command, cancellationToken); return(result); }
protected override async Task <EntityPagedResult <TReadModel> > Process(EntityPagedQuery <TReadModel> request, CancellationToken cancellationToken) { var query = DataContext .Set <TEntity>() .AsNoTracking(); // build query from filter query = BuildQuery(request, query); // get total for query int total = await QueryTotal(request, query, cancellationToken) .ConfigureAwait(false); // short circuit if total is zero if (total == 0) { return new EntityPagedResult <TReadModel> { Data = new List <TReadModel>() } } ; // page the query and convert to read model var result = await QueryPaged(request, query, cancellationToken) .ConfigureAwait(false); return(new EntityPagedResult <TReadModel> { Total = total, Data = result }); }
public async Task EntityQueryIn() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); var identifiers = new List <string> { PriorityConstants.Normal.Id, PriorityConstants.High.Id }; // Query Entity var entityQuery = new EntityQuery { Sort = new List <EntitySort> { new EntitySort { Name = "Updated", Direction = "Descending" } }, Filter = new EntityFilter { Name = "Id", Operator = "in", Value = identifiers } }; var listQuery = new EntityPagedQuery <PriorityReadModel>(MockPrincipal.Default, entityQuery); var listResult = await mediator.Send(listQuery).ConfigureAwait(false); listResult.Should().NotBeNull(); listResult.Total.Should().Be(2); }
protected override async Task <EntityPagedResult <TReadModel> > Process(EntityPagedQuery <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); // get total for query int total = await QueryTotal(request, query, cancellationToken).ConfigureAwait(false); // short circuit if total is zero if (total == 0) { return new EntityPagedResult <TReadModel> { Data = new List <TReadModel>() } } ; // page the query and convert to read model var result = await QueryPaged(request, query, cancellationToken); return(new EntityPagedResult <TReadModel> { Total = total, Data = result }); }
protected virtual async Task <int> QueryTotal(EntityPagedQuery <TReadModel> request, IQueryable <TEntity> query, CancellationToken cancellationToken) { var mongoQuery = query as IMongoQueryable <TEntity>; return(mongoQuery != null ? await mongoQuery.CountAsync(cancellationToken).ConfigureAwait(false) : query.Count()); }
protected override async Task <EntityPagedResult <TEntityModel> > Process( EntityPagedQuery <TEntityModel> request, CancellationToken cancellationToken, RequestHandlerDelegate <EntityPagedResult <TEntityModel> > next) { // add tenant filter request.Query.Filter = await RewriteFilter(request.Query.Filter, request.Principal).ConfigureAwait(false); // continue pipeline return(await next().ConfigureAwait(false)); }
protected virtual async Task <IReadOnlyCollection <TReadModel> > QueryPaged(EntityPagedQuery <TReadModel> request, IQueryable <TEntity> query, CancellationToken cancellationToken) { var entityQuery = request.Query; return(await query .Sort(entityQuery.Sort) .Page(entityQuery.Page, entityQuery.PageSize) .ProjectTo <TReadModel>(Mapper.ConfigurationProvider) .ToListAsync(cancellationToken) .ConfigureAwait(false)); }
public virtual async Task <IActionResult> OnGetAsync() { var query = CreateQuery(); var command = new EntityPagedQuery <TEntity>(User, query); var result = await Mediator.Send(command); Total = result.Total; Items = result.Data; return(Page()); }
public void ConstructorWithParameters() { var entityFilter = new EntityFilter { Name = "rank", Value = 7 }; var entityQuery = new EntityQuery("name = 'blah'", 2, 10, "updated:desc"); entityQuery.Filter = entityFilter; var listQuery = new EntityPagedQuery <LocationReadModel>(MockPrincipal.Default, entityQuery); listQuery.Should().NotBeNull(); listQuery.Query.Should().NotBeNull(); listQuery.Principal.Should().NotBeNull(); }
protected override async Task <EntityPagedResult <TEntityModel> > Process(EntityPagedQuery <TEntityModel> request, CancellationToken cancellationToken, RequestHandlerDelegate <EntityPagedResult <TEntityModel> > next) { if (request is null) { throw new ArgumentNullException(nameof(request)); } if (next is null) { throw new ArgumentNullException(nameof(next)); } // add delete filter request.Query.Filter = RewriteFilter(request.Query?.Filter, request.Principal); // continue pipeline return(await next().ConfigureAwait(false)); }
protected virtual async Task <IReadOnlyCollection <TReadModel> > QueryPaged(EntityPagedQuery <TReadModel> request, IQueryable <TEntity> query, CancellationToken cancellationToken) { var entityQuery = request.Query; var queryable = query .Sort(entityQuery.Sort); if (entityQuery.Page > 0 && entityQuery.PageSize > 0) { queryable = queryable.Page(entityQuery.Page, entityQuery.PageSize); } var results = await queryable .ToListAsync(cancellationToken) .ConfigureAwait(false); return(Mapper.Map <IList <TEntity>, IReadOnlyCollection <TReadModel> >(results)); }
protected virtual IQueryable <TEntity> BuildQuery(EntityPagedQuery <TReadModel> request, IQueryable <TEntity> query) { var entityQuery = request.Query; // build query from filter if (entityQuery?.Filter != null) { query = query.Filter(entityQuery.Filter); } // add raw query if (!string.IsNullOrEmpty(entityQuery?.Query)) { query = query.Where(entityQuery.Query); } return(query); }
protected override async Task <EntityPagedResult <TReadModel> > ProcessAsync(EntityPagedQuery <EntityPagedResult <TReadModel> > request, CancellationToken cancellationToken) { var model = DataContext .Set <TEntity>() .AsNoTracking(); if (!string.IsNullOrEmpty(request.IncludeProperties)) { model = request.IncludeProperties.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries) .Aggregate(model, (current, includeProperty) => current.Include(includeProperty)); } // build query from filter model = BuildQuery(request, model); //get total for query var total = await QueryTotal(model, cancellationToken) .ConfigureAwait(false); //short circuit if total is zero if (total == 0) { return new EntityPagedResult <TReadModel> { Data = new List <TReadModel>() } } ; var data = model .Sort(request.Query.Sort) .Page(request.Query.Page, request.Query.PageSize).ToList(); // page the query and convert to read model var result = Mapper.Map <List <TReadModel> >(data); return(new EntityPagedResult <TReadModel> { Total = total, Data = result, Page = request.Query.Page, PageSize = request.Query.PageSize }); }
private IQueryable <TEntity> BuildQuery(EntityPagedQuery <EntityPagedResult <TReadModel> > request, IQueryable <TEntity> model) { var entityQuery = request.Query; //build query from filter if (entityQuery?.Filter != null) { model = model.Filter(entityQuery.Filter); } //add raw query if (entityQuery != null && !string.IsNullOrEmpty(entityQuery.Query)) { model = model.Where(entityQuery.Query); } return(model); }
public async Task QueryList() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var query = new EntityQuery { Sort = new[] { new EntitySort { Name = "Updated", Direction = "Descending" } }, Filter = new EntityFilter { Name = "Slug", Value = "TEST" } }; var command = new EntityPagedQuery <TenantReadModel>(MockPrincipal.Default, query); var result = await mediator.Send(command).ConfigureAwait(false); result.Should().NotBeNull(); }
public async Task EntityPageQuery() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); var filter = new EntityFilter { Name = "StatusId", Value = StatusConstants.NotStarted.Id }; var entityQuery = new EntityQuery { Filter = filter }; var pagedQuery = new EntityPagedQuery <TaskReadModel>(MockPrincipal.Default, entityQuery); var selectResult = await mediator.Send(pagedQuery).ConfigureAwait(false); selectResult.Should().NotBeNull(); }
public async Task QueryStartsWithList() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var query = new EntityQuery { Sort = new List <EntitySort> { new EntitySort { Name = "Updated", Direction = "Descending" } }, Filter = new EntityFilter { Name = "Name", Value = "Location", Operator = "StartsWith" } }; var command = new EntityPagedQuery <LocationReadModel>(MockPrincipal.Default, query); var result = await mediator.Send(command).ConfigureAwait(false); result.Should().NotBeNull(); }
public async Task FullTest() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); // Create Entity var createModel = Generator.Default.Single <TenantCreateModel>(); createModel.Slug = "Test" + DateTime.Now.Ticks; createModel.TimeZone = "Central Standard Time"; var createCommand = new EntityCreateCommand <TenantCreateModel, TenantReadModel>(MockPrincipal.Default, createModel); var createResult = await mediator.Send(createCommand).ConfigureAwait(false); createResult.Should().NotBeNull(); // Get Entity by Key var identifierQuery = new EntityIdentifierQuery <Guid, TenantReadModel>(MockPrincipal.Default, createResult.Id); var identifierResult = await mediator.Send(identifierQuery).ConfigureAwait(false); identifierResult.Should().NotBeNull(); identifierResult.Name.Should().Be(createModel.Name); // Query Entity var entityQuery = new EntityQuery { Sort = new[] { new EntitySort { Name = "Updated", Direction = "Descending" } }, Filter = new EntityFilter { Name = "Slug", Value = "TEST" } }; var listQuery = new EntityPagedQuery <TenantReadModel>(MockPrincipal.Default, entityQuery); var listResult = await mediator.Send(listQuery).ConfigureAwait(false); listResult.Should().NotBeNull(); // Patch Entity var patchModel = new JsonPatchDocument <Tenant>(); patchModel.Operations.Add(new Operation <Tenant> { op = "replace", path = "/Description", value = "Patch Update" }); var patchCommand = new EntityPatchCommand <Guid, TenantReadModel>(MockPrincipal.Default, createResult.Id, patchModel); var patchResult = await mediator.Send(patchCommand).ConfigureAwait(false); patchResult.Should().NotBeNull(); patchResult.Description.Should().Be("Patch Update"); // Update Entity var updateModel = mapper.Map <TenantUpdateModel>(patchResult); updateModel.Description = "Update Command"; var updateCommand = new EntityUpdateCommand <Guid, TenantUpdateModel, TenantReadModel>(MockPrincipal.Default, createResult.Id, updateModel); var updateResult = await mediator.Send(updateCommand).ConfigureAwait(false); updateResult.Should().NotBeNull(); updateResult.Description.Should().Be("Update Command"); // Delete Entity var deleteCommand = new EntityDeleteCommand <Guid, TenantReadModel>(MockPrincipal.Default, createResult.Id); var deleteResult = await mediator.Send(deleteCommand).ConfigureAwait(false); deleteResult.Should().NotBeNull(); deleteResult.Id.Should().Be(createResult.Id); }
public async Task FullTest() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); // Create Entity var createModel = Generator.Default.Single <TaskCreateModel>(); createModel.Id = ObjectId.GenerateNewId().ToString(); createModel.Title = "Testing"; createModel.Description = "Test " + DateTime.Now.Ticks; createModel.StatusId = StatusConstants.NotStarted.Id; createModel.TenantId = TenantConstants.Test.Id; var createCommand = new EntityCreateCommand <TaskCreateModel, TaskReadModel>(MockPrincipal.Default, createModel); var createResult = await mediator.Send(createCommand).ConfigureAwait(false); createResult.Should().NotBeNull(); // Get Entity by Key var key = createResult.Id; var identifierQuery = new EntityIdentifierQuery <string, TaskReadModel>(MockPrincipal.Default, key); var identifierResult = await mediator.Send(identifierQuery).ConfigureAwait(false); identifierResult.Should().NotBeNull(); identifierResult.Title.Should().Be(createModel.Title); // Query Entity var entityQuery = new EntityQuery { Sort = new List <EntitySort> { new EntitySort { Name = "Updated", Direction = "Descending" } }, Filter = new EntityFilter { Name = "StatusId", Value = StatusConstants.NotStarted.Id } }; var listQuery = new EntityPagedQuery <TaskReadModel>(MockPrincipal.Default, entityQuery); var listResult = await mediator.Send(listQuery).ConfigureAwait(false); listResult.Should().NotBeNull(); // Patch Entity var patchModel = new JsonPatchDocument <Task>(); patchModel.Operations.Add(new Operation <Task> { op = "replace", path = "/Title", value = "Patch Update" }); var patchCommand = new EntityPatchCommand <string, TaskReadModel>(MockPrincipal.Default, key, patchModel); var patchResult = await mediator.Send(patchCommand).ConfigureAwait(false); patchResult.Should().NotBeNull(); patchResult.Title.Should().Be("Patch Update"); // Update Entity var updateModel = mapper.Map <TaskUpdateModel>(patchResult); updateModel.Title = "Update Command"; var updateCommand = new EntityUpdateCommand <string, TaskUpdateModel, TaskReadModel>(MockPrincipal.Default, key, updateModel); var updateResult = await mediator.Send(updateCommand).ConfigureAwait(false); updateResult.Should().NotBeNull(); updateResult.Title.Should().Be("Update Command"); // Delete Entity var deleteCommand = new EntityDeleteCommand <string, TaskReadModel>(MockPrincipal.Default, key); var deleteResult = await mediator.Send(deleteCommand).ConfigureAwait(false); deleteResult.Should().NotBeNull(); deleteResult.Id.Should().Be(createResult.Id); }
public async Task FullTest() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); // Create Entity var createModel = Generator.Default.Single <InstructorCreateModel>(); createModel.TenantId = Data.Constants.Tenant.Test; createModel.DisplayName = $"{createModel.GivenName} {createModel.FamilyName}"; createModel.JobTitle = "TEST"; var createCommand = new EntityCreateCommand <InstructorCreateModel, InstructorReadModel>(MockPrincipal.Default, createModel); var createResult = await mediator.Send(createCommand).ConfigureAwait(false); createResult.Should().NotBeNull(); // Get Entity by Key var identifierQuery = new EntityIdentifierQuery <Guid, InstructorReadModel>(MockPrincipal.Default, createResult.Id); var identifierResult = await mediator.Send(identifierQuery).ConfigureAwait(false); identifierResult.Should().NotBeNull(); identifierResult.DisplayName.Should().Be(createModel.DisplayName); // Query Entity var entityQuery = new EntityQuery { Sort = new[] { new EntitySort { Name = "Updated", Direction = "Descending" } }, Filter = new EntityFilter { Name = "JobTitle", Value = "TEST" } }; var listQuery = new EntityPagedQuery <InstructorReadModel>(MockPrincipal.Default, entityQuery); var listResult = await mediator.Send(listQuery).ConfigureAwait(false); listResult.Should().NotBeNull(); // Patch Entity var patchModel = new JsonPatchDocument <Instructor>(); patchModel.Operations.Add(new Operation <Instructor> { op = "replace", path = "/DisplayName", value = "Patch Update" }); var patchCommand = new EntityPatchCommand <Guid, InstructorReadModel>(MockPrincipal.Default, createResult.Id, patchModel); var patchResult = await mediator.Send(patchCommand).ConfigureAwait(false); patchResult.Should().NotBeNull(); patchResult.DisplayName.Should().Be("Patch Update"); // Update Entity var updateModel = mapper.Map <InstructorUpdateModel>(patchResult); updateModel.DisplayName = "Update Command"; var updateCommand = new EntityUpdateCommand <Guid, InstructorUpdateModel, InstructorReadModel>(MockPrincipal.Default, createResult.Id, updateModel); var updateResult = await mediator.Send(updateCommand).ConfigureAwait(false); updateResult.Should().NotBeNull(); updateResult.DisplayName.Should().Be("Update Command"); // Delete Entity var deleteCommand = new EntityDeleteCommand <Guid, InstructorReadModel>(MockPrincipal.Default, createResult.Id); var deleteResult = await mediator.Send(deleteCommand).ConfigureAwait(false); deleteResult.Should().NotBeNull(); deleteResult.Id.Should().Be(createResult.Id); }
public async Task FullTest() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); // Create Entity var createModel = Generator.Default.Single <AuditCreateModel>(); createModel.Username = "******"; createModel.Content = "Test " + DateTime.Now.Ticks; var createCommand = new EntityCreateCommand <AuditCreateModel, AuditReadModel>(MockPrincipal.Default, createModel); var createResult = await mediator.Send(createCommand).ConfigureAwait(false); createResult.Should().NotBeNull(); // Get Entity by Key var key = CosmosKey.Encode(createResult.Id, createResult.Id); var identifierQuery = new EntityIdentifierQuery <string, AuditReadModel>(MockPrincipal.Default, key); var identifierResult = await mediator.Send(identifierQuery).ConfigureAwait(false); identifierResult.Should().NotBeNull(); identifierResult.Username.Should().Be(createModel.Username); // Query Entity var entityQuery = new EntityQuery { Sort = new List <EntitySort> { new EntitySort { Name = "Updated", Direction = "Descending" } }, Filter = new EntityFilter { Name = "Username", Value = "TEST" } }; var listQuery = new EntityPagedQuery <AuditReadModel>(MockPrincipal.Default, entityQuery); var listResult = await mediator.Send(listQuery).ConfigureAwait(false); listResult.Should().NotBeNull(); // Patch Entity var patchModel = new JsonPatchDocument <Audit>(); patchModel.Operations.Add(new Operation <Audit> { op = "replace", path = "/Content", value = "Patch Update" }); var patchCommand = new EntityPatchCommand <string, AuditReadModel>(MockPrincipal.Default, key, patchModel); var patchResult = await mediator.Send(patchCommand).ConfigureAwait(false); patchResult.Should().NotBeNull(); patchResult.Content.Should().Be("Patch Update"); // Update Entity var updateModel = mapper.Map <AuditUpdateModel>(patchResult); updateModel.Content = "Update Command"; var updateCommand = new EntityUpdateCommand <string, AuditUpdateModel, AuditReadModel>(MockPrincipal.Default, key, updateModel); var updateResult = await mediator.Send(updateCommand).ConfigureAwait(false); updateResult.Should().NotBeNull(); updateResult.Content.Should().Be("Update Command"); // Delete Entity var deleteCommand = new EntityDeleteCommand <string, AuditReadModel>(MockPrincipal.Default, key); var deleteResult = await mediator.Send(deleteCommand).ConfigureAwait(false); deleteResult.Should().NotBeNull(); deleteResult.Id.Should().Be(createResult.Id); }
protected virtual async Task <int> QueryTotal(EntityPagedQuery <TReadModel> request, IQueryable <TEntity> query, CancellationToken cancellationToken) { return(await query .CountAsync(cancellationToken) .ConfigureAwait(false)); }
public void ConstructorNull() { var listQuery = new EntityPagedQuery <LocationReadModel>(null, null); listQuery.Should().NotBeNull(); }
public async Task FullTest() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var createModel = new LocationCreateModel { Name = "Location " + DateTime.Now.Ticks, Description = "Created from Unit Test", TenantId = Data.Constants.Tenant.Test }; var createCommand = new EntityCreateCommand <LocationCreateModel, LocationReadModel>(MockPrincipal.Default, createModel); var createResult = await mediator.Send(createCommand).ConfigureAwait(false); createResult.Should().NotBeNull(); var identifierQuery = new EntityIdentifierQuery <Guid, LocationReadModel>(MockPrincipal.Default, createResult.Id); var identifierResult = await mediator.Send(identifierQuery).ConfigureAwait(false); identifierResult.Should().NotBeNull(); identifierResult.Name.Should().Be(createModel.Name); var entityQuery = new EntityQuery { Sort = new List <EntitySort> { new EntitySort { Name = "Updated", Direction = "Descending" } }, Filter = new EntityFilter { Name = "Name", Value = "Location", Operator = "StartsWith" } }; var listQuery = new EntityPagedQuery <LocationReadModel>(MockPrincipal.Default, entityQuery); var listResult = await mediator.Send(listQuery).ConfigureAwait(false); listResult.Should().NotBeNull(); var patchModel = new JsonPatchDocument <Location>(); patchModel.Operations.Add(new Operation <Location> { op = "replace", path = "/Description", value = "Patch Update" }); var patchCommand = new EntityPatchCommand <Guid, LocationReadModel>(MockPrincipal.Default, createResult.Id, patchModel); var patchResult = await mediator.Send(patchCommand).ConfigureAwait(false); patchResult.Should().NotBeNull(); patchResult.Description.Should().Be("Patch Update"); var updateModel = new LocationUpdateModel { Name = patchResult.Name, Description = "Update Command", TenantId = patchResult.TenantId, RowVersion = patchResult.RowVersion }; var updateCommand = new EntityUpdateCommand <Guid, LocationUpdateModel, LocationReadModel>(MockPrincipal.Default, createResult.Id, updateModel); var updateResult = await mediator.Send(updateCommand).ConfigureAwait(false); updateResult.Should().NotBeNull(); updateResult.Description.Should().Be("Update Command"); var deleteCommand = new EntityDeleteCommand <Guid, LocationReadModel>(MockPrincipal.Default, createResult.Id); var deleteResult = await mediator.Send(deleteCommand).ConfigureAwait(false); deleteResult.Should().NotBeNull(); deleteResult.Id.Should().Be(createResult.Id); }