public async Task <IActionResult> Edit(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Atualizar(fornecedor);
if (!OperacaoValida())
{
//Para retornar todas as informacoes novamente
return(View(await ObterFornecedorProdutosEndereco(id)));
}
TempData["Editado"] = "Fornecedor editado com sucesso!";
return(RedirectToAction(nameof(Index)));
}
public async Task <UpdateFornecedorCommandResult> Handle(UpdateFornecedorCommand request, CancellationToken cancellationToken)
{
var empresa = await _empresaQueryStore.ObterEmpresaPeloId(Guid.Parse(request.EmpresaId));
if (empresa is null || empresa.Id == Guid.Empty)
{
_notificationContext.AddNotification(new Notification(Mensagens.EmpresaNaoEncontradaTitulo, Mensagens.EmpresaNaoEncontradaTexto));
return(null);
}
var fornecedorAtualizado = await _fornecedorService.Atualizar(new Fornecedor(empresa, request.Nome, request.DataCadastro,
request.DadosPessoais, request.IdentificadorReceitaFederal)
{
Id = Guid.Parse(request.Id)
});
return(new UpdateFornecedorCommandResult()
{
Empresa = new EmpresaResult()
{
NomeFantasia = fornecedorAtualizado.Empresa.NomeFantasia,
CNPJ = fornecedorAtualizado.Empresa.CNPJ,
UF = fornecedorAtualizado.Empresa.UF
},
DadosPessoais = fornecedorAtualizado.DadosPessoais,
DataCadastro = fornecedorAtualizado.DataCadastro,
IdentificadorReceitaFederal = fornecedorAtualizado.IdentificadorReceitaFederal,
Nome = fornecedorAtualizado.Nome
});
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
try
{
var result = await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(Fornecedor));
if (result == false)
{
_errorMensagens = _notificador.ObterNotificacoes(); return(null);
}
}
catch (DbUpdateConcurrencyException ex)
{
if (!FornecedorExists(Fornecedor.Id))
{
return(NotFound());
}
else
{
_errorException = ex.Message;
}
}
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> Edit(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Atualizar(fornecedor);
if (!OperacaoValida())
{
return(View(fornecedorViewModel));
}
TempData["Sucesso"] = "Fornecedor atualizado com sucesso";
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Put(Guid id, FornecedorViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var fornecedor = await _fornecedorRepository.ObterPorId(id);
if (fornecedor == null)
{
return(NotFound());
}
_mapper.Map(model, fornecedor);
if (await _fornecedorService.Atualizar(fornecedor))
{
return(Created("", _mapper.Map <FornecedorViewModel>(fornecedor)));
}
}
catch (System.Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
return(BadRequest());
}
public async Task <ActionResult <FornecedorDTO> > Put(Guid id, FornecedorDTO fornecedorDTO)
{
if (fornecedorDTO.Id != id)
{
return(BadRequest("O id informado não foi encontrado"));
}
// Erro nas validações
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var Novofornecedor = _mapper.Map <Fornecedor>(fornecedorDTO);
Task <bool> resultado = _fornecedorService.Atualizar(Novofornecedor);
var converterConvertido = Convert.ToBoolean(resultado);
if (!converterConvertido)
{
return(BadRequest());
}
return(Ok(Novofornecedor));
}
public async Task<ActionResult<FornecedorViewModel>> Alterar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id) return BadRequest();
if (!ModelState.IsValid) return CustomResponse();
await _fornecedorService.Atualizar(_mapper.Map<Fornecedor>(fornecedorViewModel));
return CustomResponse(fornecedorViewModel);
}
public async Task <ActionResult <FornecedorDTO> > Atualizar(Guid id, [FromBody] FornecedorDTO fornecedorDTO)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorDTO));
return(CustomResponse(fornecedorDTO));
}
public async Task<ActionResult<FornecedorViewModel>> AtualizarFornecedor(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificarErro("O id informado não é o mesmo que na query");
return CustomResponse(fornecedorViewModel);
}
if (!ModelState.IsValid) return CustomResponse(ModelState);
await _fornecedorService.Atualizar(_mapper.Map<Fornecedor>(fornecedorViewModel));
return CustomResponse(fornecedorViewModel);
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel forncedorViewModel)
{
if (id != forncedorViewModel.Id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorServ.Atualizar(_mapper.Map <Fornecedor>(forncedorViewModel));
return(CustomResponse(forncedorViewModel));
}
public async Task<IActionResult> Edit(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
return NotFound();
if (!ModelState.IsValid)
return View(fornecedorViewModel);
var fornecedor = _mapper.Map<Fornecedor>(fornecedorViewModel);
await _fornecedorService.Atualizar(fornecedor);
if (!base.OperacaoValida())
return View(await ObterFornecedorEndereco(id));
return RedirectToAction(nameof(Index));
}
public FornecedorViewModel Atualizar(FornecedorViewModel fornecedorViewModel)
{
var forn = _fornecedorService.ObterPorId(fornecedorViewModel.FornecedorId);
forn.ativo = true;
var fornecedor = Mapper.Map(fornecedorViewModel, forn);
fornecedor.ativo = true;
var fornreturn = _fornecedorService.Atualizar(fornecedor);
Commit();
return(fornecedorViewModel);
}
public async Task <IActionResult> Edit(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Atualizar(fornecedor);
return(RedirectToAction(nameof(Index)));
}
return(View(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorDTO> > Atualizar(Guid id, FornecedorDTO fornecedor)
{
if (id != fornecedor.Id)
{
NotificarErro("O Id do fornecedor não é o mesmo do objeto para atualização");
return(CustomResponse(fornecedor));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedor));
return(CustomResponse(fornecedor));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificarErro("O id informado não é o mesmo que foi passado na query!");
return(CustomResponse(fornecedorViewModel));
}
;
if (!ModelState.IsValid)
{
return(BadRequest());
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorDto> > Atualizar(Guid id, FornecedorDto fornecedorDto)
{
if (id != fornecedorDto.Id)
{
NotificarErro("O id informado não é o mesmo que foi passado na query.");
return(CustomResponse(fornecedorDto));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorDto));
return(CustomResponse(fornecedorDto));
}
public async Task <ActionResult <FornecedorViewModel> > Update(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificarErro(errorMsg: "The informed ID is not the same as the one passed on the query");
return(CustomResponse(fornecedorViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificarErro("O id fornecido não é o mesmo cadastrado anteriormente.");
return(CustomResponse(fornecedorViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificarErro("O id informado não é o mesmo que foi passado na query");
return(CustomResponse(fornecedorViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState)); //retorna os erros da ModelState de forma tratada
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Atualizar(fornecedor); //para ler do banco, usar o repository. Para gravar, usar o service.
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorView)
{
if (!id.Equals(fornecedorView.Id))
{
NotifyError("O id informado difere do id informado na query");
return(BadRequest(fornecedorView));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorView));
return(CustomResponse(fornecedorView));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificarErro("Id informado não exister");
return(CustomResponse(fornecedorViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar([FromRoute] Guid id, [FromBody] FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificarErro("Id informado incorreto");
return(CustomResponse(fornecedorViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await fornecedorService.Atualizar(mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificarErro("Id informado diferente de Id passado na query");
return(BadRequest(fornecedorViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var result = await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel vmodel)
{
if (id != vmodel.Id)
{
NotificarErro("O Id informado é diferente do Id passado na query");
return(CustomResponse(vmodel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(vmodel));
return(CustomResponse(vmodel));
}
/* A partir do ASP NET 2.1 não é necessário informar se o id vem da rota. */
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
notificarErro("O ID informado é diferente do existente na requisição.");
return(customResponse(fornecedorViewModel));
}
if (!ModelState.IsValid)
{
return(customResponse(ModelState));
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(customResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, [FromBody] FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificaErro("O Id informado não corresponde ao Fornecedor");
CustomResponse();
}
if (!ModelState.IsValid)
{
return(CustomResponse());
}
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Atualizar(fornecedor);
return(Ok(fornecedor));
}
public async Task <ActionResult <FornecedorDto> > Alterar(Guid id, FornecedorDto fornecedorDto)
{
if (id != fornecedorDto.Id)
{
NotificarErro("O identificador informado não corresponde");
return(CustomResponse(fornecedorDto));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorDto);
await _fornecedorService.Atualizar(fornecedor);
return(CustomResponse(fornecedorDto));
}
public async Task <ActionResult <FornecedorDto> > Atualizar(Guid id, FornecedorDto fornecedorDto)
{
if (id != fornecedorDto.Id || !ModelState.IsValid)
{
return(BadRequest());
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorDto);
var result = await _fornecedorService.Atualizar(fornecedor);
if (!result)
{
return(BadRequest());
}
return(Ok(fornecedor));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (id != fornecedorViewModel.Id)
{
NotificarErro("O Id não correponde ao objeto");
return(CustomResponse(fornecedorViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Atualizar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
