public ActionResult Create(CardapioViewModel cardapioViewModel)
{
if (ModelState.IsValid)
{
try
{
Cardapio cardapio = new Cardapio();
cardapio = Mapper.Map <Cardapio>(cardapioViewModel);
cardapio.Id = Guid.NewGuid();
cardapio.TimesTamp = DateTime.Now;
uow.CardapiorRepositorio.Adcionar(cardapio);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Cadastrado com Sucesso!");
idPedido = cardapio.Id;
return(Json(new { Resultado = cardapio.Id.ToString() }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Ocorreu um erro ao Gravar o Registro!\n {0}", ex.Message);
}
finally
{
uow.Dispose();
}
}
return(View(cardapioViewModel));
}
public ActionResult Create([Bind(Include = "Id,Codigo,Descricao,Preco")] ProdutoViewModel produtoViewModel)
{
if (ModelState.IsValid)
{
try
{
Produto produto = new Produto();
produto = Mapper.Map <Produto>(produtoViewModel);
produto.Id = Guid.NewGuid();
produto.TimesTamp = DateTime.Now;
uow.ProdutoRepositorio.Adcionar(produto);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Cadastrado com Sucesso!");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Não Foi Possivel Gravar o Registro!\n {0}", ex.InnerException);
return(View());
}
finally
{
uow.Dispose();
}
}
return(View(produtoViewModel));
}
public ActionResult Create([Bind(Include = "Nome,Sigla,Id_Pais")] EstadoViewModel estadoViewModel)
{
if (ModelState.IsValid)
{
try
{
Estado estado = new Estado();
estado = Mapper.Map <Estado>(estadoViewModel);
estado.Id = Guid.NewGuid();
estado.TimesTamp = DateTime.Now;
uow.EstadoRepositorio.Adcionar(estado);
uow.Commit();
TempData["mensagem"] = string.Format("Estado {0} cadastrado com Sucesso!", estado.Nome);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Não foi possivel cadastrar o estado: {0}: \n {1}", estadoViewModel.Nome, ex.Message);
return(View(estadoViewModel));
}
finally
{
uow.Dispose();
}
}
return(View(estadoViewModel));
}
public async Task <StavkaMenija> DodajStavku(StavkaMenija s)
{
var stavka = unitOfWork.StavkaMenijaRepository.Add(s);
await unitOfWork.Commit();
return(stavka);
}
public async Task <Recenzija> DodajRecenziju(Recenzija r)
{
var recenzija = unitOfWork.RecenzijaRepository.Add(r);
await unitOfWork.Commit();
return(recenzija);
}
public async Task <Porudzbina> DodajPorudzbinu(Porudzbina d)
{
var porudzbina = unitOfWork.PorudzbinaRepository.Add(d);
await unitOfWork.Commit();
return(porudzbina);
}
// POST: ItensCardapioViewModels/Create
public ActionResult Create(Guid id_produto, Guid id_cardapio, int quantidade)
{
try
{
ItensCardapio itensCardapio = new ItensCardapio()
{
Id = Guid.NewGuid(),
Id_Produto = id_produto,
Id_Cardapio = id_cardapio,
Quantidade = quantidade
};
uow.ItensCardapioRepositorio.Adcionar(itensCardapio);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Cadastrado com Sucesso!");
return(Json(new { Resultado = itensCardapio.Id.ToString() }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Não Foi Possivel Gravar o Registro!\n {0}", ex.Message);
return(View());
}
finally
{
uow.Dispose();
}
}
public ActionResult Create([Bind(Include = "Id,RazaoSocial,Fantasia,Logradouro,NumeroEndereco,Bairro,Fone,Cnpj,Email,Cadastro,Id_Cep")] FornecedorViewModel fornecedorViewModel)
{
if (ModelState.IsValid)
{
try
{
Fornecedor fornecedor = new Fornecedor();
fornecedor = Mapper.Map <Fornecedor>(fornecedorViewModel);
fornecedor.Id = Guid.NewGuid();
fornecedor.TimesTamp = DateTime.Now;
uow.FornecedorRepositorio.Adcionar(fornecedor);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Cadastrado com Sucesso!");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Não Foi Possivel Gravar o Registro!\n {0}", ex.Message);
return(View());
}
finally
{
uow.Dispose();
}
}
return(View(fornecedorViewModel));
}
public ActionResult Create([Bind(Include = "Id,Codigo,Nome")] PaisViewModel paisViewModel)
{
if (ModelState.IsValid)
{
try
{
paisViewModel.Id = Guid.NewGuid();
Pais pais = new Pais();
pais = Mapper.Map <Pais>(paisViewModel);
pais.TimesTamp = DateTime.Now;
uow.PaisRepositorio.Adcionar(pais);
uow.Commit();
TempData["mensagem"] = string.Format("{0} : Foi Incluido com Sucesso", pais.Nome);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", string.Format("Erro ao Cadastrar Pais:\n {0}", ex.Message));
IEnumerable <PaisViewModel> lista = Mapper.Map <IEnumerable <PaisViewModel> >(uow.PaisRepositorio.GetTudo());
ViewBag.ListaPais = lista;
return(View());
}
finally
{
uow.Dispose();
}
}
return(View(paisViewModel));
}
public async Task <Korisnik> DodajKorisnika(Korisnik k)
{
var korisnik = unitOfWork.KorisnikRepository.Add(k);
await unitOfWork.Commit();
return(korisnik);
}
public Task CreateAsync(User user)
{
return(Task.Run(() =>
{
userRepository.Insert(user);
unitOfWork.Commit();
}));
}
public ActionResult Edit([Bind(Include = "Id,Nome,Login,Email,Senha,Adm,")] UsuarioViewModel usuarioViewModel)
{
if (ModelState.IsValid)
{
using (UnitOfWork.UnitOfWork uow = new UnitOfWork.UnitOfWork())
{
try
{
Usuario usuario = new Usuario();
usuario = Mapper.Map <Usuario>(usuarioViewModel);
usuario.Senha = Criptografia.Encrypt(usuario.Senha);
uow.UsuarioRepositorio.Atualizar(usuario);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Alterado Com Sucesso!");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Ocorreu ao Alterar o Registro!\n {0}", ex.Message);
return(RedirectToAction("Index"));
}
finally
{
uow.Dispose();
}
}
}
return(View(usuarioViewModel));
}
public ActionResult Edit([Bind(Include = "Id,Nome,Id_Estado")] CidadeViewModel cidadeViewModel)
{
if (ModelState.IsValid)
{
using (UnitOfWork.UnitOfWork uow = new UnitOfWork.UnitOfWork())
{
try
{
Cidade cidade = new Cidade();
cidade = Mapper.Map <Cidade>(cidadeViewModel);
cidade.TimesTamp = DateTime.Now;
uow.CidadeRepositorio.Atualizar(cidade);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Alterado Com Sucesso!");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Ocorreu ao Alterar o Registro!\n {0}", ex.Message);
return(RedirectToAction("Index"));
}
finally
{
uow.Dispose();
}
}
}
return(View(cidadeViewModel));
}
/// <summary>
/// Metodo responsavel por gerar o contas a receber do funcionario
/// </summary>
/// <remarks>
/// Autor: Luiz Fernando
/// Data: 29/04/2019
/// </remarks>
/// <param name="pedido">Recebe o pedido e gera o financeiro do mesmo</param>
/// <returns>true se deu certo e false caso tenha dado algum erro</returns>
///
public bool GerarContasReceber(Pedido pedido)
{
bool retorno = false;
try
{
using (UnitOfWork.UnitOfWork uow = new UnitOfWork.UnitOfWork())
{
//recupero o id do fornecedor
Guid idFornecedor = uow.CardapiorRepositorio.Get(x => x.Id == pedido.Id_Cardapio).Id_Fornecedor;
ContasReceber contasReceber = new ContasReceber
{
Id = Guid.NewGuid(),
Emissao = DateTime.Now,
Id_Pedido = pedido.Id,
Id_Fornecedor = idFornecedor,
Id_Usuario = pedido.Id_Usuario,
Quitado = false,
ValorPago = 0,
Valor = pedido.Total
};
uow.ContasReceberRepositorio.Adcionar(contasReceber);
uow.Commit();
retorno = true;
return(retorno);
}
}
catch (Exception ex)
{
retorno = false;
return(retorno);
}
}
public ActionResult Create([Bind(Include = "Id,Nome,Id_Estado")] CidadeViewModel cidadeViewModel)
{
if (ModelState.IsValid)
{
using (UnitOfWork.UnitOfWork uow = new UnitOfWork.UnitOfWork())
{
try
{
Cidade cidade = new Cidade();
cidade = Mapper.Map <Cidade>(cidadeViewModel);
cidade.Id = Guid.NewGuid();
cidade.TimesTamp = DateTime.Now;
uow.CidadeRepositorio.Adcionar(cidade);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Cadastrado com Sucesso!");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Não Foi Possivel Gravar o Registro!\n {0}", ex.Message);
return(View());
}
finally
{
uow.Dispose();
}
}
}
return(View(cidadeViewModel));
}
public ActionResult Register(UsuarioViewModel usuarioViewModel)
{
if (ModelState.IsValid)
{
try
{
using (UnitOfWork.UnitOfWork uow = new UnitOfWork.UnitOfWork())
{
Usuario usuario = new Usuario();
usuarioViewModel.Id = Guid.NewGuid();
usuario = Mapper.Map <Usuario>(usuarioViewModel);
usuario.Senha = Criptografia.Encrypt(usuario.Senha);
uow.UsuarioRepositorio.Adcionar(usuario);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Cadastrado com Sucesso!");
return(RedirectToAction("Index", "Home", null));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", string.Format("Registro Falhou\n {0}", ex.Message));
}
}
return(View(usuarioViewModel));
}
public string loginFireBase(FirebaseToken decodedToken, string tokenFcm)
{
string json = null;
string uid = decodedToken.Uid;
decodedToken.Claims.TryGetValue("email", out tmp);
string email = (string)tmp;
TokenUser tokenUser = new TokenUser
{
Username = email,
Uid = uid,
FcmToken = tokenFcm
};
var employee = _unitOfWork.Repository <Employee>().Find(e => e.Email.Equals(tokenUser.Username));
if (employee != null)
{
var tokenString = CommonUtils.GenerateJSONWebToken(_config, tokenUser);// convert JWT
tokenUser.JwtToken = tokenString;;
if (_unitOfWork.Repository <TokenUser>().Find(e => tokenUser.Uid.Equals(e.Uid)) == null)
{
_unitOfWork.Repository <TokenUser>().Insert(tokenUser);//add uid
_unitOfWork.Commit();
}
else
{
TokenUser updateToken = _unitOfWork.Repository <TokenUser>().Find(e => tokenUser.Uid == e.Uid);
updateToken.JwtToken = tokenString;
updateToken.FcmToken = tokenFcm;
_unitOfWork.Commit();
}
JObject newO = new JObject {
new JProperty("email", tokenUser.Username),
new JProperty("tokenString", tokenString),
new JProperty("id", employee.Id),
new JProperty("username", employee.Name),
new JProperty("image", employee.Image)
}; //add JWT in json response
json = JsonConvert.SerializeObject(newO, Formatting.Indented);
}
return(json);
}
public void InvokeDbContextCommitMethodOnce()
{
// Arrange
var mockDbContext = new Mock <ISportSquareDbContext>();
var unitOfWork = new UnitOfWork.UnitOfWork(mockDbContext.Object);
// Act
unitOfWork.Commit();
// Assert
mockDbContext.Verify(mock => mock.SaveChanges(), Times.Once());
}
public async Task <Sto> DodajSto(Sto s)
{
var sto = unitOfWork.StoRepository.Add(s);
await unitOfWork.Commit();
return(sto);
}
public ActionResult Create([Bind(Include = "Id,Emissao,Total,Id_Funcionario,Id_Cardapio")] PedidoViewModel pedidoViewModel)
{
if (ModelState.IsValid)
{
try
{
Pedido pedido = new Pedido();
pedido = Mapper.Map <Pedido>(pedidoViewModel);
pedido.Id = Guid.NewGuid();
//pego id do usuario logado pela session
pedido.Id_Usuario = Guid.Parse(Session["id_usuario"].ToString());
//pego total
var total = uow.ItensCardapioRepositorio.GetTudo(x => x.Id_Cardapio == pedido.Id_Cardapio).Sum(x => x.Produto.Preco);
pedido.Total = total;
uow.PedidoRepositorio.Adcionar(pedido);
uow.Commit();
//gera financeiro
GeraContasReceber geraContasReceber = new GeraContasReceber();
bool pedidoGerado = geraContasReceber.GerarContasReceber(pedido);
if (pedidoGerado)
{
TempData["mensagemPedido"] = "Financeiro Gerado com Sucesso";
}
else
{
TempData["mensagemPedido"] = "Não Foi Possível Gerar o Financeiro!";
}
TempData["mensagem"] = string.Format("Registro Cadastrado com Sucesso!");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Não Foi Possivel Gravar o Registro!\n {0}", ex.Message);
return(View());
}
}
return(View(pedidoViewModel));
}
public ActionResult Create([Bind(Include = "Id,Nome,Login,Email,Senha,Adm,Cadastro,Id_Funcionario,NomeFuncionario")] UsuarioViewModel usuarioViewModel)
{
if (ModelState.IsValid)
{
try
{
Usuario usuario = new Usuario();
usuarioViewModel.Id = Guid.NewGuid();
usuario = Mapper.Map <Usuario>(usuarioViewModel);
uow.UsuarioRepositorio.Adcionar(usuario);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Cadastrado com Sucesso!");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Não Foi Possivel Gravar o Registro!\n {0}", ex.Message);
return(View());
}
}
return(View(usuarioViewModel));
}
public ActionResult Create([Bind(Include = "Id,_Cep,Id_Cidade")] CepViewModel cepViewModel)
{
if (ModelState.IsValid)
{
try
{
Cep cep = new Cep();
cep = Mapper.Map <Cep>(cepViewModel);
cep.Id = Guid.NewGuid();
cep.TimesTamp = DateTime.Now;
uow.CepRepositorio.Adcionar(cep);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Cadastrado com Sucesso!");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", string.Format("Não Foi Possivel Gravar o Registro!\n {0}", ex.Message));
return(View());
}
}
return(View(cepViewModel));
}
public async Task <Racun> DodajRacun(Racun r)
{
Racun racun = new Racun
{
Iznos = r.Iznos,
ListaPorudzbina = new List <Porudzbina>(),
StoId = r.StoId,
Vreme = r.Vreme
};
Racun res = unitOfWork.RacunRepository.Add(racun);
await unitOfWork.Commit();
foreach (Porudzbina p in r.ListaPorudzbina)
{
Porudzbina porudzbina = new Porudzbina
{
KorisnikId = p.KorisnikId,
RacunId = res.Id,
StavkaMenijaId = p.StavkaMenijaId
};
await this.porudzbinaService.DodajPorudzbinu(porudzbina);
}
return(res);
}
public ActionResult DeleteConfirmed(Guid id)
{
using (UnitOfWork.UnitOfWork uow = new UnitOfWork.UnitOfWork())
{
try
{
Usuario usuario = new Usuario();
usuario = uow.UsuarioRepositorio.Get(x => x.Id == id);
uow.UsuarioRepositorio.Deletar(usuario);
uow.Commit();
TempData["mensagem"] = string.Format("Registro Excluido com sucesso");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["mensagem"] = string.Format("Ocorreu um Erro ao excluir o registro!\n {0}", ex.Message);
return(RedirectToAction("Index"));
}
finally
{
uow.Dispose();
}
}
}