public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var createModel = new AttendanceCreateModel();
// only update input fields
await TryUpdateModelAsync(
createModel,
nameof(Attendance),
p => p.SessionId,
p => p.TenantId,
p => p.Signature,
p => p.SignatureType,
p => p.AttendeeEmail,
p => p.AttendeeName
);
createModel.Attended = DateTimeOffset.UtcNow;
var command = new EntityCreateCommand <AttendanceCreateModel, AttendanceReadModel>(User, createModel);
var result = await Mediator.Send(command);
return(RedirectToPage("/attendance/session", new { id = result.SessionId, tenant = TenantRoute }));
}
public async Task TenantSetDefault()
{
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 = null;
var createCommand = new EntityCreateCommand <TaskCreateModel, TaskReadModel>(MockPrincipal.Default, createModel);
var createResult = await mediator.Send(createCommand).ConfigureAwait(false);
createResult.Should().NotBeNull();
createResult.TenantId.Should().Be(TenantConstants.Test.Id);
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var createModel = new TopicCreateModel();
// only update input fields
await TryUpdateModelAsync(
createModel,
nameof(Entity),
p => p.Title,
p => p.Description,
p => p.CalendarYear,
p => p.TargetMonth,
p => p.IsRequired
);
// update summary
if (createModel.Description.HasValue())
{
createModel.Summary = _htmlService.PlainText(createModel.Description).RemoveExtended().Truncate(256);
}
var command = new EntityCreateCommand <TopicCreateModel, TopicReadModel>(User, createModel);
var result = await Mediator.Send(command);
ShowAlert("Successfully created topic");
return(RedirectToPage("/Topic/Edit", new { id = result.Id, tenant = TenantRoute }));
}
protected override async Task <TReadModel> Process(EntityCreateCommand <TCreateModel, TReadModel> request, CancellationToken cancellationToken)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
// create new entity from model
var entity = Mapper.Map <TEntity>(request.Model);
// apply create metadata
if (entity is ITrackCreated createdModel)
{
createdModel.Created = request.Activated;
createdModel.CreatedBy = request.ActivatedBy;
}
// apply update metadata
if (entity is ITrackUpdated updateEntity)
{
updateEntity.Updated = request.Activated;
updateEntity.UpdatedBy = request.ActivatedBy;
}
var result = await Repository
.InsertAsync(entity, cancellationToken)
.ConfigureAwait(false);
// convert to read model
return(Mapper.Map <TReadModel>(result));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var createModel = new SessionCreateModel
{
TopicId = TopicId
};
// only update input fields
await TryUpdateModelAsync(
createModel,
nameof(Entity),
p => p.Note,
p => p.StartDate,
p => p.StartTime,
p => p.EndDate,
p => p.EndTime,
p => p.LocationId,
p => p.GroupId,
p => p.LeadInstructorId
);
var command = new EntityCreateCommand <SessionCreateModel, SessionReadModel>(User, createModel);
var result = await Mediator.Send(command);
ShowAlert("Successfully created topic session");
return(RedirectToPage("/Topic/Session/Edit", new { result.Id, TopicId, tenant = TenantRoute }));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var createModel = new GroupCreateModel();
// only update input fields
await TryUpdateModelAsync(
createModel,
nameof(Entity),
p => p.Name,
p => p.Description,
p => p.Sequence
);
var command = new EntityCreateCommand <GroupCreateModel, GroupReadModel>(User, createModel);
var result = await Mediator.Send(command);
ShowAlert("Successfully created group");
return(RedirectToPage("/Group/Edit", new { id = result.Id, tenant = TenantRoute }));
}
protected virtual async Task <TReadModel> CreateCommand(TCreateModel createModel, CancellationToken cancellationToken = default)
{
var command = new EntityCreateCommand <TCreateModel, TReadModel>(User, createModel);
var result = await Mediator.Send(command, cancellationToken);
return(result);
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var createModel = new DiscussionCreateModel
{
TopicId = Id,
TenantId = Tenant.Value.Id,
DisplayName = _userClaimManager.GetDisplayName(User),
EmailAddress = _userClaimManager.GetUserName(User),
MessageDate = DateTimeOffset.UtcNow,
Message = Message
};
var userAgent = Request.ReadUserAgent();
_mapper.Map(userAgent, createModel);
var command = new EntityCreateCommand <DiscussionCreateModel, DiscussionReadModel>(User, createModel);
var result = await Mediator.Send(command);
return(RedirectToPage("/topic/discussion/view", new { id = Id, tenant = TenantRoute }));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var createModel = new TenantCreateModel();
// only update input fields
await TryUpdateModelAsync(
createModel,
nameof(Entity),
p => p.Name,
p => p.Description,
p => p.Slug,
p => p.City,
p => p.StateProvince,
p => p.TimeZone,
p => p.DomainName
);
var command = new EntityCreateCommand <TenantCreateModel, TenantReadModel>(User, createModel);
var result = await Mediator.Send(command);
ShowAlert("Successfully created tenant");
return(RedirectToPage("/Global/Tenant/Edit", new { id = result.Id }));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var createModel = new InstructorCreateModel();
// only update input fields
await TryUpdateModelAsync(
createModel,
nameof(Entity),
p => p.GivenName,
p => p.FamilyName,
p => p.DisplayName,
p => p.JobTitle,
p => p.EmailAddress,
p => p.MobilePhone,
p => p.BusinessPhone
);
var command = new EntityCreateCommand <InstructorCreateModel, InstructorReadModel>(User, createModel);
var result = await Mediator.Send(command);
ShowAlert("Successfully created instructor");
return(RedirectToPage("/Instructor/Edit", new { id = result.Id, tenant = TenantRoute }));
}
public async Task CreateLocation()
{
var createModel = Generator.Default.Single <LocationCreateModel>();
createModel.Should().NotBeNull();
var createCommand = new EntityCreateCommand <LocationCreateModel, LocationReadModel>(MockPrincipal.Default, createModel);
createCommand.Should().NotBeNull();
createCommand.Model.Should().NotBeNull();
createCommand.Principal.Should().NotBeNull();
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <LocationCreateModel, Location>();
cfg.CreateMap <LocationUpdateModel, Location>();
cfg.CreateMap <Location, LocationReadModel>();
});
var mapper = new Mapper(config);
var options = new DbContextOptionsBuilder <SampleContext>()
.UseInMemoryDatabase(databaseName: "CreateLocation")
.Options;
var context = new SampleContext(options);
var createHandler = new EntityCreateCommandHandler <SampleContext, Location, Guid, LocationCreateModel, LocationReadModel>(NullLoggerFactory.Instance, context, mapper);
var readModel = await createHandler.Handle(createCommand, CancellationToken.None);
readModel.Should().NotBeNull();
readModel.Id.Should().NotBe(Guid.Empty);
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var createModel = new LocationCreateModel();
// only update input fields
await TryUpdateModelAsync(
createModel,
nameof(Entity),
p => p.Name,
p => p.Description,
p => p.AddressLine1,
p => p.City,
p => p.StateProvince,
p => p.PostalCode
);
var command = new EntityCreateCommand <LocationCreateModel, LocationReadModel>(User, createModel);
var result = await Mediator.Send(command);
ShowAlert("Successfully created location");
return(RedirectToPage("/Location/Edit", new { id = result.Id, tenant = TenantRoute }));
}
private async Task <PaymentReadModel> PaymentTransaction(Guid attendeeId, Guid oldCourse,
Guid newCourse, CancellationToken cancellationToken)
{
var search = Query <Data.Entities.PaymentTransaction> .Create(x => x.UserProfileId == attendeeId);
search = search.And(Query <Data.Entities.PaymentTransaction> .Create(x => x.CourseId == oldCourse));
var query = new SingleQuery <Data.Entities.PaymentTransaction>(search);
var command = new EntitySingleQuery <Data.Entities.PaymentTransaction,
PaymentReadModel>(query);
var result = await _mediator.Send(command, cancellationToken).ConfigureAwait(false);
var map = _mapper.Map <PaymentUpdateModel>(result.Data);
map.CourseId = newCourse;
var updatecommand = new EntityUpdateCommand <Guid, PaymentTransaction, PaymentUpdateModel, PaymentReadModel>(result.Data.Id, map, null);
var output = await _mediator.Send(updatecommand, cancellationToken).ConfigureAwait(false);
var historymap = _mapper.Map <PaymentHistoryCreateModel>(result.Data);
var createcommand = new EntityCreateCommand <Data.Entities.PaymentTransactionHistory, PaymentHistoryCreateModel, PaymentHistoryReadModel>(historymap, null);
await _mediator.Send(createcommand, cancellationToken).ConfigureAwait(false);
return(output);
}
private async Task <TrainingBuildCoursesAttendeeReadModel> ReAssignedToCourse(TrainingBuildCoursesAttendeeUpdateModel model, CancellationToken cancellationToken)
{
var map = _mapper.Map <TrainingBuildCoursesAttendeeCreatedModel>(model);
var command = new EntityCreateCommand <Data.Entities.TrainingBuildCourseAttendee, TrainingBuildCoursesAttendeeCreatedModel, TrainingBuildCoursesAttendeeReadModel>(map, null);
return(await _mediator.Send(command, cancellationToken).ConfigureAwait(false));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var createModel = new TopicCreateModel();
// only update input fields
await TryUpdateModelAsync(
createModel,
nameof(Entity),
p => p.Title,
p => p.Description,
p => p.CalendarYear
);
var command = new EntityCreateCommand <TopicCreateModel, TopicReadModel>(User, createModel);
var result = await Mediator.Send(command);
ShowAlert("Successfully created topic");
return(RedirectToPage("/Topic/Edit", new { id = result.Id, tenant = TenantRoute }));
}
protected virtual async Task <TReadModel> CreateCommand(TCreateModel createModel, CancellationToken cancellationToken = default(CancellationToken))
{
var command = new EntityCreateCommand <TEntity, TCreateModel, TReadModel>(createModel, User);
var result = await Mediator.Send(command, cancellationToken).ConfigureAwait(false);
return(result);
}
public void ConstructorWithModel()
{
var createModel = Generator.Default.Single <LocationCreateModel>();
createModel.Should().NotBeNull();
var createCommand = new EntityCreateCommand <LocationCreateModel, LocationReadModel>(MockPrincipal.Default, createModel);
createCommand.Should().NotBeNull();
createCommand.Model.Should().NotBeNull();
createCommand.Principal.Should().NotBeNull();
}
protected override async Task <PaymentReadModel> ProcessAsync(PaymentApprovalCommand <Guid, PaymentTransaction, PaymentReadModel> message, CancellationToken cancellationToken)
{
var command = new EntityIdentifierQuery <Guid, PaymentTransaction, PaymentReadModel>(message.Id, message.Principal);
var result = await Mediator.Send(command, cancellationToken).ConfigureAwait(false);
if (result == null)
{
throw new DomainException(422, $"Payment Id '{message.Id}' not found.");
}
if (result.Status != message.PaymentStatus)
{
var commandCourse = new EntityIdentifierQuery <Guid, TrainingCourse, CourseReadModel>(result.CourseId.Value, message.Principal);
var resultCourse = await Mediator.Send(commandCourse, cancellationToken).ConfigureAwait(false);
if (resultCourse == null)
{
throw new DomainException(422, $"Course Id '{result.CourseId}' not found.");
}
if (resultCourse.MaxAttendee == resultCourse.NoAttendee)
{
throw new DomainException(422, $"Course '{resultCourse.Title}' is already full.");
}
var mapCourse = _mapper.Map <CourseUpdateModel>(resultCourse);
mapCourse.MaxAttendee = mapCourse.MaxAttendee - 1;
mapCourse.NoAttendee = mapCourse.NoAttendee + 1;
var updateCourse = new EntityUpdateCommand <Guid, TrainingCourse, CourseUpdateModel, CourseReadModel>(resultCourse.Id, mapCourse, message.Principal);
var mediatorCourse = await Mediator.Send(updateCourse, cancellationToken)
.ConfigureAwait(false);
result.Status = message.PaymentStatus;
var map = _mapper.Map <PaymentUpdateModel>(result);
var update = new EntityUpdateCommand <Guid, PaymentTransaction, PaymentUpdateModel, PaymentReadModel>(message.Id, map, message.Principal);
result = await Mediator.Send(update, cancellationToken).ConfigureAwait(false);
var history = _mapper.Map <PaymentTransactionHistory>(result);
var dbSetHistory = _dataContext.Set <Data.Entities.PaymentTransactionHistory>();
await dbSetHistory.AddAsync(history, cancellationToken).ConfigureAwait(false);
await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
var mapAttendee = _mapper.Map <TrainingBuildCoursesAttendeeCreatedModel>(result);
var courseAttendee = new EntityCreateCommand <Core.Data.Entities.TrainingBuildCourseAttendee, TrainingBuildCoursesAttendeeCreatedModel, TrainingBuildCoursesAttendeeReadModel>(mapAttendee, message.Principal);
var resultCourseAttendee = await Mediator.Send(courseAttendee, cancellationToken).ConfigureAwait(false);
}
return(result);
}
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);
}
}
private async Task SendNotification(ImportJob importJob, string message, CancellationToken cancellationToken)
{
var createModel = new NotificationCreateModel
{
Created = DateTimeOffset.UtcNow,
CreatedBy = importJob.CreatedBy,
Updated = DateTimeOffset.UtcNow,
UpdatedBy = importJob.CreatedBy,
TenantId = importJob.TenantId,
UserName = importJob.CreatedBy,
Type = importJob.Type,
Message = message
};
var command = new EntityCreateCommand <NotificationCreateModel, NotificationReadModel>(null, createModel);
var result = await _mediator.Send(command, cancellationToken);
}
protected override async Task <TReadModel> Process(EntityCreateCommand <TCreateModel, TReadModel> request, CancellationToken cancellationToken)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
// create new entity from model
var entity = Mapper.Map <TEntity>(request.Model);
// apply create metadata
if (entity is ITrackCreated createdModel)
{
createdModel.Created = request.Activated;
createdModel.CreatedBy = request.ActivatedBy;
}
// apply update metadata
if (entity is ITrackUpdated updateEntity)
{
updateEntity.Updated = request.Activated;
updateEntity.UpdatedBy = request.ActivatedBy;
}
var dbSet = DataContext
.Set <TEntity>();
// add to data set, id should be generated
await dbSet
.AddAsync(entity, cancellationToken)
.ConfigureAwait(false);
// save to database
await DataContext
.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
// convert to read model
var readModel = await Read(entity.Id, cancellationToken)
.ConfigureAwait(false);
return(readModel);
}
public async Task CreateTenant()
{
var mediator = ServiceProvider.GetService <IMediator>();
mediator.Should().NotBeNull();
var createModel = new TenantCreateModel
{
Slug = "Test" + DateTime.Now.Ticks,
Name = "Test Department " + DateTime.Now.Ticks,
Description = "Created from Unit Test",
TimeZone = "Central Standard Time"
};
var command = new EntityCreateCommand <TenantCreateModel, TenantReadModel>(MockPrincipal.Default, createModel);
var result = await mediator.Send(command).ConfigureAwait(false);
result.Should().NotBeNull();
}
public async Task TenantDoesNotMatch()
{
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.Title = "Testing";
createModel.Description = "Test " + DateTime.Now.Ticks;
createModel.StatusId = StatusConstants.NotStarted.Id;
createModel.TenantId = Guid.NewGuid().ToString();
var createCommand = new EntityCreateCommand <TaskCreateModel, TaskReadModel>(MockPrincipal.Default, createModel);
await Assert.ThrowsAsync <DomainException>(() => mediator.Send(createCommand));
}
public async Task <IActionResult> Insert(CancellationToken cancellationToken,
ProductCreateDto model)
{
var returnResponse = new EntityResponseModel <ProductReadDto>();
try
{
var command = new EntityCreateCommand <ProductCreateDto, EntityResponseModel <ProductReadDto> >(model);
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));
}
}
protected override async Task <TReadModel> ProcessAsync(EntityCreateCommand <TEntity, TCreateModel, TReadModel> message, CancellationToken cancellationToken)
{
// create new entity from model
var entity = _mapper.Map <TEntity>(message.Model);
var dbSet = _context
.Set <TEntity>();
// add to data set, id should be generated
await dbSet
.AddAsync(entity, cancellationToken)
.ConfigureAwait(false);
// save to database
await _context
.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
// convert to read model
var readModel = _mapper.Map <TReadModel>(entity);
return(readModel);
}
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 <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 override async Task <EntityResponseModel <TReadModel> > ProcessAsync(EntityCreateCommand <TCreateModel, EntityResponseModel <TReadModel> > request, CancellationToken cancellationToken)
{
var EntityResponse = new EntityResponseModel <TReadModel>();
var dbSet = DataContext.Set <TEntity>();
var entiy = Mapper.Map <TEntity>(request.Model);
dbSet.Add(entiy);
await DataContext
.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
var readModel = Mapper.Map <TReadModel>(entiy);
EntityResponse.ReturnStatus = true;
EntityResponse.Data = readModel;
return(EntityResponse);
}
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);
}
