public async Task <IActionResult> Insert([FromBody] EstabelecimentoViewModel model)
{
if (model == null)
{
return(BadRequest("O CNPJ do estabelecimento precisa ser informado"));
}
try
{
var api = RestClient.For <IReceitaWS>("https://www.receitaws.com.br/v1");
var estabelecimento = await api.GetEstabelecimentoAsync(model.CNPJ);
if (estabelecimento.Status == "ERROR")
{
return(BadRequest("Erro na API de ReceitaWS, tente novamente"));
}
await _EstabelecimentoService.Adicionar(estabelecimento);
var newCustomer = await _EstabelecimentoService.ObterMaisRecente();
return(CreatedAtRoute("GetEstabelecimento", new { id = newCustomer.Id }, newCustomer));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <ActionResult> AdicionarEstabelecimentoAsync([FromBody] EstabelecimentoViewModel estabelecimento)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(new ResultViewModel(ModelError.GetErrorModelState(ModelState, _notificador))));
}
var estabelecimentoDto = _mapper.Map <Estabelecimento>(estabelecimento);
var retornoEstabelecimento = await _estabelecimentoService.AdicionarEstabelecimentoAsync(estabelecimentoDto);
if (retornoEstabelecimento == null)
{
return(BadRequest(new ResultViewModel(_notificador.ObterNotificacoes())));
}
var estabelecimentoViewModel = _mapper.Map <EstabelecimentoViewModel>(retornoEstabelecimento);
ResultViewModel resultViewModel = new ResultViewModel(estabelecimentoViewModel);
return(Ok(resultViewModel));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Ocorreu um erro interno no servidor: " + ex.Message));
}
}
public void Testar_Nao_Cadastrar_Estabelecimento_Conta_Invalida()
{
// arrange
var estabelecimentoVM = new EstabelecimentoViewModel()
{
razao_social = "Estabelecimento 1",
cnpj = "94.335.598/0001-13",
agencia = "111-1",
conta = "11.1111"
};
var estabelecimento = Mapper.Map <EstabelecimentoViewModel, EstabelecimentoModel>(estabelecimentoVM);
// act
var result = controller.Create(estabelecimentoVM) as ViewResult;
// assert
repositoryMock.Verify(x => x.Create(estabelecimento), Times.Never());
var model = result.ViewData.Model as EstabelecimentoViewModel;
Assert.AreEqual(estabelecimentoVM, model);
Assert.AreEqual("Create", result.ViewName);
}
public void Testar_Cadastrar_CNPJ_Nao_Repetido()
{
// arrange
var estabelecimentoVM = new EstabelecimentoViewModel()
{
razao_social = "Estabelecimento 1",
cnpj = "94.335.598/0001-13"
};
var estabelecimento = Mapper.Map <EstabelecimentoViewModel, EstabelecimentoModel>(estabelecimentoVM);
var estabelecimentos = new List <EstabelecimentoModel>();
estabelecimentos.Add(new EstabelecimentoModel()
{
razao_social = "Estabelecimento 2", cnpj = "22.222.222/2222-22"
});
estabelecimentos.Add(new EstabelecimentoModel()
{
razao_social = "Estabelecimento 3", cnpj = "33.333.333/3333-33"
});
repositoryMock.Setup(x => x.FindByCnpj(estabelecimento.cnpj)).Returns(estabelecimentos.Where(x => x.cnpj == estabelecimento.cnpj).FirstOrDefault());
// act
var result = controller.Create(estabelecimentoVM) as RedirectToRouteResult;
// assert
repositoryMock.Verify(x => x.Create(It.IsAny <EstabelecimentoModel>()), Times.Once());
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public void Testar_Nao_Cadastrar_Estabelecimento_Categoria_Supermercado_Sem_Informar_Telefone()
{
// arrange
var estabelecimentoVM = new EstabelecimentoViewModel()
{
razao_social = "Estabelecimento 1",
cnpj = "94.335.598/0001-13",
cod_categoria = 1,
telefone = ""
};
var categoria = new CategoriaModel()
{
id = 1, nome = "Supermercado"
};
repositoryMockCategoria.Setup(x => x.GetSingle(categoria.id)).Returns(categoria);
var estabelecimento = Mapper.Map <EstabelecimentoViewModel, EstabelecimentoModel>(estabelecimentoVM);
// act
var result = controller.Create(estabelecimentoVM) as ViewResult;
// assert
repositoryMock.Verify(x => x.Create(estabelecimento), Times.Never());
var model = result.ViewData.Model as EstabelecimentoViewModel;
Assert.AreEqual(estabelecimentoVM, model);
Assert.AreEqual("Create", result.ViewName);
}
public ActionResult Create()
{
var model = new EstabelecimentoViewModel();
LoadModel(model);
return(View(model));
}
public async Task <EstabelecimentoViewModel> Get(int Id)
{
var estabelecimento = await _Estabelecimento.GetAsync(Id);
if (estabelecimento == null)
{
return(null);
}
var Usuarios = await _Usuario.GetAsync(estabelecimento);
return(EstabelecimentoViewModel.Create(estabelecimento, Usuarios));
}
public async Task <List <UsuarioViewModel> > Get(EstabelecimentoViewModel estabelecimento)
{
var est = await _Estabelecimento.GetAsync(estabelecimento.Id);
if (est == null)
{
return(null);
}
var usuarios = await _Usuario.GetAsync(est);
return(usuarios.Select(X => UsuarioViewModel.Create(X)).ToList());
}
public LocalizarEstabelecimentoPage()
{
if (_estabelecimentoVM == null)
{
_estabelecimentoVM = new EstabelecimentoViewModel();
}
LoadEstabelecimentosAsync();
Task.Delay(10);
BindingContext = _estabelecimentoVM;
InitializeComponent();
}
public void Testar_Cadastro_Estabelecimento()
{
// arrange
var estabelecimentoVM = new EstabelecimentoViewModel()
{
razao_social = "Estabelecimento 1",
cnpj = "94.335.598/0001-13"
};
// act
var result = controller.Create(estabelecimentoVM) as RedirectToRouteResult;
// assert
repositoryMock.Verify(x => x.Create(It.IsAny <EstabelecimentoModel>()), Times.Once());
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public async Task <UsuarioViewModel> Get(int Id)
{
var usuario = await _Usuario.GetAsync(Id);
if (usuario == null)
{
return(null);
}
var estabelecimento = await _Estabelecimento.GetAsync(usuario.EstabelecimentoId);
var user = UsuarioViewModel.Create(usuario);
user.Estabelecimento = EstabelecimentoViewModel.Create(estabelecimento);
return(user);
}
public ActionResult Edit([Bind(Include = "Id,RazaoSocial,NomeFantasia,CNPJ,Email,Endereco,Cidade,Estado,Telefone,DataCadastro,Categoria,Status,Agencia,Conta")] EstabelecimentoViewModel viewModel)
{
if (ModelState.IsValid)
{
Estabelecimento estabelecimento = Mapper.Map <EstabelecimentoViewModel, Estabelecimento> (viewModel);
try
{
repositorioEstabelecimentos.Alterar(estabelecimento);
}
catch (CustomValidationException ex)
{
ModelState.AddModelError(ex.NomeCampo, ex.Message);
return(View(viewModel));
}
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public async Task <List <UsuarioViewModel> > Get()
{
var usuarios = await _Usuario.GetAsync();
var estabelecimento = await _Estabelecimento.GetAsync();
return((from user in usuarios
join est in estabelecimento.DefaultIfEmpty() on user.EstabelecimentoId equals est.Id
select new UsuarioViewModel(user.Id,
user.Nome,
user.NomeUsuario,
user.Email,
user.Telefone,
user.UsuarioAdm)
{
CategoriasHabilitadas = user.CategoriasHabilitadas?.Select(X => CategoriaServicoViewModel.Create(X)).ToList(),
Estabelecimento = est != null ? EstabelecimentoViewModel.Create(est) : null
}).ToList());
}
public void Testar_Nao_Cadastrar_Model_Invalida()
{
// arrange
var estabelecimentoVM = new EstabelecimentoViewModel();
var estabelecimento = Mapper.Map <EstabelecimentoViewModel, EstabelecimentoModel>(estabelecimentoVM);
controller.ModelState.AddModelError("key", "error");
// act
var result = controller.Create(estabelecimentoVM) as ViewResult;
// assert
repositoryMock.Verify(x => x.Create(estabelecimento), Times.Never());
var model = result.ViewData.Model as EstabelecimentoViewModel;
Assert.AreEqual(estabelecimentoVM, model);
Assert.AreEqual("Create", result.ViewName);
}
public void Testar_Nao_Cadastrar_CNPJ_Repetido()
{
// arrange
var estabelecimentoVM = new EstabelecimentoViewModel()
{
razao_social = "Estabelecimento 1",
cnpj = "94.335.598/0001-13"
};
var estabelecimento = Mapper.Map <EstabelecimentoViewModel, EstabelecimentoModel>(estabelecimentoVM);
var estabelecimentos = new List <EstabelecimentoModel>();
estabelecimentos.Add(new EstabelecimentoModel()
{
razao_social = "Estabelecimento 1", cnpj = "94.335.598/0001-13"
});
estabelecimentos.Add(new EstabelecimentoModel()
{
razao_social = "Estabelecimento 2", cnpj = "22.222.222/2222-22"
});
estabelecimentos.Add(new EstabelecimentoModel()
{
razao_social = "Estabelecimento 3", cnpj = "33.333.333/3333-33"
});
repositoryMock.Setup(x => x.FindByCnpj(estabelecimento.cnpj)).Returns(estabelecimentos.Where(x => x.cnpj == estabelecimento.cnpj).FirstOrDefault());
// act
var result = controller.Create(estabelecimentoVM) as ViewResult;
// assert
repositoryMock.Verify(x => x.Create(estabelecimento), Times.Never());
var model = result.ViewData.Model as EstabelecimentoViewModel;
Assert.AreEqual(estabelecimentoVM, model);
Assert.AreEqual("Create", result.ViewName);
}
public ActionResult Edit(EstabelecimentoViewModel estabelecimentoVM)
{
LoadModel(estabelecimentoVM);
if (ModelState.IsValid)
{
var model = Mapper.Map <EstabelecimentoViewModel, EstabelecimentoModel>(estabelecimentoVM);
var retorno = _estabelecimentoService.Edit(model);
if (retorno != ERetornoEstabelecimento.SucessoEdicao)
{
Alert(RetornoHelper.RetornoEstabelecimento(retorno), NotificationType.error);
return(View("Edit", estabelecimentoVM));
}
Alert(RetornoHelper.RetornoEstabelecimento(retorno), NotificationType.success);
return(RedirectToAction("Index"));
}
return(View("Edit", estabelecimentoVM));
}
public App()
{
InitializeComponent();
//Inicializa os Models que serao usados no app
entidadeVM = new EntidadeViewModel();
estabelecimentoVW = new EstabelecimentoViewModel();
controleViewModel = new ControleViewModel();
//Verifica se tem um entidade inserida no banco
var entidade = entidadeVM.GetLista <Entidade>();
//Se houver
if (entidade.Count > 0)
{
//se não estiver com login expirado
if (entidade[0].dt_expiracao > DateTime.Now)
{
//prepara os dados e vai para tela principal
//entidadeVM.DadosToVM(entidade[0]);
//entidadeVM.PerfilToLista(entidade[0]);
//estabelecimentoVW.EstabelecimentosVw(estabelecimentoVW.GetLista<Estabelecimento>());
//ScontroleViewModel.AddControles(estabelecimentoVW.ListaEstabelecimento);
entidadeVM.Email = entidade[0].email;
masterPageViewModel = new MasterPageViewModel();
GerenciaLoginAsync();
MainPage = new Main();
}
else
{
MainPage = new Login();
}
}
else
{
MainPage = new Login();
}
}
public EstabelecimentoViewModel PostEstabelecimento(EstabelecimentoViewModel estabelecimento)
{
var novoEstabelecimento = _mapper.Map <Estabelecimento>(estabelecimento);
return(_mapper.Map <EstabelecimentoViewModel>(_estabelecimentoAppService.Adicionar(novoEstabelecimento)));
}
private void LoadModel(EstabelecimentoViewModel model)
{
model.Categorias = new SelectList(_categoriaService.GetAll(), "id", "nome");
}
public IActionResult PutEstabelecimento(int id, EstabelecimentoViewModel estabelecimento)
{
estabelecimento.Id = id;
_estabelecimentoAppService.Atualizar(_mapper.Map <Estabelecimento>(estabelecimento));
return(NoContent());
}
public ActionResult Cadastrar(EstabelecimentoViewModel entidade)
{
if (ModelState.IsValid)
{
try
{
if (entidade?.Departamento?.Count > 0)
{
Estabelecimento obj = new Estabelecimento()
{
UniqueKey = Guid.NewGuid(),
NomeCompleto = entidade.NomeCompleto,
Codigo = entidade.Codigo,
Descricao = entidade.Descricao,
TipoDeEstabelecimento = entidade.TipoDeEstabelecimento,
UsuarioInclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login
};
EstabelecimentoBusiness.Inserir(obj);
if (entidade?.Departamento?.Count > 0)
{
foreach (string dep in entidade.Departamento)
{
REL_EstabelecimentoDepartamento rel = new REL_EstabelecimentoDepartamento()
{
UKEstabelecimento = obj.UniqueKey,
UKDepartamento = Guid.Parse(dep),
UsuarioInclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login
};
REL_EstabelecimentoDepartamentoBusiness.Inserir(rel);
}
}
}
else
{
throw new Exception("É necessário informar pelo menos um departamento para prosseguir com o cadastro do contrato.");
}
Extensions.GravaCookie("MensagemSucesso", "O Estabelecimento '" + entidade.NomeCompleto + "' foi cadastrado com sucesso!", 10);
return(Json(new { resultado = new RetornoJSON()
{
URL = Url.Action("Index", "Estabelecimento")
} }));
}
catch (Exception ex)
{
if (ex.GetBaseException() == null)
{
return(Json(new { resultado = new RetornoJSON()
{
Erro = ex.Message
} }));
}
else
{
return(Json(new { resultado = new RetornoJSON()
{
Erro = ex.GetBaseException().Message
} }));
}
}
}
else
{
return(Json(new { resultado = TratarRetornoValidacaoToJSON() }));
}
}
