public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var readCommand = new EntityIdentifierQuery <Guid, TenantUpdateModel>(User, Id); var updateModel = await Mediator.Send(readCommand); if (updateModel == null) { return(NotFound()); } // only update input fields await TryUpdateModelAsync( updateModel, nameof(Entity), p => p.Name, p => p.Description, p => p.Slug, p => p.City, p => p.StateProvince, p => p.TimeZone, p => p.DomainName ); var updateCommand = new EntityUpdateCommand <Guid, TenantUpdateModel, TenantReadModel>(User, Id, updateModel); var result = await Mediator.Send(updateCommand); ShowAlert("Successfully saved tenant"); return(RedirectToPage("/Global/Tenant/Edit", new { id = result.Id })); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var readCommand = new EntityIdentifierQuery <Guid, LocationUpdateModel>(User, Id); var updateModel = await Mediator.Send(readCommand); if (updateModel == null) { return(NotFound()); } // only update input fields await TryUpdateModelAsync( updateModel, nameof(Entity), p => p.Name, p => p.Description, p => p.AddressLine1, p => p.City, p => p.StateProvince, p => p.PostalCode ); var updateCommand = new EntityUpdateCommand <Guid, LocationUpdateModel, LocationReadModel>(User, Id, updateModel); var result = await Mediator.Send(updateCommand); ShowAlert("Successfully saved location"); return(RedirectToPage("/Location/Edit", new { id = result.Id, tenant = TenantRoute })); }
private async Task <TopicReadModel> LoadTopic() { var command = new EntityIdentifierQuery <Guid, TopicReadModel>(User, Id); var result = await Mediator.Send(command); return(result); }
protected override async Task <TReadModel> Process(EntityIdentifierQuery <TKey, TReadModel> request, CancellationToken cancellationToken) { var model = await Read(request.Id, cancellationToken) .ConfigureAwait(false); return(model); }
private async Task LoadSession() { var command = new EntityIdentifierQuery <Guid, SessionReadModel>(User, SessionId); var result = await Mediator.Send(command); Session = result; }
protected virtual async Task <TReadModel> GetQuery(TKey id, CancellationToken cancellationToken = default(CancellationToken)) { var command = new EntityIdentifierQuery <TKey, TEntity, TReadModel>(id, User); var result = await Mediator.Send(command, cancellationToken).ConfigureAwait(false); return(result); }
protected virtual async Task <TReadModel> GetQuery(TKey id, CancellationToken cancellationToken = default) { var command = new EntityIdentifierQuery <TKey, TReadModel>(User, id); var result = await Mediator.Send(command, cancellationToken); return(result); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var readCommand = new EntityIdentifierQuery <Guid, InstructorUpdateModel>(User, Id); var updateModel = await Mediator.Send(readCommand); if (updateModel == null) { return(NotFound()); } // only update input fields await TryUpdateModelAsync( updateModel, nameof(Entity), p => p.GivenName, p => p.FamilyName, p => p.DisplayName, p => p.JobTitle, p => p.EmailAddress, p => p.MobilePhone, p => p.BusinessPhone ); var updateCommand = new EntityUpdateCommand <Guid, InstructorUpdateModel, InstructorReadModel>(User, Id, updateModel); var result = await Mediator.Send(updateCommand); ShowAlert("Successfully saved instructor"); return(RedirectToPage("/Instructor/View", new { id = result.Id, tenant = TenantRoute })); }
protected override async Task <CompleteModel> Process(SignUpCommand request, CancellationToken cancellationToken) { var principal = request.Principal; var updateCommand = new EntityUpsertCommand <Guid, SignUpUpdateModel, SignUpReadModel>(principal, request.Id, request.InstructorSignUp); var updateModel = await _mediator.Send(updateCommand, cancellationToken); foreach (var signupTopic in request.InstructorSignUpTopics) { var signupTopicCommand = new EntityUpsertCommand <Guid, SignUpTopicUpdateModel, SignUpTopicReadModel>(principal, signupTopic.Id, signupTopic); var signupTopicModel = await _mediator.Send(signupTopicCommand, cancellationToken); var topicId = signupTopicModel.TopicId; var topicReadCommand = new EntityIdentifierQuery <Guid, TopicUpdateModel>(principal, topicId); var topicModel = await _mediator.Send(topicReadCommand, cancellationToken); topicModel.InstructorSlots = signupTopic.TopicInstructorSlots; var topicUpdateCommand = new EntityUpdateCommand <Guid, TopicUpdateModel, TopicReadModel>(principal, topicId, topicModel); var updatedModel = await _mediator.Send(topicUpdateCommand, cancellationToken); } return(new CompleteModel()); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var readCommand = new EntityIdentifierQuery <Guid, DiscussionUpdateModel>(User, Id); var updateModel = await Mediator.Send(readCommand); if (updateModel == null) { return(NotFound()); } // only update input fields await TryUpdateModelAsync( updateModel, nameof(Entity), p => p.Message ); var updateCommand = new EntityUpdateCommand <Guid, DiscussionUpdateModel, DiscussionReadModel>(User, Id, updateModel); var result = await Mediator.Send(updateCommand); ShowAlert("Successfully saved topic discussion message"); return(RedirectToPage("/Topic/Discussion/View", new { Id = TopicId, tenant = TenantRoute })); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var readCommand = new EntityIdentifierQuery <Guid, TopicUpdateModel>(User, Id); var updateModel = await Mediator.Send(readCommand); if (updateModel == null) { return(NotFound()); } // only update input fields await TryUpdateModelAsync( updateModel, nameof(Entity), p => p.Title, p => p.Description, p => p.CalendarYear, p => p.TargetMonth, p => p.LeadInstructorId, p => p.IsRequired ); var updateCommand = new EntityUpdateCommand <Guid, TopicUpdateModel, TopicReadModel>(User, Id, updateModel); var result = await Mediator.Send(updateCommand); ShowAlert("Successfully saved topic"); return(RedirectToPage("/Topic/View", new { id = result.Id, tenant = TenantRoute })); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { Topics = await LoadTopics(); return(Page()); } var readCommand = new EntityIdentifierQuery <Guid, SignUpUpdateModel>(User, Id); var updateModel = await Mediator.Send(readCommand); if (updateModel == null) { return(NotFound()); } // only update input fields await TryUpdateModelAsync( updateModel, nameof(Entity), p => p.Name, p => p.Description ); var updateCommand = new SignUpCommand(User, Id, updateModel, SignUpTopics); var result = await Mediator.Send(updateCommand); ShowAlert("Successfully saved instructor signup"); return(RedirectToPage("/signup/View", new { id = Id, tenant = TenantRoute })); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var readCommand = new EntityIdentifierQuery <Guid, MemberUpdateModel>(User, Id); var updateModel = await Mediator.Send(readCommand); if (updateModel == null) { return(NotFound()); } // only update input fields await TryUpdateModelAsync( updateModel, nameof(Entity), p => p.DisplayName, p => p.SortName, p => p.FamilyName, p => p.GivenName, p => p.JobTitle, p => p.Email, p => p.PhoneNumber ); // compute sort name if (updateModel.SortName.IsNullOrWhiteSpace()) { updateModel.SortName = ToSortName(updateModel); } if (IsMemberDisabled && updateModel.LockoutEnd == null) { updateModel.LockoutEnd = DateTimeOffset.Now.AddYears(100); } else if (!IsMemberDisabled && updateModel.LockoutEnd.HasValue) { updateModel.LockoutEnd = null; } var updateCommand = new EntityUpdateCommand <Guid, MemberUpdateModel, MemberReadModel>(User, Id, updateModel); var updateResult = await Mediator.Send(updateCommand); // make sure correct user and tenant Membership.UserId = updateResult.Id; Membership.TenantId = Tenant.Value.Id; var membershipCommand = new TenantMembershipCommand(User, Membership); var membershipResult = await Mediator.Send(membershipCommand); ShowAlert("Successfully saved member"); return(RedirectToPage("/Member/Edit", new { id = Id, tenant = TenantRoute })); }
private async Task <TemplateReadModel> LoadTemplate() { if (TemplateId == null) { return(await Task.FromResult <TemplateReadModel>(null)); } var command = new EntityIdentifierQuery <Guid, TemplateReadModel>(User, TemplateId.Value); var result = await Mediator.Send(command); return(result); }
public void ConstructorWithParameters() { var id = Guid.NewGuid(); var identifierQuery = new EntityIdentifierQuery <Guid, LocationReadModel>(MockPrincipal.Default, id); identifierQuery.Should().NotBeNull(); identifierQuery.Id.Should().NotBe(Guid.Empty); identifierQuery.Id.Should().Be(id); identifierQuery.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); }
public virtual async Task <IActionResult> OnGetAsync() { var command = new EntityIdentifierQuery <Guid, TModel>(User, Id); var result = await Mediator.Send(command); if (result == null) { return(NotFound()); } Entity = result; return(Page()); }
public async Task EntityIdentifierQuery() { var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); var identifierQuery = new EntityIdentifierQuery <string, PriorityReadModel>(MockPrincipal.Default, PriorityConstants.Normal.ToCosmosKey()); var identifierResult = await mediator.Send(identifierQuery).ConfigureAwait(false); identifierResult.Should().NotBeNull(); identifierResult.Id.Should().Be(PriorityConstants.Normal.Id); }
protected override async Task <TReadModel> Process(EntityIdentifierQuery <TKey, TReadModel> request, CancellationToken cancellationToken) { if (request is null) { throw new ArgumentNullException(nameof(request)); } var entity = await Repository .FindAsync(request.Id, cancellationToken) .ConfigureAwait(false); // convert entity to read model var model = Mapper.Map <TReadModel>(entity); return(model); }
public async Task Upsert() { var key = ObjectId.GenerateNewId().ToString(); var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); // Update Entity var updateModel = Generator.Default.Single <TaskUpdateModel>(); updateModel.Title = "Upsert Test"; updateModel.Description = "Insert " + DateTime.Now.Ticks; updateModel.StatusId = StatusConstants.NotStarted.Id; updateModel.TenantId = TenantConstants.Test.Id; var upsertCommandNew = new EntityUpsertCommand <string, TaskUpdateModel, TaskReadModel>(MockPrincipal.Default, key, updateModel); var upsertResultNew = await mediator.Send(upsertCommandNew).ConfigureAwait(false); upsertResultNew.Should().NotBeNull(); upsertResultNew.Id.Should().Be(key); // Get Entity by Key var identifierQuery = new EntityIdentifierQuery <string, TaskReadModel>(MockPrincipal.Default, key); var identifierResult = await mediator.Send(identifierQuery).ConfigureAwait(false); identifierResult.Should().NotBeNull(); identifierResult.Title.Should().Be(updateModel.Title); // update model updateModel.Description = "Update " + DateTime.Now.Ticks; // Upsert again, should be update var upsertCommandUpdate = new EntityUpsertCommand <string, TaskUpdateModel, TaskReadModel>(MockPrincipal.Default, key, updateModel); var upsertResultUpdate = await mediator.Send(upsertCommandUpdate).ConfigureAwait(false); upsertResultUpdate.Should().NotBeNull(); upsertResultUpdate.Description.Should().NotBe(upsertResultNew.Description); }
protected override async Task <TReadModel> Process(EntityIdentifierQuery <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); // convert deleted entity to read model var model = Mapper.Map <TReadModel>(entity); return(model); }
public async Task Upsert() { var id = ObjectId.GenerateNewId().ToString(); var key = CosmosKey.Encode(id, id); var mediator = ServiceProvider.GetService <IMediator>(); mediator.Should().NotBeNull(); var mapper = ServiceProvider.GetService <IMapper>(); mapper.Should().NotBeNull(); // Update Entity var updateModel = Generator.Default.Single <AuditUpdateModel>(); updateModel.Username = "******"; updateModel.Content = "Insert " + DateTime.Now.Ticks; var upsertCommandNew = new EntityUpsertCommand <string, AuditUpdateModel, AuditReadModel>(MockPrincipal.Default, key, updateModel); var upsertResultNew = await mediator.Send(upsertCommandNew).ConfigureAwait(false); upsertResultNew.Should().NotBeNull(); // Get Entity by Key var identifierQuery = new EntityIdentifierQuery <string, AuditReadModel>(MockPrincipal.Default, key); var identifierResult = await mediator.Send(identifierQuery).ConfigureAwait(false); identifierResult.Should().NotBeNull(); identifierResult.Username.Should().Be(updateModel.Username); // update model updateModel.Content = "Update " + DateTime.Now.Ticks; // Upsert again, should be update var upsertCommandUpdate = new EntityUpsertCommand <string, AuditUpdateModel, AuditReadModel>(MockPrincipal.Default, key, updateModel); var upsertResultUpdate = await mediator.Send(upsertCommandUpdate).ConfigureAwait(false); upsertResultUpdate.Should().NotBeNull(); upsertResultUpdate.Content.Should().NotBe(upsertResultNew.Content); }
public async Task <IActionResult> GetById(int id, CancellationToken cancellationToken) { var returnResponse = new EntityResponseModel <ProductReadDto>(); try { var query = new EntityIdentifierQuery <int, EntityResponseModel <ProductReadDto> >(id); var result = await Mediator.Send(query, 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(EntityIdentifierQuery <TKey, TEntity, TReadModel> message, CancellationToken cancellationToken) { var dbSet = _context .Set <TEntity>(); var keyValue = new object[] { message.Id }; // find entity by message id var entity = await dbSet .FindAsync(keyValue, cancellationToken) .ConfigureAwait(false); if (entity == null) { return(default(TReadModel)); } // return read model var model = _mapper.Map <TReadModel>(entity); return(model); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var readCommand = new EntityIdentifierQuery <Guid, SessionUpdateModel>(User, Id); var updateModel = await Mediator.Send(readCommand); if (updateModel == null) { return(NotFound()); } // only update input fields await TryUpdateModelAsync( updateModel, 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 updateCommand = new EntityUpdateCommand <Guid, SessionUpdateModel, SessionReadModel>(User, Id, updateModel); var result = await Mediator.Send(updateCommand); var instructorCommand = new SessionInstructorUpdateCommand(User, Id, AdditionalInstructors); await Mediator.Send(instructorCommand); ShowAlert("Successfully saved topic session"); return(RedirectToPage("/Topic/Session/View", new { result.Id, TopicId, tenant = TenantRoute })); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var readCommand = new EntityIdentifierQuery <Guid, MemberUpdateModel>(User, Id); var updateModel = await Mediator.Send(readCommand); if (updateModel == null) { return(NotFound()); } // only update input fields await TryUpdateModelAsync( updateModel, nameof(Entity), p => p.DisplayName, p => p.Email, p => p.PhoneNumber ); var updateCommand = new EntityUpdateCommand <Guid, MemberUpdateModel, MemberReadModel>(User, Id, updateModel); var updateResult = await Mediator.Send(updateCommand); // make sure correct user and tenant Membership.UserName = updateResult.UserName; Membership.TenantId = Tenant.Value.Id; var membershipCommand = new TenantMembershipCommand(User, Membership); var membershipResult = await Mediator.Send(membershipCommand); ShowAlert("Successfully saved member"); return(RedirectToPage("/Member/Edit", new { id = Id, tenant = TenantRoute })); }
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 void ConstructorNull() { var identifierQuery = new EntityIdentifierQuery <Guid, LocationReadModel>(null, Guid.Empty); identifierQuery.Should().NotBeNull(); }