Example #1
0
        /// <summary>
        /// Atualiza o campo Qntde Terceiro da tabela produto_loja
        /// </summary>
        /// <param name="tipoMov"></param>
        /// <param name="idLoja"></param>
        /// <param name="idProd"></param>
        /// <param name="qtdeMov"></param>
        private void AtualizaProdutoLojaQtdeTerceiros(GDASession sessao, MovEstoque.TipoMovEnum tipoMov, uint idLoja, uint idProd, decimal qtdeMov)
        {
            ProdutoLoja plAtual = ProdutoLojaDAO.Instance.GetElement(idLoja, idProd);

            if (plAtual == null)
            {
                return;
            }

            ProdutoLoja plNovo = ProdutoLojaDAO.Instance.GetElement(idLoja, idProd);

            if (tipoMov == MovEstoque.TipoMovEnum.Entrada)
            {
                plNovo.QtdePosseTerceiros += Convert.ToDouble(qtdeMov);
            }
            else
            {
                plNovo.QtdePosseTerceiros -= Convert.ToDouble(qtdeMov);
            }

            ProdutoLojaDAO.Instance.Update(sessao, plNovo);

            // Salva log da alteração no estoque de terceiros
            LogAlteracaoDAO.Instance.LogProdutoLoja(sessao, plAtual);
        }
Example #2
0
        /// <summary>
        /// Dá baixa no estoque no produto da loja passados
        /// </summary>
        private void MovimentaEstoqueFiscal(GDASession sessao, uint idProd, uint idLoja, uint?idNaturezaOperacao, MovEstoque.TipoMovEnum tipoMov, uint?idNf,
                                            uint?idProdNf, bool lancManual, decimal qtdeMov, decimal total, DateTime dataMov, string obs, bool estorno)
        {
            var usarValorProdNf = Configuracoes.EstoqueConfig.ConsiderarTotalProdNfMovEstoqueFiscal;

            try
            {
                ProdutoBaixaEstoqueFiscal[] prodBaixEstFisc;

                if (!lancManual)
                {
                    prodBaixEstFisc = ProdutoBaixaEstoqueFiscalDAO.Instance.GetByProd(idProd);
                }
                else
                {
                    prodBaixEstFisc = new ProdutoBaixaEstoqueFiscal[]
                    {
                        new ProdutoBaixaEstoqueFiscal()
                        {
                            IdProd      = (int)idProd,
                            IdProdBaixa = (int)idProd,
                            Qtde        = 1
                        }
                    }
                };

                if (AlteraEstoqueFiscal(idProd, idNaturezaOperacao) || lancManual)
                {
                    foreach (var pbef in prodBaixEstFisc)
                    {
                        var qtde     = qtdeMov * (decimal)pbef.Qtde;
                        var totalMov = total * (decimal)pbef.Qtde;

                        if (pbef.IdProdBaixa != idProd)
                        {
                            if (estorno || usarValorProdNf)
                            {
                                /* Chamado 38441. */
                                if (Configuracoes.EstoqueConfig.AbaterICMSDoTotalProdNfMovEstoqueFiscal && idProdNf > 0)
                                {
                                    var valorIcms = ProdutosNfDAO.Instance.ObterValorIcms(sessao, (int)idProdNf.GetValueOrDefault());
                                    totalMov -= valorIcms;
                                }
                            }
                        }

                        // Recupera os dados da movimentação anterior
                        decimal saldoQtdeAnterior  = ObtemSaldoQtdeMov(sessao, null, (uint)pbef.IdProdBaixa, idLoja, dataMov, true);
                        decimal saldoValorAnterior = ObtemSaldoValorMov(sessao, null, (uint)pbef.IdProdBaixa, idLoja, dataMov, true);

                        /* Chamado 16616.
                         * O saldo do ficou negativo após a emissão de uma nota fiscal.
                         * Esta verificação irá impedir que isto ocorra novamente. */
                        // Verifica se, ao registrar a movimentação, o saldo em estoque do produto ficará negativo.
                        if ((saldoQtdeAnterior - qtde) < 0 && tipoMov == MovEstoque.TipoMovEnum.Saida)
                        {
                            var validarEstoqueDisponivel = true;

                            /* Chamado 53204. */
                            if (idNf > 0)
                            {
                                validarEstoqueDisponivel = NotaFiscalDAO.Instance.GetTipoDocumento(sessao, idNf.Value) == (int)NotaFiscal.TipoDoc.EntradaTerceiros;
                            }

                            if (validarEstoqueDisponivel)
                            {
                                var idGrupoProdBaixa    = ProdutoDAO.Instance.ObtemIdGrupoProd(pbef.IdProdBaixa);
                                var idSubgrupoProdBaixa = ProdutoDAO.Instance.ObtemValorCampo <int?>("IdSubGrupoProd", "IdProd=" + pbef.IdProdBaixa);

                                // Verifica se o subgrupo ou o grupo do produto estão marcados para bloquear estoque.
                                if (GrupoProdDAO.Instance.BloquearEstoque((int)idGrupoProdBaixa, idSubgrupoProdBaixa))
                                {
                                    throw new Exception
                                          (
                                              "O grupo/subgrupo do produto está marcado para bloquear estoque, portanto, o estoque não pode ser negativo."
                                          );
                                }
                            }
                        }

                        // Registra a alteração do estoque
                        MovEstoqueFiscal movEstoque = new MovEstoqueFiscal();
                        movEstoque.IdProd     = (uint)pbef.IdProdBaixa;
                        movEstoque.IdLoja     = idLoja;
                        movEstoque.IdFunc     = UserInfo.GetUserInfo.CodUser;
                        movEstoque.IdNf       = idNf;
                        movEstoque.IdProdNf   = idProdNf;
                        movEstoque.LancManual = lancManual;
                        movEstoque.TipoMov    = (int)tipoMov;
                        movEstoque.DataMov    = dataMov;
                        movEstoque.Obs        = obs;
                        if (dataMov.Date != DateTime.Now.Date)
                        {
                            movEstoque.DataCad = DateTime.Now;
                        }
                        movEstoque.QtdeMov = qtde;

                        movEstoque.SaldoQtdeMov = Math.Round(saldoQtdeAnterior + (tipoMov == MovEstoque.TipoMovEnum.Entrada ? qtde : -qtde), 2);

                        if (movEstoque.SaldoQtdeMov < 0)
                        {
                            movEstoque.ValorMov      = 0;
                            movEstoque.SaldoValorMov = 0;
                        }
                        // Caso o tipo da nota fiscal seja "Saída" o tipo da movimentação será entrada somente no caso de um estorno,
                        // e o estorno da nota fiscal de saída deve calcular o valor e a quantidade da movimentação da mesma forma que é
                        // calculado na movimentação de saída da nota. Por isso, neste momento, deve ser verificado se a nota é de saída.
                        else if (tipoMov == MovEstoque.TipoMovEnum.Entrada &&
                                 (idNf.GetValueOrDefault() > 0 ? NotaFiscalDAO.Instance.ObtemValorCampo <int>(sessao, "tipoDocumento", "IdNf=" + idNf.Value) !=
                                  (int)NotaFiscal.TipoDoc.Saída : true))
                        {
                            decimal perc = qtde > movEstoque.SaldoQtdeMov ?
                                           qtde / (movEstoque.SaldoQtdeMov > 0 ? movEstoque.SaldoQtdeMov : 1) : 1;

                            movEstoque.ValorMov      = Math.Abs(totalMov);
                            movEstoque.SaldoValorMov = saldoValorAnterior + (movEstoque.ValorMov * perc);
                        }
                        else
                        {
                            decimal valorUnit = saldoValorAnterior / (saldoQtdeAnterior > 0 ? saldoQtdeAnterior : 1);
                            movEstoque.ValorMov      = Math.Abs(valorUnit * qtde);
                            movEstoque.SaldoValorMov = saldoValorAnterior - (valorUnit * qtde);
                        }

                        movEstoque.IdMovEstoqueFiscal = Insert(sessao, movEstoque);

                        // Chamado 15184: Sempre atualiza o saldo, para resolver o erro de não recalcular o saldo
                        var idMovAnterior = ObtemIdMovAnterior(sessao, movEstoque.IdMovEstoqueFiscal, movEstoque.IdProd, movEstoque.IdLoja, movEstoque.DataMov);
                        if (idMovAnterior != null)
                        {
                            AtualizaSaldo(sessao, idMovAnterior.Value);
                        }
                        else
                        {
                            AtualizaSaldo(sessao, movEstoque.IdMovEstoqueFiscal);
                        }

                        // Atualiza a tabela produto_loja
                        AtualizaProdutoLoja(sessao, movEstoque.IdProd, movEstoque.IdLoja);
                    }
                }

                if (!lancManual &&
                    idNaturezaOperacao > 0 &&
                    CfopDAO.Instance.AlterarEstoqueTerceiros(sessao, NaturezaOperacaoDAO.Instance.ObtemIdCfop(sessao, idNaturezaOperacao.Value)))
                {
                    if (prodBaixEstFisc != null && prodBaixEstFisc.Length > 0 && prodBaixEstFisc[0].IdProdBaixa > 0)
                    {
                        foreach (var pbef in prodBaixEstFisc)
                        {
                            AtualizaProdutoLojaQtdeTerceiros(sessao, tipoMov, idLoja, (uint)pbef.IdProdBaixa, qtdeMov);
                        }
                    }
                    else
                    {
                        AtualizaProdutoLojaQtdeTerceiros(sessao, tipoMov, idLoja, idProd, qtdeMov);
                    }
                }
            }
            catch (Exception ex)
            {
                if (idNf > 0)
                {
                    LogNfDAO.Instance.NewLog(idNf.Value, "Estoque", 2, MensagemAlerta.FormatErrorMsg("Falha ao movimentar estoque.", ex));
                    ErroDAO.Instance.InserirFromException("MovEstoqueFiscal", ex);
                }

                // Chamado 26887, não estava lançando exception
                if (lancManual)
                {
                    throw ex;
                }
            }
        }
Example #3
0
        public void MovimentaMateriaPrimaPedidoEspelho(GDASession sessao, int idProdPedEsp, decimal qntd, MovEstoque.TipoMovEnum tipoMov)
        {
            var idProd = ProdutosPedidoEspelhoDAO.Instance.ObtemIdProd(sessao, (uint)idProdPedEsp);

            int     idCorVidro;
            decimal espessura;

            RecuperaCorEspessuraProduto(sessao, (int)idProd, out idCorVidro, out espessura);

            MovimentaMateriaPrima(sessao, idCorVidro, espessura, tipoMov, qntd, null, null, null, null, idProdPedEsp);
        }
Example #4
0
        private void MovimentaMateriaPrima(GDASession sessao, int idCorVidro, decimal espessura, MovEstoque.TipoMovEnum tipoMov, decimal qntd,
                                           int?idProdNf, int?idPerdaChapaVidro, int?idProdImpressao, int?idProdPed, int?idProdPedEsp)
        {
            var saldoAtual = ObterSaldo(sessao, idCorVidro, espessura);

            MovMateriaPrima mov = new MovMateriaPrima();

            mov.IdCorVidro = idCorVidro;
            mov.Espessura  = espessura;
            mov.IdFunc     = Helper.UserInfo.GetUserInfo.CodUser;
            mov.DataMov    = DateTime.Now;
            mov.TipoMov    = tipoMov;
            mov.Qtde       = qntd;
            mov.Saldo      = tipoMov == MovEstoque.TipoMovEnum.Entrada ? saldoAtual + qntd : saldoAtual - qntd;

            mov.IdProdNf          = idProdNf;
            mov.IdPerdaChapaVidro = idPerdaChapaVidro;
            mov.IdProdImpressao   = idProdImpressao;
            mov.IdProdPed         = idProdPed;
            mov.IdProdPedEsp      = idProdPedEsp;

            Insert(sessao, mov);
        }
Example #5
0
        public void MovimentaMateriaPrimaNotaFiscal(GDASession sessao, int idProd, int idNf, int idProdNf, decimal qtde, MovEstoque.TipoMovEnum tipoMov)
        {
            //Se for materia-prima (Chapas) faz a movimentação
            var tipoSubgrupo = SubgrupoProdDAO.Instance.ObtemTipoSubgrupo(sessao, idProd);

            if (NotaFiscalDAO.Instance.ObtemValorCampo <bool>("gerarEtiqueta", "idNf=" + idNf) && (tipoSubgrupo == TipoSubgrupoProd.ChapasVidro || tipoSubgrupo == TipoSubgrupoProd.ChapasVidroLaminado))
            {
                int     idCorVidro;
                decimal espessura;

                RecuperaCorEspessuraProduto(sessao, idProd, out idCorVidro, out espessura);

                MovimentaMateriaPrima(null, idCorVidro, espessura, tipoMov, qtde, idProdNf, null, null, null, null);
            }
        }
Example #6
0
        public void MovimentaMateriaPrimaCorte(GDASession sessao, int idProdImpressaoPeca, MovEstoque.TipoMovEnum tipoMov)
        {
            var idProdPed = ProdutoImpressaoDAO.Instance.ObtemIdProdPed(sessao, idProdImpressaoPeca);
            var idProd    = ProdutoImpressaoDAO.Instance.GetIdProd(sessao, (uint)idProdImpressaoPeca);

            int     idCorVidro;
            decimal espessura;

            RecuperaCorEspessuraProduto(sessao, (int)idProd.GetValueOrDefault(), out idCorVidro, out espessura);

            var totM = ProdutosPedidoEspelhoDAO.Instance.ObtemTotM(sessao, (uint)idProdPed);
            var qtde = ProdutosPedidoEspelhoDAO.Instance.ObtemQtde(sessao, (uint)idProdPed);

            if (qtde == 0 || totM == 0)
            {
                return;
            }

            var m2 = (decimal)Math.Round(totM / qtde, 2);

            MovimentaMateriaPrima(sessao, idCorVidro, espessura, tipoMov, m2, null, null, idProdImpressaoPeca, null, null);
        }
Example #7
0
        public void MovimentaMateriaPrimaChapaCortePeca(GDASession sessao, int idProdImpressaoChapa, MovEstoque.TipoMovEnum tipoMov)
        {
            if (idProdImpressaoChapa > 0 && !ChapaCortePecaDAO.Instance.ChapaPossuiLeitura(sessao, (uint)idProdImpressaoChapa))
            {
                uint?idProd = ProdutoImpressaoDAO.Instance.GetIdProd(sessao, (uint)idProdImpressaoChapa);

                //Se for materia-prima (Chapas) faz a movimentação
                var tipoSubgrupo = SubgrupoProdDAO.Instance.ObtemTipoSubgrupo(sessao, (int)idProd);
                if (tipoSubgrupo == TipoSubgrupoProd.ChapasVidro || tipoSubgrupo == TipoSubgrupoProd.ChapasVidroLaminado)
                {
                    int     idCorVidro;
                    decimal espessura;

                    RecuperaCorEspessuraProduto(sessao, (int)idProd.GetValueOrDefault(), out idCorVidro, out espessura);

                    var m2 = ProdutoDAO.Instance.ObtemM2Chapa(sessao, (int)idProd);

                    MovimentaMateriaPrima(sessao, idCorVidro, espessura, tipoMov, m2, null, null, idProdImpressaoChapa, null, null);
                }
            }
        }
Example #8
0
        /// <summary>
        /// Dá baixa no estoque no produto da loja passados
        /// </summary>
        private void MovimentaEstoqueCliente(GDASession sessao, uint idCliente, uint idProd, uint idLoja, MovEstoque.TipoMovEnum tipoMov, uint?idNf, uint?idProdNf,
                                             uint?idPedido, uint?idProdPed, uint?idLiberarPedido, uint?idProdLiberarPedido, uint?idProdPedProducao, bool lancManual, decimal qtdeMov,
                                             decimal qtdeMovAreaMinima, decimal total, DateTime dataMov, string obs)
        {
            if (!EstoqueConfig.ControlarEstoqueVidrosClientes)
            {
                return;
            }

            ProdutoBaixaEstoque[] prodBaixEst;

            if (!lancManual)
            {
                prodBaixEst = ProdutoBaixaEstoqueDAO.Instance.GetByProd(sessao, idProd);
            }
            else
            {
                prodBaixEst = new ProdutoBaixaEstoque[]
                {
                    new ProdutoBaixaEstoque()
                    {
                        IdProd      = (int)idProd,
                        IdProdBaixa = (int)idProd,
                        Qtde        = 1
                    }
                }
            };

            foreach (var pbe in prodBaixEst)
            {
                bool executou     = false;
                var  tipoSubgrupo = SubgrupoProdDAO.Instance.ObtemTipoSubgrupo(sessao, (int)idProd);

                //Se não for lançamento manual e o produto for chapa de vidro mov. a matéria-prima
                if (!lancManual && (tipoSubgrupo == TipoSubgrupoProd.ChapasVidro || tipoSubgrupo == TipoSubgrupoProd.ChapasVidroLaminado))
                {
                    decimal m2Chapa             = ProdutoDAO.Instance.ObtemM2Chapa(sessao, (int)pbe.IdProdBaixa);
                    decimal qtdeMovMateriaPrima = (decimal)pbe.Qtde * m2Chapa;

                    uint?idProdBase = ProdutoDAO.Instance.ObtemValorCampo <uint?>(sessao, "idProdBase", "idProd=" + pbe.IdProdBaixa);

                    if (idProdBase.HasValue && idProd != idProdBase)
                    {
                        MovimentaEstoqueCliente(sessao, idCliente, idProdBase.Value, idLoja, tipoMov, idNf, idProdNf, idPedido, idProdPed,
                                                idLiberarPedido, idProdLiberarPedido, idProdPedProducao, lancManual, qtdeMov, qtdeMovAreaMinima, total, dataMov, obs);

                        executou = true;
                    }
                }

                if (!executou)
                {
                    decimal qtde     = (qtdeMovAreaMinima > 0 ? qtdeMovAreaMinima : qtdeMov) * (decimal)pbe.Qtde;
                    decimal totalMov = pbe.IdProdBaixa != idProd?MovEstoqueDAO.Instance.GetTotalEstoqueManual(sessao, (int)pbe.IdProdBaixa, qtde) :
                                           total * (decimal)pbe.Qtde;

                    // Registra a alteração do estoque
                    MovEstoqueCliente movEstoque = new MovEstoqueCliente();
                    movEstoque.IdCliente           = idCliente;
                    movEstoque.IdProd              = (uint)pbe.IdProdBaixa;
                    movEstoque.IdLoja              = idLoja;
                    movEstoque.IdFunc              = UserInfo.GetUserInfo.CodUser;
                    movEstoque.IdNf                = idNf;
                    movEstoque.IdProdNf            = idProdNf;
                    movEstoque.IdPedido            = idPedido;
                    movEstoque.IdProdPed           = idProdPed;
                    movEstoque.IdLiberarPedido     = idLiberarPedido;
                    movEstoque.IdProdLiberarPedido = idProdLiberarPedido;
                    movEstoque.IdProdPedProducao   = idProdPedProducao;
                    movEstoque.LancManual          = lancManual;
                    movEstoque.TipoMov             = (int)tipoMov;
                    movEstoque.DataMov             = dataMov;
                    if (dataMov.Date != DateTime.Now.Date)
                    {
                        movEstoque.DataCad = DateTime.Now;
                    }
                    movEstoque.QtdeMov    = qtde;
                    movEstoque.Observacao = obs;

                    movEstoque.IdMovEstoqueCliente = Insert(sessao, movEstoque);

                    // Recupera os dados da movimentação anterior
                    decimal saldoQtdeAnterior  = ObtemSaldoQtdeMov(sessao, movEstoque.IdMovEstoqueCliente, idCliente, (uint)pbe.IdProdBaixa, idLoja, dataMov, true);
                    decimal saldoValorAnterior = ObtemSaldoValorMov(sessao, movEstoque.IdMovEstoqueCliente, idCliente, (uint)pbe.IdProdBaixa, idLoja, dataMov, true);

                    movEstoque.SaldoQtdeMov = Math.Round(saldoQtdeAnterior + (tipoMov == MovEstoque.TipoMovEnum.Entrada ? qtde : -qtde), Geral.NumeroCasasDecimaisTotM);

                    if (movEstoque.SaldoQtdeMov < 0)
                    {
                        movEstoque.ValorMov      = 0;
                        movEstoque.SaldoValorMov = 0;
                    }
                    else if (tipoMov == MovEstoque.TipoMovEnum.Entrada)
                    {
                        decimal perc = tipoMov == MovEstoque.TipoMovEnum.Entrada && qtde > movEstoque.SaldoQtdeMov ?
                                       qtde / (movEstoque.SaldoQtdeMov > 0 ? movEstoque.SaldoQtdeMov : 1) : 1;

                        movEstoque.ValorMov      = Math.Abs(totalMov);
                        movEstoque.SaldoValorMov = saldoValorAnterior + (movEstoque.ValorMov * perc);
                    }
                    else
                    {
                        decimal valorUnit = saldoValorAnterior / (saldoQtdeAnterior > 0 ? saldoQtdeAnterior : 1);
                        movEstoque.ValorMov      = Math.Abs(valorUnit * qtde);
                        movEstoque.SaldoValorMov = saldoValorAnterior - (valorUnit * qtde);
                    }

                    base.Update(sessao, movEstoque);

                    if (TemMovimentacaoPosterior(sessao, movEstoque.IdMovEstoqueCliente))
                    {
                        AtualizaSaldo(sessao, movEstoque.IdMovEstoqueCliente);
                    }
                }
            }
        }
Example #9
0
 /// <summary>
 /// (APAGAR: quando alterar para utilizar transação)
 /// Dá baixa no estoque no produto da loja passados
 /// </summary>
 private void MovimentaEstoqueCliente(uint idCliente, uint idProd, uint idLoja, MovEstoque.TipoMovEnum tipoMov, uint?idNf, uint?idProdNf,
                                      uint?idPedido, uint?idProdPed, uint?idLiberarPedido, uint?idProdLiberarPedido, uint?idProdPedProducao, bool lancManual, decimal qtdeMov,
                                      decimal qtdeMovAreaMinima, decimal total, DateTime dataMov, string obs)
 {
     MovimentaEstoqueCliente(null, idCliente, idProd, idLoja, tipoMov, idNf, idProdNf, idPedido, idProdPed, idLiberarPedido,
                             idProdLiberarPedido, idProdPedProducao, lancManual, qtdeMov, qtdeMovAreaMinima, total, dataMov, obs);
 }