Example #1
0
        internal void LimpaLogErro()
        {
            using (var session = new GDA.GDATransaction())
            {
                try
                {
                    session.BeginTransaction();

                    if (ExecuteScalar <int>(session, "SELECT COUNT(*) FROM erro") < 50000)
                    {
                        session.Close();
                        return;
                    }

                    do
                    {
                        objPersistence.ExecuteCommand(session, "DELETE FROM erro LIMIT 50000");
                    } while (ExecuteScalar <int>(session, "SELECT COUNT(*) FROM erro") > 0);



                    session.Commit();
                    session.Close();
                }
                catch
                {
                    session.Rollback();
                    session.Close();
                }
            }
        }
Example #2
0
        public void AumentarEstoque(uint idLoja, IEnumerable <DadosAumentarEstoque> dadosAumentarEstoque)
        {
            lock (_aumentarEstoqueLock)
            {
                using (var transaction = new GDA.GDATransaction())
                {
                    try
                    {
                        transaction.BeginTransaction();

                        var usuario = UserInfo.GetUserInfo;

                        if (usuario.TipoUsuario != (uint)Utils.TipoFuncionario.AuxAlmoxarifado &&
                            !Config.PossuiPermissao(Config.FuncaoMenuEstoque.ControleEstoque))
                        {
                            throw new Exception("Você não tem permissão para marcar entrada de produtos.");
                        }

                        List <ProdutosCompra> lstProdCompra = new List <ProdutosCompra>();

                        foreach (DadosAumentarEstoque d in dadosAumentarEstoque)
                        {
                            var prodCompra = ProdutosCompraDAO.Instance.GetElementByPrimaryKey(transaction, d.IdProdCompra);

                            // Se a quantidade a ser marcada como saída for maior do que o máximo, não permite marcar saída
                            if (d.QtdeAumentar > prodCompra.Qtde - prodCompra.QtdeEntrada)
                            {
                                throw new Exception("Operação cancelada. O produto " + d.DescricaoProduto + " teve uma entrada maior do que sua quantidade.");
                            }
                            else
                            {
                                prodCompra.QtdMarcadaEntrada = d.QtdeAumentar;

                                lstProdCompra.Add(prodCompra);
                            }
                        }

                        MovEstoqueDAO.Instance.CreditaEstoqueManualCompra(transaction, idLoja, lstProdCompra[0].IdCompra, lstProdCompra);

                        transaction.Commit();
                        transaction.Close();
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        transaction.Close();
                        ErroDAO.Instance.InserirFromException("AumentarEstoque Compra", ex);
                        throw;
                    }
                }
            }
        }
Example #3
0
        public void ConfirmarPedido(uint idPedido, string observacao, bool negado)
        {
            using (var transaction = new GDA.GDATransaction())
            {
                try
                {
                    transaction.BeginTransaction();

                    bool enviarMensagem = false;

                    if (!negado && Glass.Configuracoes.PedidoConfig.LiberarPedido)
                    {
                        //Recalcula a data de entrega do pedido baseando-se na data de hoje e atualiza a data de entrega do pedido
                        PedidoDAO.Instance.RecalcularEAtualizarDataEntregaPedido(transaction, idPedido, DateTime.Now, out enviarMensagem, false);

                        var idsPedidoOk   = new List <int>();
                        var idsPediodErro = new List <int>();

                        PedidoDAO.Instance.ConfirmarLiberacaoPedido(transaction, new List <int> {
                            (int)idPedido
                        }, out idsPedidoOk, out idsPediodErro, true, false);

                        if (PedidoDAO.Instance.IsGeradoParceiro(transaction, idPedido) &&
                            Glass.Configuracoes.ProjetoConfig.TelaCadastroParceiros.ConfirmarPedidoGerarPCPFinalizarPCPAoGerarPedido)
                        {
                            var idProjeto = PedidoDAO.Instance.ObtemIdProjeto(idPedido);
                            if (ProjetoDAO.Instance.GetTipoVenda(transaction, idProjeto.GetValueOrDefault(0)) == (int)Glass.Data.Model.Pedido.TipoPedidoEnum.Venda)
                            {
                                // Gera o espelho do pedido.
                                PedidoEspelhoDAO.Instance.GeraEspelho(transaction, idPedido);

                                // Deixa a conferência do pedido finalizada.
                                PedidoEspelhoDAO.Instance.FinalizarPedido(transaction, idPedido);
                            }
                        }
                    }
                    else
                    {
                        PedidoDAO.Instance.AlteraSituacao(transaction, idPedido, Glass.Data.Model.Pedido.SituacaoPedido.Conferido);
                    }

                    ObservacaoFinalizacaoFinanceiroDAO.Instance.AtualizaItem(transaction, idPedido, observacao, !negado ?
                                                                             Glass.Data.Model.ObservacaoFinalizacaoFinanceiro.MotivoEnum.Confirmacao :
                                                                             Glass.Data.Model.ObservacaoFinalizacaoFinanceiro.MotivoEnum.NegacaoConfirmar);

                    if (enviarMensagem)
                    {
                        var idRemetente   = UserInfo.GetUserInfo.CodUser;
                        var idVendedorCad = (int)PedidoDAO.Instance.ObtemIdFuncCad(transaction, idPedido);
                        var dataEntrega   = PedidoDAO.Instance.ObtemDataEntrega(null, idPedido);

                        //Envia uma mensagem para o vendedor informando que a data de entrega foi alterada
                        Microsoft.Practices.ServiceLocation.ServiceLocator.Current
                        .GetInstance <Glass.Global.Negocios.IMensagemFluxo>()
                        .EnviarMensagemVendedorAoAlterarDataEntrega((int)idRemetente, idVendedorCad, (int)idPedido, dataEntrega);
                    }

                    transaction.Commit();
                    transaction.Close();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    transaction.Close();
                    throw ex;
                }
            }
        }
Example #4
0
        public void AumentarEstoque(uint idLoja, IEnumerable <DadosAumentarEstoque> dadosAumentarEstoque, bool manual)
        {
            lock (_aumentarEstoqueLock)
            {
                using (var transaction = new GDA.GDATransaction())
                {
                    try
                    {
                        transaction.BeginTransaction();

                        if (UserInfo.GetUserInfo.TipoUsuario != (uint)Utils.TipoFuncionario.AuxAlmoxarifado &&
                            !Config.PossuiPermissao(Config.FuncaoMenuEstoque.ControleEstoque))
                        {
                            throw new Exception("Você não tem permissão para marcar entrada de produtos.");
                        }

                        if (dadosAumentarEstoque == null || dadosAumentarEstoque.Count() == 0)
                        {
                            throw new Exception("Falha ao recuperar os produtos para creditar o estoque.");
                        }

                        var        lstProdNf = new List <ProdutosNf>();
                        ProdutosNf prodNf;

                        foreach (DadosAumentarEstoque d in dadosAumentarEstoque)
                        {
                            prodNf = ProdutosNfDAO.Instance.GetElement(transaction, d.IdProdNf);

                            if (prodNf == null || d.IdProdNf == 0)
                            {
                                throw new Exception("Não foi possível recuperar o produto da nota para creditar o estoque.");
                            }

                            // Se a quantidade a ser marcada como saída for maior do que o máximo, não permite marcar saída
                            if (d.QtdeAumentar > prodNf.Qtde - prodNf.QtdeEntrada)
                            {
                                throw new Exception("Operação cancelada. O produto " + d.DescricaoProduto + " teve uma entrada maior do que sua quantidade.");
                            }
                            else
                            {
                                prodNf.QtdMarcadaEntrada = d.QtdeAumentar;
                                lstProdNf.Add(prodNf);
                            }
                        }

                        if (!lstProdNf.Any())
                        {
                            throw new Exception("Falha ao calcular a quantidade dos produtos a ser creditada no estoque.");
                        }

                        MovEstoqueDAO.Instance.CreditaEstoqueNotaFiscalManual(transaction, (int)idLoja, (int)lstProdNf[0].IdNf, lstProdNf);

                        transaction.Commit();
                        transaction.Close();
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        transaction.Close();
                        ErroDAO.Instance.InserirFromException("AumentarEstoque NFE", ex);
                        throw;
                    }
                }
            }
        }
Example #5
0
        public void Excluir(Entidade.Cte cte)
        {
            lock (_excluirCte)
            {
                using (var transaction = new GDA.GDATransaction())
                {
                    try
                    {
                        transaction.BeginTransaction();

                        uint idCte = cte.IdCte;
                        cte = BuscarCte.Instance.GetCte(transaction, idCte);

                        if (ContasPagarDAO.Instance.ExistePagasCte(transaction, idCte))
                        {
                            throw new Exception("Já existe pelo menos uma conta paga gerada por esse CT-e.");
                        }

                        ContasPagarDAO.Instance.DeleteByCte(transaction, idCte);

                        Glass.Data.DAL.CTe.ConhecimentoTransporteDAO.Instance.DeleteByPrimaryKey(transaction, idCte);
                        Glass.Data.DAL.CTe.CobrancaCteDAO.Instance.DeleteByPrimaryKey(transaction, idCte);

                        foreach (var i in cte.ObjCobrancaCte.ObjCobrancaDuplCte)
                        {
                            Glass.Data.DAL.CTe.CobrancaDuplCteDAO.Instance.Delete(transaction, idCte);
                        }

                        Glass.Data.DAL.CTe.ComplCteDAO.Instance.DeleteByPrimaryKey(transaction, idCte);
                        Glass.Data.DAL.CTe.ComplPassagemCteDAO.Instance.Delete(transaction, idCte, cte.ObjComplCte.ObjComplPassagemCte.NumSeqPassagem);

                        foreach (var i in cte.ObjComponenteValorCte)
                        {
                            Glass.Data.DAL.CTe.ComponenteValorCteDAO.Instance.Delete(transaction, idCte);
                        }

                        Glass.Data.DAL.CTe.ConhecimentoTransporteRodoviarioDAO.Instance.DeleteByPrimaryKey(transaction, idCte);
                        Glass.Data.DAL.CTe.EntregaCteDAO.Instance.DeleteByPrimaryKey(transaction, idCte);

                        foreach (var i in cte.ObjImpostoCte)
                        {
                            Glass.Data.DAL.CTe.ImpostoCteDAO.Instance.Delete(transaction, idCte, i.TipoImposto);
                        }

                        foreach (var i in cte.ObjInfoCte.ObjInfoCargaCte)
                        {
                            Glass.Data.DAL.CTe.InfoCargaCteDAO.Instance.Delete(transaction, idCte, i.TipoUnidade);
                        }

                        Glass.Data.DAL.CTe.InfoCteDAO.Instance.DeleteByPrimaryKey(transaction, idCte);

                        foreach (var i in cte.ObjConhecimentoTransporteRodoviario.ObjLacreCteRod)
                        {
                            Glass.Data.DAL.CTe.LacreCteRodDAO.Instance.Delete(transaction, idCte);
                        }

                        Glass.Data.DAL.CTe.NotaFiscalCteDAO.Instance.DeleteByIdCte(transaction, idCte);

                        foreach (var i in cte.ObjConhecimentoTransporteRodoviario.ObjOrdemColetaCteRod)
                        {
                            Glass.Data.DAL.CTe.OrdemColetaCteRodDAO.Instance.Delete(transaction, idCte);
                        }

                        foreach (var i in cte.ObjConhecimentoTransporteRodoviario.ObjValePedagioCteRod)
                        {
                            Glass.Data.DAL.CTe.ValePedagioCteRodDAO.Instance.Delete(transaction, idCte);
                        }

                        foreach (var i in cte.ObjParticipanteCte)
                        {
                            Glass.Data.DAL.CTe.ParticipanteCteDAO.Instance.Delete(transaction, idCte);
                        }

                        Glass.Data.DAL.CTe.SeguroCteDAO.Instance.Delete(transaction, idCte);

                        foreach (var i in cte.ObjVeiculoCte)
                        {
                            Glass.Data.DAL.CTe.VeiculoCteDAO.Instance.Delete(transaction, idCte);
                        }

                        Glass.Data.DAL.CTe.EfdCteDAO.Instance.Delete(transaction, idCte);

                        transaction.Commit();
                        transaction.Close();
                    }
                    catch
                    {
                        transaction.Rollback();
                        transaction.Close();
                        throw;
                    }
                }
            }
        }