示例#1
0
        public bool MovimentarCaixa(Tipo_movimentacao_caixa tipo_mov,
                                    decimal valor,
                                    int forma_pagamento_id,
                                    int usuario_id,
                                    int movimento_id,
                                    string descricao)
        {
            if (string.IsNullOrWhiteSpace(descricao))
            {
                MessageBox.Show("Informe o motivo", "Atenção", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                return(false);
            }

            if (usuario_id == 0)
            {
                MessageBox.Show("Informe o usuário", "Atenção", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                return(false);
            }

            if (forma_pagamento_id == 0)
            {
                MessageBox.Show("Informe a condição de pagamento", "Atenção", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                return(false);
            }

            if (tipo_mov == Tipo_movimentacao_caixa.SAIDA)
            {
                Formas_pagamento fpg = new Formas_pagamentoController().Find(forma_pagamento_id);
                if (fpg.Tipo_pagamento != (int)Tipo_pagamento.DINHEIRO)
                {
                    MessageBox.Show("A condição de pagamento para movimentações de saída no caixa deve ser do tipo 'DINHEIRO'", "Confição de pagamento incompatível", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                    return(false);
                }
            }

            Movimentos_caixas mc = new Movimentos_caixas();

            mc.Caixa_id           = Get_ID_CaixaAtualUsuario();
            mc.Forma_pagamento_id = forma_pagamento_id;
            mc.Loja_id            = UsuariosController.LojaAtual.Id;
            mc.Usuario_id         = usuario_id;
            mc.Valor = (tipo_mov == Tipo_movimentacao_caixa.ABERTURA || tipo_mov == Tipo_movimentacao_caixa.ENTRADA
                ? valor
                : valor * (-1));
            mc.Data         = DateTime.Now;
            mc.Movimento_id = movimento_id;
            mc.Tipo_mov     = (int)tipo_mov;
            mc.Descricao    = descricao;

            return(Save(mc));
        }
示例#2
0
        public List <KeyValuePair <Formas_pagamento, decimal> > GetTotaisPorFormaPagamentoCaixaAtual()
        {
            int ultmaAbertura    = GetUltimoMovimentoAbertura().Id;
            int caixa_id         = Get_ID_CaixaAtualUsuario();
            int tipoMov_abertura = (int)Tipo_movimentacao_caixa.ABERTURA;

            List <Movimentos_caixas> movimentos      = GetMovimentosCaixaAtual();
            List <Movimentos_caixas> distinctFormaPg = movimentos.GroupBy(e => e.Forma_pagamento_id).Select(mov => mov.First()).ToList();
            List <KeyValuePair <Formas_pagamento, decimal> > result = new List <KeyValuePair <Formas_pagamento, decimal> >();

            Formas_pagamentoController fpgController = new Formas_pagamentoController();

            foreach (Movimentos_caixas mov in distinctFormaPg)
            {
                Formas_pagamento fpg = fpgController.Find(mov.Forma_pagamento_id);
                result.Add(new KeyValuePair <Formas_pagamento, decimal>(fpg, movimentos.Where(e => e.Forma_pagamento_id == mov.Forma_pagamento_id).Sum(e => e.Valor)));
            }

            return(result);
        }
示例#3
0
        public void CupomNaoFiscal()
        {
            DsCupomNaoFiscal dataSet     = new DsCupomNaoFiscal();
            DataTable        dtMovimento = dataSet.Tables["Movimento"];

            EstoqueController          eController        = new EstoqueController();
            Grades_produtosController  gController        = new Grades_produtosController();
            UnidadesController         unController       = new UnidadesController();
            UsuariosController         usuariosController = new UsuariosController();
            ClientesController         clientesController = new ClientesController();
            Tipos_movimentoController  tipoMovController  = new Tipos_movimentoController();
            Formas_pagamentoController fpgController      = new Formas_pagamentoController();

            if (Movimento.Usuarios == null)
            {
                Movimento.Usuarios = new UsuariosController().Find(Movimento.Usuario_id);
            }

            #region MOVIMENTO
            dtMovimento.Rows.Add(
                Movimento.Id,
                UsuariosController.LojaAtual.Nome_fantasia,
                Movimento.Usuarios.Vendedores.Count == 0 ? Movimento.Usuarios.Nome : Movimento.Usuarios.Vendedores.First().Nome,
                Movimento.Cliente_id == 0 ? "Não identificado" : clientesController.Find(Movimento.Cliente_id).Nome,
                GetTotalParcial(),
                GetTotalDesconto(),
                Movimento.Data,
                "",
                $"{UsuariosController.LojaAtual.Logradouro}, {UsuariosController.LojaAtual.Bairro} - {UsuariosController.LojaAtual.Municipio}",
                tipoMovController.Find(Movimento.Tipo_movimento_id).Descricao,
                UsuariosController.LojaAtual.Cnpj);
            #endregion

            #region ITENS_PAGAMENTO
            DataTable dtItens_pag = dataSet.Tables["Itens_pagamento"];
            itens_pag.ForEach(e => dtItens_pag.Rows.Add(
                                  fpgController.Find(e.Forma_pagamento_id).Descricao,
                                  e.Valor
                                  ));
            #endregion

            #region ITENS_MOVIMENTO
            DataTable dtItens_mov = dataSet.Tables["Itens_movimento"];
            foreach (Itens_movimento item in Itens_movimento)
            {
                string cod_prod                 = string.Empty;
                string descricaoProdo           = item.Produtos.Descricao;
                string descricao_valor_unitario = string.Empty;

                if (!string.IsNullOrEmpty(item.Lote))
                {
                    cod_prod = item.Lote + "SL" + item.Sublote;
                }
                else if (item.Grade_id != null)
                {
                    Grades_produtos grade = gController.Find(item.Grade_id);

                    cod_prod        = item.Grade_id;
                    descricaoProdo += $" {grade.Cores.Descricao} {grade.Tamanhos.Descricao}";
                }
                else
                {
                    cod_prod = item.Produtos.Ean;
                }

                if (item.Unidades == null)
                {
                    item.Unidades = unController.Find(item.Unidade_id);
                }
                descricao_valor_unitario = $"{item.Quant} {item.Unidades.Sigla} x R${item.Valor_unit}";
                dtItens_mov.Rows.Add(item.Id, cod_prod, descricaoProdo, descricao_valor_unitario, item.Quant, item.Valor_final);
            }
            #endregion

            IControllerReport rController = ReportController.GetInstance();
            rController.AddDataSource("Itens_movimento", dtItens_mov);
            rController.AddDataSource("Itens_pagamento", dtItens_pag);
            rController.AddDataSource("Movimento", dtMovimento);

            rController.ShowReport("MOVIMENTO", "MOV001");
        }
示例#4
0
        /// <summary>
        ///
        /// </summary>
        /// <returns>Código do movimento caso seja efetuado com sucesso. Caso haja erros, retornará 0.</returns>
        public int FechaMovimento(decimal troco)
        {
            UnitOfWork unit = new UnitOfWork(true);

            try
            {
                unit.BeginTransaction();
                db.Context = unit.Context;

                if (itens_mov == null)
                {
                    itens_mov = Movimento.Itens_movimento.ToList();
                }
                Movimento.Itens_movimento.Clear();

                if (itens_pag == null)
                {
                    itens_pag = Movimento.Itens_pagamento.ToList();
                }
                Movimento.Itens_pagamento.Clear();

                Movimentos_caixasController movimentos_caixaController = new Movimentos_caixasController();
                movimentos_caixaController.SetContext(unit.Context);

                Formas_pagamentoController fpg_controller = new Formas_pagamentoController();
                fpg_controller.SetContext(unit.Context);

                Tipos_movimentoController tmc = new Tipos_movimentoController();
                tmc.SetContext(unit.Context);

                Tipos_movimento tipo_mov = tmc.Find(Movimento.Tipo_movimento_id);

                Movimento.Id         = db.NextId(e => e.Id);
                Movimento.Data       = DateTime.Now;
                Movimento.Usuario_id = UsuariosController.UsuarioAtual.Id;
                Movimento.Loja_id    = UsuariosController.LojaAtual.Id;

                db.Save(Movimento);
                db.Commit();

                if (troco > 0)
                {
                    int tipo_pg_dinheiro      = (int)Tipo_pagamento.DINHEIRO;
                    Formas_pagamento fpgTroco = fpg_controller.Get(e => e.Tipo_pagamento == tipo_pg_dinheiro);

                    Movimentos_caixas mcTroco = new Movimentos_caixas();
                    mcTroco.Descricao          = $"Movimento {Movimento.Id} (TROCO)";
                    mcTroco.Caixa_id           = movimentos_caixaController.Get_ID_CaixaAtualUsuario();
                    mcTroco.Data               = Movimento.Data;
                    mcTroco.Movimento_id       = Movimento.Id;
                    mcTroco.Usuario_id         = Movimento.Usuario_id;
                    mcTroco.Forma_pagamento_id = fpgTroco.Id;
                    mcTroco.Loja_id            = UsuariosController.LojaAtual.Id;
                    mcTroco.Tipo_mov           = (int)Tipo_movimentacao_caixa.TROCO;
                    mcTroco.Valor              = (troco * (-1));

                    if (!movimentos_caixaController.Save(mcTroco))
                    {
                        unit.RollBack();
                        return(0);
                    }
                }

                Itens_movimentoController imc = new Itens_movimentoController();
                imc.SetContext(unit.Context);

                EstoqueController estoque_controller = new EstoqueController();
                estoque_controller.SetContext(unit.Context);

                string lote = imc.GetLastLote(false);
                lote = estoque_controller.GeraProximoLote(lote);
                int sublote = 1;

                #region Itens do movimento
                foreach (Itens_movimento item in itens_mov)
                {
                    item.Produtos     = null;
                    item.Unidades     = null;
                    item.Movimento_id = Movimento.Id;

                    Estoque e = new Estoque();
                    e.Produto_id = item.Produto_id;
                    e.Loja_id    = UsuariosController.LojaAtual.Id;
                    e.Quant      = item.Quant;
                    e.Lote       = (string.IsNullOrEmpty(item.Lote)
                            ? null
                            : (item.Lote + "SL" + item.Sublote));
                    e.Grade_id = item.Grade_id;

                    ProdutosController pc = new ProdutosController();
                    pc.SetContext(unit.Context);
                    Produtos prod = pc.Find(item.Produto_id);

                    Produtos_fornecedoresController pForn_c = new Produtos_fornecedoresController();
                    pForn_c.SetContext(unit.Context);

                    switch (tipo_mov.Movimentacao_itens)
                    {
                    case (int)Tipo_movimentacao.ENTRADA:

                        /*
                         *   O produto controla Lote, e a sua entrada é vinda de um Fornecedor.
                         *   Neste caso é gerado o seu Lote e inserido no estoque da
                         *   loja em questão
                         */
                        #region tipo_mov.Utiliza_fornecedor && prod.Controla_lote
                        if (tipo_mov.Utiliza_fornecedor && prod.Controla_lote)
                        {
                            e.Lote         = lote;
                            e.Sublote      = sublote.ToString();
                            e.Data_entrada = DateTime.Now;

                            Produtos_fornecedores pf = pForn_c.Find(item.Produto_id, Movimento.Fornecedor_id);
                            if (pf != null)
                            {
                                item.Quant = (item.Quant * pf.Fator_conversao);
                            }

                            estoque_controller.Save(e);
                            sublote++;

                            break;
                        }
                        #endregion

                        #region tipo_mov.Utiliza_fornecedor && !prod.Controla_lote
                        if (tipo_mov.Utiliza_fornecedor && !prod.Controla_lote)
                        {
                            Produtos_fornecedores pf = pForn_c.Find(item.Produto_id, Movimento.Fornecedor_id);
                            if (pf != null)
                            {
                                item.Quant = (item.Quant * pf.Fator_conversao);
                            }

                            if (!estoque_controller.InsereEstoque(item.Quant, item.Produto_id, Movimento.Loja_id, (item.Lote + "SL" + item.Sublote)))
                            {
                                unit.RollBack();
                                return(0);
                            }

                            break;
                        }
                        #endregion

                        /*
                         *   O produto controla Lote, porém sua entrada NÃO é proveniennte de um fornecedor.
                         *   Pode ser uma devolução, troca ou entrada por transferencia de loja.
                         *
                         *   Neste caso, é verificado se existe o lote em questão.
                         *   Caso não exista, será criado,
                         *   Caso exista, o Saldo em Estoque do mesmo será atualizado
                         */
                        #region (!tipo_mov.Utiliza_fornecedor) && prod.Controla_lote
                        if ((!tipo_mov.Utiliza_fornecedor) && prod.Controla_lote)
                        {
                            if (!estoque_controller.ExisteLote(item.Lote, item.Sublote))
                            {
                                estoque_controller.CriaLote(item.Produto_id, Movimento.Loja_id, item.Lote, item.Sublote);
                            }

                            if (!estoque_controller.InsereEstoque(item.Quant, item.Produto_id, Movimento.Loja_id, (item.Lote + "SL" + item.Sublote)))
                            {
                                unit.RollBack();
                                return(0);
                            }

                            break;
                        }
                        #endregion

                        #region prod.Controla_grade
                        if (prod.Controla_grade)
                        {
                            if (!estoque_controller.InsereEstoque(item.Quant, item.Produto_id, Movimento.Loja_id, null, item.Grade_id))
                            {
                                unit.RollBack();
                                return(0);
                            }

                            break;
                        }
                        #endregion

                        /*
                         *  O produto NÃO controla lote, e sua entrada NÃO é proveniente de um fornecedor.
                         *  Neste caso, o estoque será inserido levando em consideração o produto pelo seu código.
                         *
                         *  OBS.: Quando um produto NÃO possui lotes em estoque, a tabela de Estoque só pode
                         *  conter um unico registro referente ao produto em questão, considerando a Loja.
                         *
                         *  Quando o produto POSSUI lotes em estoque, a tabela de estoque pode conter varios
                         *  registros referente ao produto em questão, levando em consideração o Lote, Sub-Lote
                         *  e respectiva Loja.
                         */
                        #region !tipo_mov.Utiliza_fornecedor && !prod.Controla_lote
                        if (!tipo_mov.Utiliza_fornecedor && !prod.Controla_lote)
                        {
                            if (!estoque_controller.InsereEstoque(item.Quant, item.Produto_id, Movimento.Loja_id))
                            {
                                unit.RollBack();
                                return(0);
                            }

                            break;
                        }
                        #endregion

                        break;

                    case (int)Tipo_movimentacao.SAIDA:

                        string loteEst = (string.IsNullOrEmpty(e.Lote)
                                ? null
                                : e.Lote);

                        if (!estoque_controller.RetiraEstoque(e.Quant, e.Produto_id, e.Loja_id, loteEst, item.Grade_id))
                        {
                            unit.RollBack();
                            return(0);
                        }

                        break;
                    }

                    if (e.Lote != null)
                    {
                        if (e.Lote.Contains("SL"))
                        {
                            item.Lote    = e.Lote.Substring(0, e.Lote.IndexOf("SL"));
                            item.Sublote = e.Lote.Substring(e.Lote.IndexOf("SL") + 2);
                        }
                        else
                        {
                            item.Lote    = e.Lote;
                            item.Sublote = e.Sublote;
                        }
                    }

                    if (!imc.Save(item))
                    {
                        unit.RollBack();
                        return(0);
                    }
                }
                #endregion

                int numero_parcela = 1;

                #region Itens do Pagamento
                foreach (Itens_pagamento item_pg in itens_pag)
                {
                    if (tipo_mov.Movimentacao_valores == (int)Tipo_movimentacao.NENHUM)
                    {
                        continue;
                    }

                    item_pg.Movimento_id = Movimento.Id;

                    ContasController contas_controller = new ContasController();
                    contas_controller.SetContext(unit.Context);

                    Itens_pagamentoController ipc = new Itens_pagamentoController();
                    ipc.SetContext(unit.Context);

                    if (!ipc.Save(item_pg))
                    {
                        unit.RollBack();
                        return(0);
                    }

                    Formas_pagamento forma_pagamento = fpg_controller.Find(item_pg.Forma_pagamento_id);

                    Movimentos_caixas movimento_caixa = new Movimentos_caixas();
                    movimento_caixa.Descricao          = $"Movimento {Movimento.Id} ({(tipo_mov.Movimentacao_valores == (int)Tipo_movimentacao.ENTRADA ? "ENTRADA" : "SAIDA")})";
                    movimento_caixa.Caixa_id           = movimentos_caixaController.Get_ID_CaixaAtualUsuario();
                    movimento_caixa.Data               = Movimento.Data;
                    movimento_caixa.Movimento_id       = Movimento.Id;
                    movimento_caixa.Usuario_id         = Movimento.Usuario_id;
                    movimento_caixa.Forma_pagamento_id = item_pg.Forma_pagamento_id;
                    movimento_caixa.Loja_id            = UsuariosController.LojaAtual.Id;

                    ParcelasController parcController = new ParcelasController();
                    parcController.SetContext(unit.Context);

                    switch (forma_pagamento.Tipo_pagamento)
                    {
                        #region DINHEIRO
                    case (int)Tipo_pagamento.DINHEIRO:

                        switch (tipo_mov.Movimentacao_valores)
                        {
                        case (int)Tipo_movimentacao.ENTRADA:
                            movimento_caixa.Tipo_mov = (int)Tipo_movimentacao_caixa.ENTRADA;
                            movimento_caixa.Valor    = item_pg.Valor;
                            break;

                        case (int)Tipo_movimentacao.SAIDA:
                            movimento_caixa.Tipo_mov = (int)Tipo_movimentacao_caixa.SAIDA;
                            movimento_caixa.Valor    = (item_pg.Valor * (-1));
                            break;
                        }

                        break;
                        #endregion

                        #region CARTAO
                    case (int)Tipo_pagamento.CARTAO:

                        movimento_caixa.Valor = 0;

                        Operadoras_cartaoController opController = new Operadoras_cartaoController();
                        opController.SetContext(unit.Context);

                        Operadoras_cartao operadora = opController.Find(forma_pagamento.Operadora_cartao_id);

                        Parcelas parcela_cartao = new Parcelas();
                        parcela_cartao.Item_pagamento_id = item_pg.Id;
                        parcela_cartao.Valor             = item_pg.Valor;
                        parcela_cartao.Situacao          = (int)Situacao_parcela.EM_ABERTO;
                        parcela_cartao.Data_lancamento   = Movimento.Data;

                        parcela_cartao.Data_vencimento = (operadora.Tipo_recebimento == (int)Tipo_prazo_operadora.DIAS
                                ? Movimento.Data.AddDays(operadora.Prazo_recebimento)
                                : Movimento.Data.AddHours(operadora.Prazo_recebimento));
                        parcela_cartao.Portador = forma_pagamento.Conta_id;

                        if (tipo_mov.Movimentacao_valores == (int)Tipo_movimentacao.ENTRADA)
                        {
                            parcela_cartao.Tipo_parcela = (int)Tipo_parcela.RECEBER;
                            parcela_cartao.Cliente_id   = Movimento.Cliente_id;

                            movimento_caixa.Tipo_mov = (int)Tipo_movimentacao_caixa.ENTRADA;
                            movimento_caixa.Valor    = item_pg.Valor;
                        }

                        if (tipo_mov.Movimentacao_valores == (int)Tipo_movimentacao.SAIDA)
                        {
                            parcela_cartao.Tipo_parcela  = (int)Tipo_parcela.PAGAR;
                            parcela_cartao.Fornecedor_id = Movimento.Cliente_id;

                            movimento_caixa.Tipo_mov = (int)Tipo_movimentacao_caixa.SAIDA;
                            movimento_caixa.Valor    = item_pg.Valor * (-1);
                        }

                        parcela_cartao.Num_documento     = Movimento.Id.ToString().PadLeft(8 - Movimento.Id.ToString().Length, '0') + "-" + numero_parcela;
                        parcela_cartao.Parcela_descricao = $"REFERENTE AO MOVIMENTO {Movimento.Id} ({tipo_mov.Descricao})";
                        parcela_cartao.Numero_cheque     = string.Empty;
                        parcela_cartao.Banco             = string.Empty;
                        parcela_cartao.Agencia           = string.Empty;
                        parcela_cartao.Dias_compensacao  = 0;
                        parcela_cartao.Conta             = string.Empty;

                        if (!parcController.Save(parcela_cartao))
                        {
                            unit.RollBack();
                            return(0);
                        }
                        numero_parcela++;
                        break;
                        #endregion

                        #region CHEQUE
                    case (int)Tipo_pagamento.CHEQUE:

                        movimento_caixa.Valor = 0;
                        IRegistroCheques registroCheques;

                        if (tipo_mov.Movimentacao_valores == (int)Tipo_movimentacao.ENTRADA)
                        {
                            registroCheques          = new RecebimentoCheques();
                            movimento_caixa.Tipo_mov = (int)Tipo_movimentacao_caixa.ENTRADA;
                            movimento_caixa.Valor    = item_pg.Valor;
                        }
                        else
                        {
                            registroCheques = new LancamentoCheque();
                            registroCheques.SetConta(contas_controller.Find(forma_pagamento.Conta_id));

                            movimento_caixa.Tipo_mov = (int)Tipo_movimentacao_caixa.SAIDA;
                            movimento_caixa.Valor    = item_pg.Valor * (-1);
                        }

                        registroCheques.Exibir(item_pg.Valor);

                        foreach (Cheque cheque in registroCheques.Cheques)
                        {
                            Parcelas parcela_cheque = new Parcelas();

                            parcela_cheque.Item_pagamento_id = item_pg.Id;
                            parcela_cheque.Valor             = cheque.Valor;
                            parcela_cheque.Situacao          = (int)Situacao_parcela.EM_ABERTO;
                            parcela_cheque.Data_lancamento   = Movimento.Data;
                            parcela_cheque.Num_documento     = Movimento.Id.ToString().PadLeft(8 - Movimento.Id.ToString().Length, '0') + "-" + numero_parcela;
                            parcela_cheque.Parcela_descricao = $"REFERENTE AO MOVIMENTO {Movimento.Id} ({tipo_mov.Descricao})";
                            parcela_cheque.Data_vencimento   = cheque.Data_deposito;

                            if (tipo_mov.Movimentacao_valores == (int)Tipo_movimentacao.ENTRADA)
                            {
                                parcela_cheque.Tipo_parcela = (int)Tipo_parcela.RECEBER;
                                parcela_cheque.Cliente_id   = Movimento.Cliente_id;

                                parcela_cheque.Numero_cheque    = cheque.Numero_cheque;
                                parcela_cheque.Banco            = cheque.Banco;
                                parcela_cheque.Agencia          = cheque.Agencia;
                                parcela_cheque.Dias_compensacao = cheque.Dias_compensacao;
                                parcela_cheque.Conta            = cheque.Conta;
                            }

                            if (tipo_mov.Movimentacao_valores == (int)Tipo_movimentacao.SAIDA)
                            {
                                parcela_cheque.Tipo_parcela  = (int)Tipo_parcela.PAGAR;
                                parcela_cheque.Fornecedor_id = Movimento.Fornecedor_id;

                                parcela_cheque.Portador         = forma_pagamento.Conta_id;
                                parcela_cheque.Numero_cheque    = cheque.Numero_cheque;
                                parcela_cheque.Banco            = string.Empty;
                                parcela_cheque.Agencia          = string.Empty;
                                parcela_cheque.Dias_compensacao = 0;
                                parcela_cheque.Conta            = string.Empty;
                            }

                            if (!parcController.Save(parcela_cheque))
                            {
                                unit.RollBack();
                                return(0);
                            }

                            numero_parcela++;
                        }

                        break;
                        #endregion

                        #region PRAZO
                    case (int)Tipo_pagamento.PRAZO:

                        DateTime data_base = (forma_pagamento.Tipo_intervalo == (int)Tipo_intervalo.DATA_BASE
                                ? DateTime.Now.AddMonths(1)
                                : DateTime.Now.AddDays(forma_pagamento.Intervalo)); //baseando a data para o mes sequente ao atual

                        for (int i = 0; i < forma_pagamento.Parcelas; i++)
                        {
                            Parcelas parcela_prazo = new Parcelas();

                            parcela_prazo.Item_pagamento_id = item_pg.Id;
                            parcela_prazo.Valor             = (item_pg.Valor / forma_pagamento.Parcelas);
                            parcela_prazo.Situacao          = (int)Situacao_parcela.EM_ABERTO;
                            parcela_prazo.Data_lancamento   = Movimento.Data;
                            parcela_prazo.Parcela_descricao = $"REFERENTE AO MOVIMENTO {Movimento.Id} ({tipo_mov.Descricao})";
                            parcela_prazo.Num_documento     = Movimento.Id.ToString().PadLeft(8 - Movimento.Id.ToString().Length, '0') + "-" + numero_parcela;
                            parcela_prazo.Numero_cheque     = string.Empty;
                            parcela_prazo.Banco             = string.Empty;
                            parcela_prazo.Agencia           = string.Empty;
                            parcela_prazo.Dias_compensacao  = 0;
                            parcela_prazo.Conta             = string.Empty;

                            if (forma_pagamento.Tipo_intervalo == (int)Tipo_intervalo.DATA_BASE)
                            {
                                data_base = new DateTime(data_base.Year, data_base.Month, forma_pagamento.Dia_base);
                                parcela_prazo.Data_vencimento = data_base;
                                data_base = data_base.AddMonths(1);
                            }

                            if (forma_pagamento.Tipo_intervalo == (int)Tipo_intervalo.INTERVALO)
                            {
                                parcela_prazo.Data_vencimento = data_base;
                                data_base = data_base.AddDays(forma_pagamento.Intervalo);
                            }

                            if (tipo_mov.Movimentacao_valores == (int)Tipo_movimentacao.ENTRADA)
                            {
                                parcela_prazo.Tipo_parcela = (int)Tipo_parcela.RECEBER;
                                parcela_prazo.Cliente_id   = Movimento.Cliente_id;

                                movimento_caixa.Tipo_mov = (int)Tipo_movimentacao_caixa.ENTRADA;
                                movimento_caixa.Valor    = item_pg.Valor;
                            }

                            if (tipo_mov.Movimentacao_valores == (int)Tipo_movimentacao.SAIDA)
                            {
                                parcela_prazo.Tipo_parcela  = (int)Tipo_parcela.PAGAR;
                                parcela_prazo.Fornecedor_id = Movimento.Fornecedor_id;

                                movimento_caixa.Tipo_mov = (int)Tipo_movimentacao_caixa.SAIDA;
                                movimento_caixa.Valor    = item_pg.Valor * (-1);
                            }

                            if (!parcController.Save(parcela_prazo))
                            {
                                unit.RollBack();
                                return(0);
                            }

                            numero_parcela++;
                        }
                        break;
                        #endregion
                    }

                    if (!movimentos_caixaController.Save(movimento_caixa))
                    {
                        unit.RollBack();
                        return(0);
                    }
                }
                #endregion

                if (Pedido_venda != null)
                {
                    Pedidos_vendaController pedidosController = new Pedidos_vendaController();
                    pedidosController.SetContext(unit.Context);

                    pedidosController.RemovePedido(Pedido_venda.Id);
                }

                unit.Commit();
                BStatus.Success("Movimento salvo");
                return(Movimento.Id);
            }
            catch (Exception ex)
            {
                unit.RollBack();
                return(0);
            }
        }
示例#5
0
        public void NFCe()
        {
            int retorno = 0;
            //  Declaracoes.tCFCancelar_NFCe_Daruma("", "", "", "", "");
            Clientes cliente = new ClientesController().Find(Movimento.Cliente_id);

            if (cliente == null || cliente.Cpf.Equals("___.___.___-__"))
            {
                retorno = Declaracoes.aCFAbrir_NFCe_Daruma("", "", "", "", "", "",
                                                           "", "", "");
            }
            else
            {
                retorno = Declaracoes.aCFAbrir_NFCe_Daruma(cliente.Cpf, cliente.Nome, cliente.Logradouro, cliente.Numero.ToString(), cliente.Bairro, "",
                                                           cliente.Municipio, cliente.Uf, cliente.Cep);
            }

            LogNFCe($"aCFAbrir_NFCe_Daruma - {Declaracoes.TrataRetorno(retorno)}");

            if (retorno != 1)
            {
                MessageBox.Show("Ocorreu um problema ao emitir a NFC-e. \nAcione o suporte Doware.", "Erro NFC-e", MessageBoxButton.OK, MessageBoxImage.Error);
                Declaracoes.tCFCancelar_NFCe_Daruma("", "", "", "", "");
                return;
            }

            foreach (Itens_movimento item in Itens_movimento)
            {
                Produtos produto = new ProdutosController().Find(item.Produto_id);

                string aliquota = (produto.Aliquota == 0
                    ? "F1"
                    : produto.Aliquota.ToString("N2").Replace(",", "."));

                string tipoDescAcresc = (item.Desconto == 0
                    ? "A$"
                    : "D$");

                string valorDescAcresc = (item.Desconto == 0
                    ? item.Acrescimo.ToString("N2")
                    : item.Desconto.ToString("N2"));

                string codigoItem = (produto.Controla_lote
                    ? item.Lote + "SL" + item.Sublote
                    : produto.Id.ToString());

                retorno = Declaracoes.aCFVenderCompleto_NFCe_Daruma(aliquota, item.Quant.ToString("N2"),
                                                                    item.Valor_unit.ToString("N2").Replace(".", ""), tipoDescAcresc, valorDescAcresc, codigoItem, produto.Ncm, item.Cfop.ToString(), produto.Unidades.Sigla,
                                                                    produto.Descricao, "");

                string msg = $@"aCFVenderCompleto_NFCe_Daruma - {Declaracoes.TrataRetorno(retorno)}
    Aliquita.....: {aliquota}
    Quant........: {item.Quant}
    Valor_unit...: {item.Valor_unit.ToString("N2")}
    Tp. Desc/Acr.: {tipoDescAcresc}
    Vl. Desc/Acr.: {valorDescAcresc}
    Cod. Item....: {codigoItem}
    NCM..........: {produto.Ncm}
    CFOP.........: {item.Cfop}
    Unidade......: {produto.Unidades.Sigla}
    Produto......: {produto.Descricao}
";
                LogNFCe(msg);

                if (retorno != 1)
                {
                    MessageBox.Show("Ocorreu um problema ao emitir a NFC-e. Acione o suporte Doware.", "Erro NFC-e", MessageBoxButton.OK, MessageBoxImage.Exclamation);

                    Declaracoes.tCFCancelar_NFCe_Daruma("", "", "", "", "");
                    return;
                }
            }

            retorno = Declaracoes.aCFTotalizar_NFCe_Daruma("D%", "0,00");
            LogNFCe("aCFTotalizar_NFCe_Daruma - " + Declaracoes.TrataRetorno(retorno));
            List <Itens_pagamento> itens_pagamento = itens_pag;

            foreach (Itens_pagamento item in itens_pagamento)
            {
                Formas_pagamento fpg = new Formas_pagamentoController().Find(item.Forma_pagamento_id);
                retorno = Declaracoes.aCFEfetuarPagamento_NFCe_Daruma(fpg.Descricao, item.Valor.ToString("N2").Replace(".", ""));

                string msg = $@"aCFEfetuarPagamento_NFCe_Daruma - {Declaracoes.TrataRetorno(retorno)}

    Condição pgto.....: {fpg.Descricao}
    Valor.............: {item.Valor.ToString("N2")}
";

                LogNFCe(msg);

                if (retorno != 1)
                {
                    MessageBox.Show("Ocorreu um problema ao emitir a NFC-e. \nAcione o suporte Doware.", "Erro NFC-e", MessageBoxButton.OK, MessageBoxImage.Error);
                    Declaracoes.tCFCancelar_NFCe_Daruma("", "", "", "", "");
                    return;
                }
            }

            retorno = Declaracoes.tCFEncerrar_NFCe_Daruma("NFC-e emitida via Curae ERP - Doware Sistemas");
            LogNFCe($@"tCFEncerrar_NFCe_Daruma - {Declaracoes.TrataRetorno(retorno)}");

            if (retorno != 1)
            {
                StringBuilder sbCodigo   = new StringBuilder(10);
                StringBuilder sbMensagem = new StringBuilder(1000);

                Declaracoes.rAvisoErro_NFCe_Daruma(sbCodigo, sbMensagem);
                LogNFCe($@"tCFEncerrar_NFCe_Daruma - ERRO

Codigo.....: {sbCodigo.ToString()}
Mensagem...: {sbMensagem.ToString()}");

                MessageBox.Show($"A NFC-e não foi autorizada! \nErro: {sbCodigo.ToString()} \nMensagem SEFAZ: {sbMensagem.ToString()}");
                retorno = Declaracoes.tCFCancelar_NFCe_Daruma("", "", "", "", "");
                LogNFCe($"tCFCancelar_NFCe_Daruma - {Declaracoes.TrataRetorno(retorno)}");
                return;
            }

            if (retorno == 1)
            {
                string   diretorio = @"C:\NFC-e\DANFEs\";
                var      directory = new DirectoryInfo(diretorio);
                FileInfo danfe     = directory.GetFiles()
                                     .Where(f => f.Name.Contains("DANFE"))
                                     .OrderByDescending(f => f.LastWriteTime)
                                     .First();

                Parametros parametro = ParametrosController.FindParametro("NF_IMPPADRAO", true);
                if (parametro == null)
                {
                    MessageBox.Show("Não foi possível imprimir a DANFE por que o parâmetro de sistema 'NF_IMPPADRAO' não foi informado ou seu valor não pode ser reconhecido. \n\nAcione o suporte Doware.", "NF_IMPPADRAO", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                    return;
                }

                if (parametro.Valor == null || parametro.Valor == "")
                {
                    MessageBox.Show("Não foi possível imprimir a DANFE por que o parâmetro de sistema 'NF_IMPPADRAO' não foi informado ou seu valor não pode ser reconhecido. \n\nAcione o suporte Doware.", "NF_IMPPADRAO", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                    return;
                }

                string parametrosSpool = $@"{danfe.FullName};{parametro.Valor}";

                File.WriteAllText(Directory.GetCurrentDirectory() + @"\PARAMS.txt", "");
                StreamWriter writer = new StreamWriter(Directory.GetCurrentDirectory() + @"\PARAMS.txt");
                writer.WriteLine(parametrosSpool);
                writer.Close();

                System.Diagnostics.Process.Start(Directory.GetCurrentDirectory() + @"\Utilitarios\NFCe_Spool.exe");
            }
        }
        public bool Save(Lancamentos_financeiros lancamento_financeiro)
        {
            if (!Valid(lancamento_financeiro))
            {
                return(false);
            }

            List <Pagamentos_lancamentos> pagamentos = lancamento_financeiro.Pagamentos_lancamentos.ToList();

            lancamento_financeiro.Pagamentos_lancamentos = null;
            UnitOfWork unit = new UnitOfWork();

            try
            {
                unit.BeginTransaction();
                db.Context = unit.Context;

                lancamento_financeiro.Id = db.NextId(e => e.Id);
                db.Save(lancamento_financeiro);
                db.Commit();

                pagamentos.ForEach(e => e.Lancamento_id    = lancamento_financeiro.Id);
                pagamentos.ForEach(e => e.Formas_pagamento = null);

                Pagamentos_lancamentosController pl_controller = new Pagamentos_lancamentosController();
                pl_controller.SetContext(unit.Context);

                Formas_pagamentoController fpg_controller = new Formas_pagamentoController();
                fpg_controller.SetContext(unit.Context);

                ParcelasController parcController = new ParcelasController();
                parcController.SetContext(unit.Context);

                ContasController contasController = new ContasController();
                contasController.SetContext(unit.Context);

                Planos_contasController planoContasController = new Planos_contasController();
                planoContasController.SetContext(unit.Context);

                Contas        conta       = contasController.Find(lancamento_financeiro.Conta_id);
                Planos_contas plano_conta = planoContasController.Find(lancamento_financeiro.Plano_conta_id);

                int numero_parcela = 1;
                foreach (Pagamentos_lancamentos pagamento in pagamentos)
                {
                    if (!pl_controller.Save(pagamento))
                    {
                        unit.RollBack();
                        return(false);
                    }

                    Formas_pagamento forma_pg = fpg_controller.Find(pagamento.Forma_pagamento_id);

                    #region DINHEIRO
                    if (forma_pg.Tipo_pagamento == (int)Tipo_pagamento.DINHEIRO)
                    {
                        if (lancamento_financeiro.Tipo == (int)Tipo_lancamento.ENTRADA)
                        {
                            conta.Saldo += pagamento.Valor;
                        }
                        else
                        {
                            conta.Saldo -= pagamento.Valor;
                        }

                        contasController.Save(conta);
                    }
                    #endregion

                    #region CHEQUE
                    if (forma_pg.Tipo_pagamento == (int)Tipo_pagamento.CHEQUE)
                    {
                        IRegistroCheques registroCheques;

                        if (lancamento_financeiro.Tipo == (int)Tipo_lancamento.ENTRADA)
                        {
                            registroCheques = new RecebimentoCheques();
                        }
                        else
                        {
                            registroCheques = new LancamentoCheque();
                            registroCheques.SetConta(conta);
                        }

                        registroCheques.Exibir(pagamento.Valor);

                        foreach (Cheque cheque in registroCheques.Cheques)
                        {
                            Parcelas parcela_cheque = new Parcelas();

                            parcela_cheque.Pagamento_lancamento_id = pagamento.Id;
                            parcela_cheque.Valor             = cheque.Valor;
                            parcela_cheque.Situacao          = (int)Situacao_parcela.EM_ABERTO;
                            parcela_cheque.Data_lancamento   = lancamento_financeiro.Data;
                            parcela_cheque.Num_documento     = lancamento_financeiro.Num_documento.PadLeft(8 - lancamento_financeiro.Num_documento.Length, '0') + "-" + numero_parcela;
                            parcela_cheque.Parcela_descricao = $"REFERENTE AO LANÇAMENTO FINANCEIRO {lancamento_financeiro.Id} ({plano_conta.Descricao})";
                            parcela_cheque.Data_vencimento   = cheque.Data_deposito;

                            if (lancamento_financeiro.Tipo == (int)Tipo_lancamento.ENTRADA)
                            {
                                parcela_cheque.Tipo_parcela = (int)Tipo_parcela.RECEBER;
                                parcela_cheque.Cliente_id   = lancamento_financeiro.Cliente_id;

                                parcela_cheque.Numero_cheque    = cheque.Numero_cheque;
                                parcela_cheque.Banco            = cheque.Banco;
                                parcela_cheque.Agencia          = cheque.Agencia;
                                parcela_cheque.Dias_compensacao = cheque.Dias_compensacao;
                                parcela_cheque.Conta            = cheque.Conta;
                            }

                            if (lancamento_financeiro.Tipo == (int)Tipo_lancamento.SAIDA)
                            {
                                parcela_cheque.Tipo_parcela  = (int)Tipo_parcela.PAGAR;
                                parcela_cheque.Fornecedor_id = lancamento_financeiro.Fornecedor_id;

                                parcela_cheque.Portador         = forma_pg.Conta_id;
                                parcela_cheque.Numero_cheque    = cheque.Numero_cheque;
                                parcela_cheque.Banco            = string.Empty;
                                parcela_cheque.Agencia          = string.Empty;
                                parcela_cheque.Dias_compensacao = 0;
                                parcela_cheque.Conta            = string.Empty;
                            }

                            if (!parcController.Save(parcela_cheque))
                            {
                                unit.RollBack();
                                return(false);
                            }

                            numero_parcela++;
                        }
                    }
                    #endregion

                    #region CARTAO
                    if (forma_pg.Tipo_pagamento == (int)Tipo_pagamento.CARTAO)
                    {
                        Operadoras_cartaoController opController = new Operadoras_cartaoController();
                        opController.SetContext(unit.Context);

                        Operadoras_cartao operadora = opController.Find(forma_pg.Operadora_cartao_id);

                        Parcelas parcela_cartao = new Parcelas();
                        parcela_cartao.Pagamento_lancamento_id = pagamento.Id;
                        parcela_cartao.Valor           = pagamento.Valor;
                        parcela_cartao.Situacao        = (int)Situacao_parcela.EM_ABERTO;
                        parcela_cartao.Data_lancamento = lancamento_financeiro.Data;

                        parcela_cartao.Data_vencimento = (operadora.Tipo_recebimento == (int)Tipo_prazo_operadora.DIAS
                            ? lancamento_financeiro.Data.AddDays(operadora.Prazo_recebimento)
                            : lancamento_financeiro.Data.AddHours(operadora.Prazo_recebimento));
                        parcela_cartao.Portador = forma_pg.Conta_id;

                        if (lancamento_financeiro.Tipo == (int)Tipo_lancamento.ENTRADA)
                        {
                            parcela_cartao.Tipo_parcela = (int)Tipo_parcela.RECEBER;
                            parcela_cartao.Cliente_id   = lancamento_financeiro.Cliente_id;
                        }

                        if (lancamento_financeiro.Tipo == (int)Tipo_lancamento.SAIDA)
                        {
                            parcela_cartao.Tipo_parcela  = (int)Tipo_parcela.PAGAR;
                            parcela_cartao.Fornecedor_id = lancamento_financeiro.Cliente_id;
                        }

                        parcela_cartao.Num_documento     = lancamento_financeiro.Num_documento.PadLeft(8 - lancamento_financeiro.Num_documento.Length, '0') + "-" + numero_parcela;
                        parcela_cartao.Parcela_descricao = $"REFERENTE AO LANÇAMENTO FINANCEIRO {lancamento_financeiro.Id} ({plano_conta.Descricao})";
                        parcela_cartao.Numero_cheque     = string.Empty;
                        parcela_cartao.Banco             = string.Empty;
                        parcela_cartao.Agencia           = string.Empty;
                        parcela_cartao.Dias_compensacao  = 0;
                        parcela_cartao.Conta             = string.Empty;

                        if (!parcController.Save(parcela_cartao))
                        {
                            unit.RollBack();
                            return(false);
                        }
                        numero_parcela++;
                    }
                    #endregion

                    #region PRAZO
                    if (forma_pg.Tipo_pagamento == (int)Tipo_pagamento.PRAZO)
                    {
                        DateTime data_base = (forma_pg.Tipo_intervalo == (int)Tipo_intervalo.DATA_BASE
                            ? DateTime.Now.AddMonths(1)
                            : DateTime.Now.AddDays(forma_pg.Intervalo)); //baseando a data para o mes sequente ao atual

                        for (int i = 0; i < forma_pg.Parcelas; i++)
                        {
                            Parcelas parcela_prazo = new Parcelas();

                            parcela_prazo.Pagamento_lancamento_id = pagamento.Id;
                            parcela_prazo.Valor             = (pagamento.Valor / forma_pg.Parcelas);
                            parcela_prazo.Situacao          = (int)Situacao_parcela.EM_ABERTO;
                            parcela_prazo.Data_lancamento   = lancamento_financeiro.Data;
                            parcela_prazo.Parcela_descricao = $"REFERENTE AO LANÇAMENTO FINANCEIRO {lancamento_financeiro.Id} ({plano_conta.Descricao})";
                            parcela_prazo.Num_documento     = lancamento_financeiro.Num_documento.PadLeft(8 - lancamento_financeiro.Num_documento.Length, '0') + "-" + numero_parcela;
                            parcela_prazo.Numero_cheque     = string.Empty;
                            parcela_prazo.Banco             = string.Empty;
                            parcela_prazo.Agencia           = string.Empty;
                            parcela_prazo.Dias_compensacao  = 0;
                            parcela_prazo.Conta             = string.Empty;
                            parcela_prazo.Portador          = lancamento_financeiro.Conta_id;

                            if (forma_pg.Tipo_intervalo == (int)Tipo_intervalo.DATA_BASE)
                            {
                                data_base = new DateTime(data_base.Year, data_base.Month, forma_pg.Dia_base);
                                parcela_prazo.Data_vencimento = data_base;
                                data_base = data_base.AddMonths(1);
                            }

                            if (forma_pg.Tipo_intervalo == (int)Tipo_intervalo.INTERVALO)
                            {
                                parcela_prazo.Data_vencimento = data_base;
                                data_base = data_base.AddDays(forma_pg.Intervalo);
                            }

                            if (lancamento_financeiro.Tipo == (int)Tipo_lancamento.ENTRADA)
                            {
                                parcela_prazo.Tipo_parcela = (int)Tipo_parcela.RECEBER;
                                parcela_prazo.Cliente_id   = lancamento_financeiro.Cliente_id;
                            }

                            if (lancamento_financeiro.Tipo == (int)Tipo_lancamento.SAIDA)
                            {
                                parcela_prazo.Tipo_parcela  = (int)Tipo_parcela.PAGAR;
                                parcela_prazo.Fornecedor_id = lancamento_financeiro.Fornecedor_id;
                            }

                            if (!parcController.Save(parcela_prazo))
                            {
                                unit.RollBack();
                                return(false);
                            }

                            numero_parcela++;
                        }
                        #endregion
                    }
                }

                unit.Commit();
                BStatus.Success("Lançamento financeiro efetuado com sucesso");
                return(true);
            }
            catch (Exception ex)
            {
                unit.RollBack();
                return(false);
            }
        }