protected virtual async Task <TReadModel> DeleteCommand(TKey id, CancellationToken cancellationToken = default(CancellationToken))
{
var command = new EntityDeleteCommand <TKey, TReadModel>(id, User);
var result = await Mediator.Send(command, cancellationToken).ConfigureAwait(false);
return(result);
}
protected override async Task <TReadModel> Process(EntityDeleteCommand <TKey, TReadModel> request, CancellationToken cancellationToken)
{
var dbSet = DataContext
.Set <TEntity>();
var keyValue = new object[] { request.Id };
var entity = await dbSet
.FindAsync(keyValue, cancellationToken)
.ConfigureAwait(false);
if (entity == null)
{
return(default(TReadModel));
}
// entity supports soft delete
if (entity is ITrackDeleted deleteEntity)
{
deleteEntity.IsDeleted = true;
}
else
{
dbSet.Remove(entity);
}
await DataContext
.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
// convert deleted entity to read model
var model = Mapper.Map <TReadModel>(entity);
return(model);
}
protected override async Task <TReadModel> ProcessAsync(EntityDeleteCommand <TKey, TEntity, TReadModel> message, CancellationToken cancellationToken)
{
var dbSet = _context
.Set <TEntity>();
var keyValue = new object[] { message.Id };
var entity = await dbSet
.FindAsync(keyValue, cancellationToken)
.ConfigureAwait(false);
if (entity == null)
{
return(default(TReadModel));
}
dbSet.Remove(entity);
await _context
.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
// convert deleted entity to read model
var model = _mapper.Map <TReadModel>(entity);
return(model);
}
protected virtual async Task <TReadModel> DeleteCommand(TKey id, CancellationToken cancellationToken = default)
{
var command = new EntityDeleteCommand <TKey, TReadModel>(User, id);
var result = await Mediator.Send(command, cancellationToken);
return(result);
}
public async Task <IActionResult> OnPostDeleteEntity()
{
var command = new EntityDeleteCommand <Guid, TopicReadModel>(User, Id);
var result = await Mediator.Send(command);
ShowAlert("Successfully deleted topic");
return(RedirectToPage("/Topic/Index", new { tenant = TenantRoute }));
}
public async Task <IActionResult> OnPostDeleteInstructorSignUp(Guid topicInstructorId)
{
var command = new EntityDeleteCommand <Guid, TopicInstructorReadModel>(User, topicInstructorId);
var result = await Mediator.Send(command);
ShowAlert("Successfully deleted instructor signup");
return(RedirectToPage("/signup/View", new { id = Id, tenant = TenantRoute }));
}
public async Task <IActionResult> OnPostDeleteEntity()
{
var command = new EntityDeleteCommand <Guid, TenantReadModel>(User, Id);
var result = await Mediator.Send(command);
ShowAlert("Successfully deleted tenant");
return(RedirectToPage("/Global/Tenant/Index"));
}
public async Task <IActionResult> OnPostDeleteEntity()
{
var command = new EntityDeleteCommand <Guid, DiscussionReadModel>(User, Id);
var result = await Mediator.Send(command);
ShowAlert("Successfully deleted discussion message");
return(RedirectToPage("/Topic/Discussion/View", new { Id = TopicId, tenant = TenantRoute }));
}
public void ConstructorWithId()
{
var id = Guid.NewGuid();
var deleteCommand = new EntityDeleteCommand <Guid, LocationReadModel>(MockPrincipal.Default, id);
deleteCommand.Should().NotBeNull();
deleteCommand.Id.Should().NotBe(Guid.Empty);
deleteCommand.Id.Should().Be(id);
deleteCommand.Principal.Should().NotBeNull();
}
public void TestInitialize()
{
notificationProviderMock = new NotificationProviderMock();
NotificationMessageProvider.Initialize(notificationProviderMock, 1000000);
mock = new ApiConnectorMock();
dialogProviderMock = new DialogProviderMock();
deleteCommand = new EntityDeleteCommand <Card>(mock)
{
Entity = card
};
ModalDialogManager.Initialize(dialogProviderMock);
}
private async Task SendNotification(PrincipalCommandBase <TResponse> request, TResponse response, CancellationToken cancellationToken)
{
var operation = request switch
{
EntityCreateCommand <TEntityModel, TResponse> _ => EntityChangeOperation.Created,
EntityDeleteCommand <TKey, TResponse> _ => EntityChangeOperation.Deleted,
_ => EntityChangeOperation.Updated
};
var notification = new EntityChangeNotification <TResponse>(response, operation);
await _mediator.Publish(notification, cancellationToken);
}
}
protected override async Task <TReadModel> Process(EntityDeleteCommand <TKey, TReadModel> request, CancellationToken cancellationToken)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
var entity = await Repository
.FindAsync(request.Id, cancellationToken)
.ConfigureAwait(false);
if (entity == null)
{
return(default !);
public async Task <IActionResult> OnPostDeleteEntity()
{
var command = new EntityDeleteCommand <Guid, AttendanceSessionModel>(User, Id);
var result = await Mediator.Send(command);
if (Route == "user")
{
return(RedirectToPage("/attendance/user", new { tenant = TenantRoute }));
}
if (Route == "topic")
{
return(RedirectToPage("/attendance/topic", new { tenant = TenantRoute }));
}
return(RedirectToPage("/attendance/session", new { id = SessionId, tenant = TenantRoute }));
}
protected override async Task <TReadModel> Process(EntityDeleteCommand <string, TReadModel> request, CancellationToken cancellationToken)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
if (!CosmosKey.TryDecode(request.Id, out var id, out var partitionKey))
{
throw new InvalidOperationException("Invalid Cosmos Key format");
}
var entity = await Repository
.FindAsync(id, partitionKey, cancellationToken)
.ConfigureAwait(false);
if (entity == null)
{
return(default !);
protected override async Task <TReadModel> Process(EntityDeleteCommand <TKey, TReadModel> request, CancellationToken cancellationToken)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
var dbSet = DataContext
.Set <TEntity>();
var keyValue = new object[] { request.Id };
var entity = await dbSet
.FindAsync(keyValue, cancellationToken)
.ConfigureAwait(false);
if (entity == null)
{
return(default !);
public async Task <IActionResult> Delete(CancellationToken cancellationToken, int id)
{
var returnResponse = new EntityResponseModel <ProductReadDto>();
try
{
var command = new EntityDeleteCommand <int, EntityResponseModel <ProductReadDto> >(id);
var result = await Mediator.Send(command, cancellationToken).ConfigureAwait(false);
if (result.ReturnStatus == false)
{
return(BadRequest(result));
}
return(Ok(result));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
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 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);
}
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);
}
protected override async Task <EntityResponseModel <TReadModel> > ProcessAsync(EntityDeleteCommand <TKey, EntityResponseModel <TReadModel> > request, CancellationToken cancellationToken)
{
var entityResponse = new EntityResponseModel <TReadModel>();
try
{
var dbSet = DataContext
.Set <TEntity>();
var keyValue = new object[] { request.Id };
var entity = dbSet.Where(p => Equals(p.Id, request.Id));
if (!string.IsNullOrEmpty(request.IncludeProperties))
{
entity = request.IncludeProperties.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Aggregate(entity, (current, includeProperty) =>
current.Include(includeProperty.Trim(new char[] { ' ', '\n', '\r' })));
}
var model = entity.FirstOrDefault();
if (model == null)
{
return(default);
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);
}
