public async Task <Result <ManufacturerDto> > Handle(UpdateManufacturerCommand request,
CancellationToken cancellationToken)
{
var cacheKey = $"Manufacturer-{request.ManufacturerId}";
Manufacturer manufacturerInDb;
if (!await _cacheService.IsExistsAsync(cacheKey))
{
manufacturerInDb = await _manufacturerRepository.GetAsync(m => m.Id == request.ManufacturerId);
manufacturerInDb.CheckForNull();
}
var manufacturerDto = _mapper.Map <ManufacturerDto>(request.Manufacturer) with {
Id = request.ManufacturerId
};
manufacturerInDb = _mapper.Map <Manufacturer>(manufacturerDto);
LogDto log = new(Guid.NewGuid().ToString(), request.UserName, "edited manufacturer",
JsonSerializer.Serialize(manufacturerDto, CommandExtensions.JsonSerializerOptions), DateTime.UtcNow);
await _manufacturerRepository.UpdateAsync(m => m.Id == manufacturerInDb.Id, manufacturerInDb);
await _sender.PublishAsync(new UpdatedManufacturer(manufacturerInDb), cancellationToken);
await _sender.PublishAsync(log, cancellationToken);
await _cacheService.UpdateAsync(cacheKey, manufacturerInDb, _manufacturerSettings);
return(Result <ManufacturerDto> .Success(manufacturerDto));
}
}
public async Task <IActionResult> UpdateAsync(UpdateManufacturerCommand updateCommand)
{
var result = await _updateHandler.HandleAsync(updateCommand);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(Ok());
}
public async Task <ActionResult <ManufacturerLookupDto> > Update(int id,
[FromBody] UpdateManufacturerCommand command)
{
try
{
command.ManufacturerId = id;
return(Ok(await Mediator.Send(command)));
}
catch (ValidationException e)
{
return(BadRequest(e.Message));
}
}
public async Task <ICommandResult> HandleAsync(UpdateManufacturerCommand command)
{
command.Validate();
if (!command.IsValid)
{
new CommandResult(false, command.Errors);
}
var manufacturer = new Manufacturer(command.Id, command.Name)
{
Email = command.Email,
Phone = command.Phone
};
await _manufacturerRepository.UpdateAsync(manufacturer);
return(new CommandResult(true, "Manufacturer successfully updated."));
}
public IBaseCommandResult Handle(UpdateManufacturerCommand command)
{
command.Validate();
if (command.Invalid)
{
return(new BaseCommandResult(false, "Need to fix the errors on Manufacturer", command.Notifications));
}
var manufacturer = _repository.GetById(command.Id);
if (manufacturer == null)
{
return(new BaseCommandResult(false, "Manufacturer not found", null));
}
manufacturer.Update(command.Description);
_repository.Update(manufacturer);
return(new BaseCommandResult(true, "Manufacturer Updated with Success!", manufacturer));
}
public async Task <IActionResult> Put([FromRoute] Guid Id, [FromBody] UpdateManufacturerCommand command)
{
var result = _handler.Handle(command);
return(await Response(result));
}
public ICommandResult Handle(UpdateManufacturerCommand command)
{
return(Task.Run(() => HandleAsync(command)).GetAwaiter().GetResult());
}
