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