Esempio n. 1
0
        private int getSaldoSuficiente(CaixaSaque caixa)
        {
            var result = db.Nota.Where(t => t.CaixaId == caixa.Caixa.CaixaId).Sum(i => (i.NotaQuantidade * i.NotaValor));
            int saldo  = result != null ? result - caixa.valorSaque : -1;

            return(saldo);
        }
Esempio n. 2
0
        public JsonResult saque(CaixaSaque caixasaque)
        {
            JsonResult result;

            if (caixasaque.valorSaque < 0 || caixasaque.valorSaque > 10000)
            {
                return(new JsonResult("Não permitido."));
            }
            if (getSaldoSuficiente(caixasaque) < 0)
            {
                return(new JsonResult("Não há saldo suficiente"));
            }

            List <Nota> totalNotas = sacaNotas(caixasaque);

            if (totalNotas.Count() != 0)
            {
                result = atualizaNotas(caixasaque, totalNotas);
            }
            else
            {
                result = new JsonResult("Notas insuficientes");
            }



            //result = new JsonResult("saque ok!");
            SGCAController sgca = new SGCAController(_configuration);

            _hub.Clients.All.SendAsync("transfercaixadata", sgca.GetSignalStatus());//sinaliza o sgca
            //_hub.Clients.All.SendAsync("caixaativoevent", this.getCaixaAtivo());
            _hub.Clients.All.SendAsync("caixaativoevent", result);

            return(new JsonResult(result));
        }
Esempio n. 3
0
        //TODO colocar na tela as notas disponiveis . !!
        private List <Nota> sacaNotas(CaixaSaque caixaSaque)
        {
            List <Nota> totalNotas = new List <Nota>();
            Nota        nota;
            int         qtdEmCaixa = 0;
            var         caixa      = db.Caixas.Where(x => x.CaixaId == caixaSaque.Caixa.CaixaId).FirstOrDefault();
            int         valor      = caixaSaque.valorSaque;

            int[] notasDisponiveis = db.Nota.Where(x => x.CaixaId == caixaSaque.Caixa.CaixaId && x.NotaQuantidade > 0).OrderBy(x => x.NotaValor).Select(x => x.NotaValor).ToArray <int>();

            //if (notasDisponiveis.Sum() < caixa.valorSaque)
            //return totalNotas;

            int i;

            for (i = 0; i < notasDisponiveis.Count(); i++)
            {
                if (notasDisponiveis[i] > caixaSaque.valorSaque)
                {
                    break;
                }
            }

            i--;
            while (i >= 0)
            {
                nota                = new Nota();
                nota.NotaValor      = notasDisponiveis[i];
                nota.NotaQuantidade = valor / notasDisponiveis[i];
                qtdEmCaixa          = db.Nota.Where(x => x.CaixaId == caixaSaque.Caixa.CaixaId && x.NotaValor == nota.NotaValor).FirstOrDefault().NotaQuantidade;


                if (nota.NotaQuantidade >= qtdEmCaixa || (qtdEmCaixa - nota.NotaQuantidade) <= caixa.CaixaQtdCritica)
                {
                    i--;
                    continue;
                }

                valor -= (nota.NotaValor * nota.NotaQuantidade);
                if (nota.NotaQuantidade > 0)
                {
                    totalNotas.Add(nota);
                }

                if (valor % notasDisponiveis[i] == 0)
                {
                    break;
                }
                i--;
            }
            if (valor > 0)
            {
                //caixa.CaixaSituacao = "Inativo";
                db.SaveChanges();
                totalNotas.Clear();//notas disponiveis não podem fechar o valor pedido
            }

            return(totalNotas);
        }
Esempio n. 4
0
        private JsonResult atualizaNotas(CaixaSaque caixasaque, List <Nota> totalNotas)
        {
            var existingCaixa = db.Caixas.Where(x => x.CaixaId == caixasaque.Caixa.CaixaId).FirstOrDefault();
            var existingNota  = db.Nota.Where(x => x.CaixaId == caixasaque.Caixa.CaixaId);

            var data = db.Caixas.Join(
                db.Nota,
                caixa => caixa.CaixaId,
                nota => nota.CaixaId,
                (caixa, nota) => new
            {
                CaixaId         = caixa.CaixaId,
                NotaId          = nota.NotaId,
                CaixaQtdCritica = caixa.CaixaQtdCritica,
                CaixaSituacao   = caixa.CaixaSituacao,
                NotaQuantidade  = nota.NotaQuantidade,
                NotaValor       = nota.NotaValor
            }
                ).Where(a => a.CaixaId == caixasaque.Caixa.CaixaId);

            for (int i = 0; i < totalNotas.Count; i++)
            {
                if (data.Where(x => x.NotaValor == totalNotas[i].NotaValor && x.NotaQuantidade >= totalNotas[i].NotaQuantidade) != null)
                {
                    existingNota.Where(x => x.NotaValor == totalNotas[i].NotaValor).FirstOrDefault().NotaQuantidade -= totalNotas[i].NotaQuantidade;

                    db.SaveChanges();

                    if (existingNota.Where(x => x.NotaValor == totalNotas[i].NotaValor).FirstOrDefault().NotaQuantidade <= caixasaque.Caixa.CaixaQtdCritica)
                    {
                        caixasaque.Caixa.CaixaSituacao = "Inativo";
                    }
                }
            }
            return(new JsonResult("saque realizado com sucesso."));
        }