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 async Task <IActionResult> Put(FornecedorEntity model)
{
try
{
var fornecedor = await _service.GetFornecedorAsyncById(model.Id);
if (fornecedor == null)
{
return(NotFound());
}
var idTelefone = new List <int>();
model.TelefoneFornecedor.ForEach(item => idTelefone.Add(item.Id));
var telefones = fornecedor.TelefoneFornecedor.Where(telefone => !idTelefone.Contains(telefone.Id)).ToArray();
if (telefones.Length > 0)
{
_service.DeleteRange(telefones);
}
_mapper.Map(model, fornecedor);
var obtemEmpresa = await _empresa.ObterPorIdAsync(model.EmpresaId);
var valida = await FornecedorValidation.ValidaFornecedor(model, obtemEmpresa);
if (valida.Any())
{
throw new ArgumentException(valida);
}
_service.Update(model);
if (await _service.SaveChangesAsync())
{
return(Ok(_mapper.Map <FornecedorEntity>(model)));
}
}
catch (ArgumentException ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
return(BadRequest());
}
public async Task Atualizar(Fornecedor fornecedor)
{
var validator = new FornecedorValidation();
if (!ExecutarValidacao(validator, fornecedor))
{
return;
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento && f.Id != fornecedor.Id).Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return;
}
await _fornecedorRepository.Atualizar(fornecedor);
return;
}
public async Task Adicionar(Fornecedor fornecedor)
{
//validar o estado da entidade
var validator = new FornecedorValidation();
if (!ExecutarValidacao(validator, fornecedor) ||
!ExecutarValidacao(new EnderecoValidation(), fornecedor.Endereco))
{
return;
}
if (_fornecedorRepository.Buscar(f => f.Documento == fornecedor.Documento)
.Result.Any())
{
Notificar("Já existe um fornecedor com este documento informado.");
return;
}
await _fornecedorRepository.Adicionar(fornecedor);
}
public async Task <Unit> Handle(CreateFornecedorCommand request, CancellationToken cancellationToken)
{
var fornecedor = mapper.Map <Fornecedor>(request);
var validation = new FornecedorValidation().Validate(fornecedor);
if (!validation.IsValid)
{
throw new ValidationException(validation.Errors);
}
fornecedorDomainService.Add(fornecedor);
await mediator.Publish(new FornecedorNotification
{
Fornecedor = fornecedor,
Action = ActionNotification.Criar
});
return(Unit.Value);
}
public async Task <IActionResult> Post(FornecedorEntity model)
{
try
{
var fornecedor = _mapper.Map <FornecedorEntity>(model);
var obtemEmpresa = await _empresa.ObterPorIdAsync(model.EmpresaId);
var valida = await FornecedorValidation.ValidaFornecedor(fornecedor, obtemEmpresa);
if (valida.Any())
{
throw new ArgumentException(valida);
}
model.DataCadastro = DateTime.Now;
return(Ok(_service.InsertAsync(model)));
}
catch (ArgumentException ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
public override bool IsValid()
{
ValidationResult = new FornecedorValidation().Validate(this);
return(ValidationResult.IsValid);
}
public FornecedorValidationTests()
{
_sut = new FornecedorValidation();
}
