public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorRepository.Adicionar(fornecedor);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(FornecedorViewModel fornecedorViewModel)
{
if (ModelState.IsValid)
{
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorRepository.Adicionar(fornecedor);
//await _fornecedorRepository.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
return(View(fornecedorViewModel));
}
public async Task <ActionResult <FornecedorViewModel> > Excluir(Guid id)
{
FornecedorViewModel forncedorViewModel = await ObterFornecedorEndereco(id);
if (forncedorViewModel == null)
{
return(NotFound());
}
await _fornecedorServ.Remover(id);
return(CustomResponse(id));
}
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 ActionResult Delete(FornecedorViewModel fornecedorViewModel)
{
try
{
_fornecedorServicoAplicacao.Excluir(fornecedorViewModel.Id);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
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 <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 ActionResult Edit(FornecedorViewModel fornecedorViewModel)
{
try
{
_fornecedorServicoAplicacao.Atualizar(fornecedorViewModel);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task Remover_Fornecedor_Com_Erro_Not_Found()
{
// Arrange
FornecedorViewModel fornecedorVM = FornecedorViewModelTestsHelper.ObterInstancia(1, "34446436082");
// Act
HttpResponseMessage response = await base.Client.DeleteAsync($"{CommonUri}/{fornecedorVM.Id}");
// Assert
Assert.False(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public ActionResult Edit(FornecedorViewModel fornecedor)
{
if (ModelState.IsValid)
{
var fornecedorDomain = Mapper.Map <FornecedorViewModel, Fornecedor>(fornecedor);
_fornecedorApp.Update(fornecedorDomain);
return(RedirectToAction("Index"));
}
return(View(fornecedor));
}
public async Task <ActionResult <FornecedorViewModel> > Atualizar(Guid id, FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid || id != fornecedorViewModel.Id)
{
NotificarError("O id informado é nao é o mesmo que foi passado na query");
return(CustomResponse(fornecedorViewModel));
}
await _fornecedorRepositorio.Atualizar(_mapper.Map <Fornecedor>(fornecedorViewModel));
return(CustomResponse(fornecedorViewModel));
}
public IActionResult Post([FromBody] FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(Response(fornecedorViewModel));
}
_fornecedorAppService.Register(fornecedorViewModel);
return(Response(fornecedorViewModel));
}
public async Task <ObjectResult> Put([FromBody] FornecedorViewModel fornecedor)
{
var result = await fornecedorRepository.Update(fornecedor);
if (result != null)
{
return(Ok(result));
}
else
{
return(BadRequest(new { message = "No result" }));
}
}
public async Task Adicionar_Fornecedor_Com_Sucesso()
{
// Arrange
FornecedorViewModel fornecedorVM = FornecedorViewModelTestsHelper.ObterInstancia(1, "64307756070");
HttpContent dataRequest = ContentHelper.CreateJsonContent(fornecedorVM);
// Act
HttpResponseMessage response = await base.Client.PostAsync(CommonUri, dataRequest);
// Assert
Assert.True(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public async Task Atualizar_Fornecedor_Com_Erro_Not_Found()
{
// Arrange
FornecedorViewModel fornecedorVM = FornecedorViewModelTestsHelper.ObterInstancia(1, "92076602020");
HttpContent dataRequest = ContentHelper.CreateJsonContent(fornecedorVM);
// Act
HttpResponseMessage response = await base.Client.PutAsync($"{CommonUri}/{fornecedorVM.Id}", dataRequest);
// Assert
Assert.False(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task Adicionar_Fornecedor_Com_Erro_Bad_Request(string documento)
{
// Arrange
FornecedorViewModel fornecedorVM = FornecedorViewModelTestsHelper.ObterInstancia(1, documento);
HttpContent dataRequest = ContentHelper.CreateJsonContent(fornecedorVM);
// Act
HttpResponseMessage response = await base.Client.PostAsync(CommonUri, dataRequest);
// Assert
Assert.False(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
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);
return RedirectToAction("Index");
}
public async Task <ActionResult <FornecedorViewModel> > Cadastrar(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
await _fornecedorService.Adicionar(fornecedor);
return(Ok());
}
public async Task <ActionResult <FornecedorViewModel> > Adicionar([FromBody] FornecedorViewModel fornecedorVM)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorVM);
await _fornecedorService.Adicionar(fornecedor);
return(CustomResponse(_mapper.Map <FornecedorViewModel>(fornecedor)));
}
public ConfigurationProfile()
{
Shared.Conversores.Configuracao.Registrar(this);
this.AllowNullCollections = true;
EnderecoViewModel.Mapping(this);
FornecedorViewModel.Mapping(this);
InfracaoViewModel.Mapping(this);
InfracaoListaViewModel.Mapping(this);
ProdutoViewModel.Mapping(this);
ProcessoViewModel.Mapping(this);
ProcessoListaViewModel.Mapping(this);
}
public async Task <ActionResult <FornecedorViewModel> > AdcionarFornecedor(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var fornecedor = _mapper.Map <Fornecedor>(fornecedorViewModel);
//var result =
await _fornecedorService.Adicionar(fornecedorViewModel);
//if (!result) return BadRequest();
return CustomResponse(fornecedorViewModel)
}
public IActionResult Excluir(FornecedorViewModel model)
{
// TempData, guarda a mensagem para ser exibido na pagina INDEX
//se houver
var fornecedor = appFornecedores.Remover(model);
TempData["RetornoPost"] = "success,Fornecedor excluído com sucesso!";
if (VerificaErros(fornecedor.ListaErros))
{
ViewBag.RetornoPost = "error,Não foi possível excluir o fornecedor!";
return(View(model));
}
return(RedirectToAction("Index"));
}
public void Adicionar(FornecedorViewModel FornecedorViewModel)
{
try
{
//var produto = _mapper.Map<Produto>(produtoViewModel);
Fornecedor fornecedor = new Fornecedor();
_mapper.Map(FornecedorViewModel, fornecedor);
_fornecedorServicoDominio.Adicionar(fornecedor);
}
catch (Exception e)
{
throw e;
}
}
public async Task Remover_Fornecedor_Com_Sucesso()
{
// Arrange
FornecedorViewModel fornecedorVM = FornecedorViewModelTestsHelper.ObterInstancia(1, "34446436082");
await AdicionarObjsParaTestes(fornecedorVM);
// Act
HttpResponseMessage response = await base.Client.DeleteAsync($"{CommonUri}/{fornecedorVM.Id}");
// Assert
Assert.True(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public IActionResult Cadastrar()
{
var viewModel = new FornecedorViewModel()
{
TelaEnderecos = new EnderecoTelaViewModel()
{
ApenasUmEndereco = false
}
};
PreencheCombosTela(viewModel);
return(View("Form", viewModel));
}
private async Task AdicionarObjsParaTestes(FornecedorViewModel fornecedorVM, params ProdutoViewModel[] objs)
{
using IServiceScope scope = base.Factory.Services.CreateScope();
var fornecedorRepository = scope.ServiceProvider.GetRequiredService <IFornecedorRepository>();
var produtoRepository = scope.ServiceProvider.GetRequiredService <IProdutoRepository>();
var mapper = scope.ServiceProvider.GetRequiredService <IMapper>();
await fornecedorRepository.Adicionar(mapper.Map <Fornecedor>(fornecedorVM));
foreach (ProdutoViewModel item in objs)
{
await produtoRepository.Adicionar(mapper.Map <Produto>(item));
}
}
public ActionResult Alterar(int id, FornecedorViewModel fornecedorViewModel)
{
fornecedorViewModel.Id = id;
if (ModelState.IsValid)
{
var dao = new FornecedorDAO();
var fornecedor = Mapper.Map <FornecedorViewModel, Fornecedor>(fornecedorViewModel);
dao.Atualizar(fornecedor);
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index"));
}
public ActionResult Alterar(FornecedorViewModel model)
{
model.Endereco.UF.ListaEstados = appuf.ObterListaEstados();
if (!ModelState.IsValid)
{
return(View(model));
}
model = appService.Atualizar(model);
ViewBag.RetornoPost = "success,Cliente atualizado com sucesso!";
if (VerificaErros(model.ListaErros))
{
ViewBag.RetornoPost = "error,Não foi possível atualizar o fornecedor!";
}
return(View(model));
}
public IActionResult Create(FornecedorViewModel fornecedorViewModel)
{
if (!ModelState.IsValid)
{
return(View(fornecedorViewModel));
}
_fornecedorAppService.Register(fornecedorViewModel);
if (IsValidOperation())
{
ViewBag.Sucesso = "Cliente Registerado!";
}
return(View(fornecedorViewModel));
}
