public async Task <ActionResult <FornecedorDto> > Adicionar(FornecedorDto fornecedorDto)
{
//obtendo o nome do usuário autenticado antes da implementação na MainController
//if (User.Identity.IsAuthenticated)
//{
// var userName = User.Identity.Name;
//}
//obtendo o nome do usuário autenticado depois da implementação na MainController
//if (UsuarioAutenticado)
//{
// var nomeUser = AppUser.Name;
// var nomeEmail = AppUser.GetUserEmail();
// var userId = AppUser.GetUserId();
// var userId2 = UsuarioId;
//}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(fornecedorDto));
return(CustomResponse(fornecedorDto));
//Antes de customizar as mensagens
//var fornecedor = _mapper.Map<Fornecedor>(fornecedorDto);
//var result = await _fornecedorService.Adicionar(fornecedor);
//if (!result) return BadRequest();
//return Ok(fornecedor);
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar(FornecedorViewModel fornecedorViewModel)
{
// Esses dois ifs são apenas para demostração - fazem o mesmo trabalho
if (User.Identity.IsAuthenticated)
{
var userName = User.Identity.Name;
}
// UsuarioAutenticado está com a implementação na MainController
if (UsuarioAutenticado)
{
// UsuarioId está com a implementação na MainController
var userName = UsuarioId;
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorDTO> > Post(FornecedorDTO fornecedor)
{
//O ModelState é conferido pela viewmodel
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
if (fornecedor == null)
{
return(NotFound());
}
var novoFornecedor = _mapper.Map <Fornecedor>(fornecedor);
var resultado = await _fornecedorService.Adicionar(novoFornecedor);
if (!resultado)
{
return(BadRequest());
}
else
{
return(Ok("O fornecedor " + fornecedor.Nome + " foi criado com sucesso"));
}
}
public async Task<ActionResult<FornecedorViewModel>> Adicionar(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid) return CustomResponse(ModelState);
await _fornecedorService.Adicionar(_mapper.Map<Fornecedor>(fornecedorViewModel));
return CustomResponse(fornecedorViewModel);
}
public async Task <ActionResult <FornecedorDTO> > Adicionar(FornecedorDTO fornecedorDTO)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(fornecedorDTO));
return(CustomResponse(fornecedorDTO));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState)); //retorna os erros da ModelState de forma tratada
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor); //para ler do banco, usar o repository. Para gravar, usar o service.
return(CustomResponse(fornecedorViewModel));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (ModelState.IsValid)
{
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
return(RedirectToAction("Index"));
}
return(View(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar([FromBody] FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await fornecedorService.Adicionar(mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
return(CustomResponse(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar(FornecedorViewModel fornecedorDto)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(fornecedorDto));
//retorne sempre o objeto Dto/ViewModel para evitar expor a sua entidade de negócio que pode vir a ter dados sensiveis.
return(CustomResponse(fornecedorDto));
}
public FornecedorViewModel Adicionar(FornecedorViewModel fornecedorViewModel)
{
var fornecedor = Mapper.Map <Fornecedor>(fornecedorViewModel);
fornecedor.ativo = true;
var fornecedorReturn = _fornecedorService.Adicionar(fornecedor);
Commit();
return(Mapper.Map <FornecedorViewModel>(fornecedorReturn));
}
public async Task<IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
return View(fornecedorViewModel);
var fornecedor = _mapper.Map<Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
if (!base.OperacaoValida())
return View(fornecedorViewModel);
return RedirectToAction(nameof(Index));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar(FornecedorViewModel model)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
Fornecedor fornecedor = _mapper.Map <Fornecedor>(model);
await _fornecedorService.Adicionar(fornecedor);
return(CustomResponse(model));
} //Adicionar
public async Task <ActionResult <FornecedorViewModel> > Adicionar([FromBody] FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor> (fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
// if (!result) return BadRequest ();
// return Ok (fornecedor);
}
public async Task <IActionResult> Create(FornecedorDTO fornecedorDTO)
{
if (!ModelState.IsValid)
{
return(View(fornecedorDTO));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(fornecedorDTO));
if (!OperacaoValida())
{
return(View(fornecedorDTO));
}
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult <FornecedoreViewModel> > Adicionar(FornecedoreViewModel fornecedoreViewModel)
{
if (UsuarioAutenticado)
{
var userName = AppUser.Name;
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(fornecedoreViewModel.Adapt <Fornecedor>());
return(CustomResponse(fornecedoreViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar(FornecedorViewModel fornecedorViewModel)
{
if (UsuarioAutenticado)
{
var userName = AppUser.GetUserEmail();
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var result = await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(Fornecedor));
if (result == false)
{
_errorMensagens = _notificador.ObterNotificacoes(); return(null);
}
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel); //quero um Fornecedor e tenho um FornecedorViewModel
await _fornecedorService.Adicionar(fornecedor);
if (!OperacaoValida())
{
return(View(fornecedorViewModel));
}
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
var result = await _fornecedorService.Adicionar(fornecedor);
if (!result)
{
return(BadRequest());
}
return(Ok(fornecedor));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
//fornecedorViewModel.Id = Guid.NewGuid();
//_context.Add(fornecedorViewModel);
//await _context.SaveChangesAsync();
//return RedirectToAction(nameof(Index));
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
//Retornar notificação para user se algo não está válido
if (!OperacaoValida())
{
return(View(fornecedorViewModel));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
fornecedorViewModel.RemoveCaracteresDocumento();
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
if (!OperacaoValida())
{
return(View(fornecedorViewModel));
}
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar([FromBody] FornecedorViewModel fornecedorViewModel)
{
var UserName = _appUser.Name;
var UserEmail = _appUser.GetUserId();
var Autenticado = _appUser.IsAuthenticated();
var isInRole = _appUser.IsInRole("Fornecedor");
var Claims = _appUser.GetClaimsIdentity();
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
ModelState.Remove("Documento");
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
if (!OperacaoValida())
{
return(View(fornecedorViewModel));
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar(FornecedorViewModel fornecedorViewModel)
{
//if (!ModelState.IsValid) return BadRequest();
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
//Converte fornecedorViewModel para o tipo Fornecedor da classe de negócio
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
//var result = await _fornecedorService.Adicionar(fornecedor);
await _fornecedorService.Adicionar(fornecedor);
//if (!result) return BadRequest();
//return Ok(fornecedor);
return(CustomResponse(fornecedorViewModel));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
if (!OperacaoValida())
{
return(View(fornecedorViewModel));
}
TempData["Sucesso"] = "Fornecedor criado com sucesso";
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
//Verificando se algo deu errado na camada de negocios
if (!OperacaoValida())
{
return(View(fornecedorViewModel));
}
return(RedirectToAction(nameof(Index)));
} //Create
public async Task <ActionResult <FornecedorDto> > Adicionar(FornecedorDto fornecedorDto)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
if (UsuarioAutenticado)
{
var userId = User.GetUserId();
var email = User.GetUserEmail();
var id = UsuarioId;
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorDto);
await _fornecedorService.Adicionar(fornecedor);
_logger.LogInformation("Inclusão de fornecedor " + fornecedorDto.Nome);
return(CustomResponse(fornecedorDto));
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar(FornecedorViewModel fornecedorViewModel)
{
//if (User.Identity.IsAuthenticated)
//{
// var userName = User.Identity.Name;
//}
//if (UsuarioAutenticado)
//{
// var userName = UsuarioId;
//}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _fornecedorService.Adicionar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
