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