public async Task <Result <CommandResult> > Handle(UpdateOrganizationCommand request, CancellationToken cancellationToken) { if (!request.IsValid()) { await PublishValidationErrorsAsync(request); return(Result.Failure <CommandResult>(ApplicationMessages.Update_Failed)); } var organization = await _organizationRepository.GetByIdAsync(request.Id); var exist = await _organizationRepository.ExistByNameAsync(organization.Id, request.Name); if (exist) { await _mediator.Publish(new DomainNotification("", ApplicationMessages.Name_Already_Exist)); return(Result.Failure <CommandResult>(ApplicationMessages.Update_Failed)); } organization.SetName(request.Name); organization.SetDescription(request.Description); await _organizationRepository.UpdateAsync(organization); return(Result.Success(new CommandResult(organization.Id, ApplicationMessages.Update_Success))); }
public void UpdateOrganization(Guid id, string name, string description, string email, bool isDisabled) { userContext.CheckPermission(Permissions.UserMaintenance); var command = new UpdateOrganizationCommand(id, name, description, email, isDisabled); commandBus.Value.Send(Envelope.Create(command)); }
public async Task <ActionResult> UpdateOrganization(int id, UpdateOrganizationCommand command) { command.Id = id; command.UserId = User.GetUserId(); await this.SendRequest(command); return(Ok()); }
public async Task UpdateOrganizationCommand_WithoutTitle_ShouldThrowValidationException() { var createdOrganizationId = await SeedSampleOrganization(); var command = new UpdateOrganizationCommand { OrganizationId = createdOrganizationId }; FluentActions.Invoking(() => SendAsync(command)).Should().Throw <ValidationException>(); }
public async Task <ActionResult> Update(Guid id, UpdateOrganizationCommand command) { if (id != command.OrganizationId) { return(BadRequest()); } await Mediator.Send(command); return(NoContent()); }
public void UpdateOrganizationCommand_WithInvalidOrganizationId_ShoulThrowNotFoundException() { var command = new UpdateOrganizationCommand { OrganizationId = Guid.Empty, Title = "Test 5" }; FluentActions.Invoking(() => SendAsync(command)).Should().Throw <NotFoundException>(); }
public async Task <IActionResult> Put(UpdateOrganizationCommand updateOrganizationCommand) { var result = await Mediator.Send(updateOrganizationCommand); if (result.Success == false) { return(result.ApiResult); } return(NoContent()); }
public async Task UpdateOrganizationCommand_WithTitleMoreThan200Characters_ShouldThrowValidationException() { var createdOrganizationId = await SeedSampleOrganization(); var command = new UpdateOrganizationCommand { OrganizationId = createdOrganizationId, Title = "This is a very long title for an organization so we could test Request validator. In this case we expect a validation exception because our title is more that 200 character. so let's test it and see our test result" }; FluentActions.Invoking(() => SendAsync(command)).Should().Throw <ValidationException>(); }
public async Task UpdateOrganziationCommand_WithDiffrentUserThanAdmin_ShouldThrowForbiddenAccessException() { var createdOrganizationId = await SeedSampleOrganization(); await RunAsAdministratorAsync(); var command = new UpdateOrganizationCommand { OrganizationId = createdOrganizationId, Title = "Test 5" }; FluentActions.Invoking(() => SendAsync(command)).Should().Throw <ForbiddenAccessException>(); }
public async Task <CommandResult> UpdateOrganization(UpdateOrganizationCommand cmd) { var org = await _db.Organizations.FindAsync(cmd.OrganizationId); if (org == null) { return(CommandResult.NotFound(cmd, "Organization Not Found")); } org.Name = cmd.Name; org.Image = cmd.Image; org.Description = cmd.Description; await _db.SaveChangesAsync(); return(CommandResult.Success(cmd)); }
public IHttpActionResult UpdateOrganization(Guid organizationId, UpdateOrganizationCommand command) { if (command == null) { throw new ArgumentNullException("command"); } if (organizationId == Guid.Empty) { throw new ArgumentException("organizationId must be defined."); } if (string.IsNullOrWhiteSpace(command.Name)) { throw new ArgumentException("Organization name must be defined."); } identityManagementService.UpdateOrganization(organizationId, command.Name, command.Description, command.Email, command.IsDisabled); return(Ok()); }
public Task <bool> Handle(UpdateOrganizationCommand request, CancellationToken cancellationToken) { if (!request.IsValid()) { NotifyValidationErrors(request); return(Task.FromResult(false)); } var Organization = new Organization(request.Id, request.Name, request.EmployeesCount); _organizationRepository.Update(Organization); if (Commit()) { _bus.RaiseEvent(new OrganizationUpdatedEvent(request.Id, request.Name, request.EmployeesCount)); } return(Task.FromResult(true)); }
/// <summary> /// Updates an organization with passed fields /// </summary> /// <param name="command">contains ID and fields</param> /// <returns></returns> public EmptyResult UpdateOrganization(UpdateOrganizationCommand command) { if (command?.OrganizationId == null || command.OrganizationId <= 0) { return(new EmptyResult(OrganizationUserServiceErrors.InvalidOrganizationId())); } if (!organizationRepository.OrganizationExists(command.OrganizationId.Value)) { return(new EmptyResult(OrganizationServiceErrors.OrganizationNotFoundError())); } if (command.Name != null && organizationRepository.OrganizationExistsByName(command.Name, command.OrganizationId.Value)) { return(new EmptyResult(OrganizationServiceErrors.InvalidUpdateOrganizationNameError(nameof(command.Name)))); } organizationRepository.UpdateOrganization(command); return(new EmptyResult()); }
public void UpdateOrganization(UpdateOrganizationCommand command) { if (command.OrganizationId != null) { var id = command.OrganizationId.Value; var organizationEntity = context.Organizations.Find(id); organizationEntity.UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); if (command.Name != null) { organizationEntity.Name = command.Name; } if (command.IsActive.HasValue) { organizationEntity.IsActive = command.IsActive.Value; } context.Organizations.Update(organizationEntity); context.SaveChanges(); } }
public async Task <IHttpActionResult> UpdateOrganization(int organizationId, string description, string details, OrganizationType organizationType, ReportingFrequency reportingFrequency, EntityReference parent) { try { if (!_userContext.CurrentUserIsSystemUser()) { return(Unauthorized()); } if (string.IsNullOrWhiteSpace(description)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(description)); } if (!_userContext.CurrentUserIsSystemAdmin()) { return(Unauthorized()); } var organization = _queryService.GetOrganizationViewModel(organizationId); if (organization == null) { throw new ArgumentException("Invalid Organization Id", nameof(organizationId)); } var cmd = new UpdateOrganizationCommand(organizationId, description, details, organizationType, reportingFrequency, parent); await _endpointInstance().SendWithSignalRMetaData(cmd, Request); return(this.Accepted()); } catch (Exception ex) { _log.Error(ex); return(InternalServerError()); } }
public void Update(OrganizationModel organization) { var updateOrganizationCommand = new UpdateOrganizationCommand(organization.Id, organization.Name, organization.EmployeesCount); _bus.SendCommand(updateOrganizationCommand); }
public async Task <IActionResult> UpdateOrganization([FromBody] UpdateOrganizationCommand command) => await HandleCommandAsync(command, _commandService.UpdateOrganization);