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