public Task <bool> Handle(UpdateFornecedorCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
var fornecedor = new Fornecedor(message.Id, message.NomeCompanhia, message.NomeContato, message.TituloContato,
message.Telefone, message.EnderecoEmail, message.Endereco, message.Cidade, message.Estado, message.Pais);
var fornecedorExiste = _fornecedorRepository.GetByNomeCompanhia(fornecedor.NomeCompanhia);
if (fornecedorExiste != null && fornecedorExiste.Id != fornecedor.Id)
{
if (!fornecedorExiste.Equals(fornecedor))
{
Bus.RaiseEvent(new DomainNotification(message.MessageType, "A Categria já foi recebido."));
return(Task.FromResult(false));
}
}
_fornecedorRepository.Update(fornecedor);
if (Commit())
{
Bus.RaiseEvent(new FornecedorUpdatedEvent(fornecedor.Id, fornecedor.NomeCompanhia, fornecedor.NomeContato, fornecedor.TituloContato,
fornecedor.Telefone, fornecedor.EnderecoEmail, fornecedor.Endereco, fornecedor.Cidade, fornecedor.Estado, fornecedor.Pais));
}
return(Task.FromResult(true));
}
public async Task <Unit> Handle(UpdateFornecedorCommand request, CancellationToken cancellationToken)
{
var fornecedor = mapper.Map <Fornecedor>(request);
if (fornecedor == null)
{
throw new Exception("Fornecedor não encontrado.");
}
var validation = new FornecedorValidation().Validate(fornecedor);
if (!validation.IsValid)
{
throw new ValidationException(validation.Errors);
}
fornecedorDomainService.Update(fornecedor);
await mediator.Publish(new FornecedorNotification
{
Fornecedor = fornecedor,
Action = ActionNotification.Atualizar
});
return(Unit.Value);
}
public override Task <CommandResult> Update(FornecedorViewModel viewModel)
{
var command = new UpdateFornecedorCommand(viewModel.Id, viewModel.Nome, viewModel.Tipo, viewModel.Descricao);
command.AttachContato(viewModel.ContatoCelular, viewModel.ContatoEmail, viewModel.ContatoTelefoneComercial, viewModel.ContatoTelefoneResidencial, viewModel.ContatoObservacao);
command.AttachEndereco(viewModel.EnderecoNumero, viewModel.EnderecoRua, viewModel.EnderecoBairro, viewModel.EnderecoComplemento, viewModel.EnderecoCidadeId, viewModel.EnderecoCEP);
command.AttachDocumento(viewModel.DocumentoCadastroNacional, viewModel.DocumentoCadastroEstadual);
return(_mediator.SendCommand(command));
}
public async Task <IActionResult> Put(UpdateFornecedorCommand command)
{
try
{
await fornecedorApplicationService.Update(command);
return(Ok(new { Message = "Fornecedor atualizado com sucesso." }));
}
catch (ValidationException e)
{
return(BadRequest(ValidationAdapter.Parse(e.Errors)));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public Task <CommandResult> Handle(UpdateFornecedorCommand command, CancellationToken cancellationToken)
{
if (!command.IsValid())
{
NotifyCommandErrors(command);
return(Response());
}
Cidade cidade = _cidadeRepository.GetById(command.EnderecoCidadeId);
Documento documento = new Documento(command.DocumentoCadastroNacional, command.DocumentoCadastroEstadual);
Contato contato = new Contato(command.ContatoCelular, command.ContatoEmail, command.ContatoTelefoneComercial, command.ContatoTelefoneResidencial, command.ContatoObservacao);
Endereco endereco = new Endereco(command.EnderecoRua, command.EnderecoNumero, command.EnderecoBairro, command.EnderecoComplemento, cidade, command.EnderecoCEP);
Fornecedor fornecedor = new Fornecedor(command.Id, command.Nome, command.Tipo, documento, contato, endereco, command.Observacao);
_fornecedorRepository.Update(fornecedor);
if (Commit())
{
_mediator.PublishEvent(new UpdatedFornecedorEvent(fornecedor));
}
return(Response());
}
public async Task <IActionResult> Atualizar([FromBody] UpdateFornecedorCommand command)
{
var updateFornecedorResult = await Mediator.Send(command);
return(Ok(updateFornecedorResult));
}
public async Task Update(UpdateFornecedorCommand command)
{
await mediator.Send(command);
}