示例#1
0
        /// <summary>
        /// Retifica uma comissão
        /// </summary>
        /// <param name="idComissao"></param>
        /// <param name="idFunc"></param>
        /// <param name="idsContasRemover"></param>
        /// <param name="valorComissao"></param>
        /// <param name="dataContaPagar"></param>
        public void RetificarComissaoContasReceber(uint idComissao, uint idFunc, string idsContasRemover, decimal valorComissao, string dataContaPagar)
        {
            using (var trans = new GDA.GDATransaction())
            {
                trans.BeginTransaction();

                // Apenas financeiro pagto pode retificar comissões
                uint tipoUsuario = UserInfo.GetUserInfo.TipoUsuario;
                if (!Config.PossuiPermissao(Config.FuncaoMenuFinanceiroPagto.ControleFinanceiroPagamento))
                {
                    throw new Exception("Você não tem permissão para retificar comissões");
                }

                var contaPagar = ContasPagarDAO.Instance.GetByComissao(trans, idComissao);
                var comissao   = GetElementByPrimaryKey(trans, idComissao);

                if (comissao == null)
                {
                    throw new Exception("Comissão não encontrada.");
                }

                if (contaPagar == null || contaPagar.Paga)
                {
                    throw new Exception("Não é possível retificar essa conta, pois ela já foi paga.");
                }

                try
                {
                    //Remove a associação das contas
                    ComissaoContasReceberDAO.Instance.DeleteByContasRecebidas(trans, idsContasRemover);

                    //Verifica a data da conta a pagar
                    DateTime dataPagar;
                    if (!DateTime.TryParse(dataContaPagar, out dataPagar))
                    {
                        dataPagar = DateTime.Now.AddMonths(1);
                    }

                    //Atualiza a conta a pagar
                    contaPagar.DataVenc  = dataPagar;
                    contaPagar.ValorVenc = valorComissao;
                    ContasPagarDAO.Instance.Update(trans, contaPagar);

                    //Atualiza a comissao
                    comissao.Total = valorComissao;
                    Update(trans, comissao);

                    trans.Commit();
                    trans.Close();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    trans.Close();

                    ErroDAO.Instance.InserirFromException("Retificar comissão de contas recebidas", ex);
                    throw ex;
                }
            }
        }
示例#2
0
        public override uint Insert(Medicao objInsert)
        {
            using (var transaction = new GDA.GDATransaction())
            {
                try
                {
                    transaction.BeginTransaction();

                    if (objInsert.IdOrcamento > 0 && !OrcamentoDAO.Instance.Exists(transaction, objInsert.IdOrcamento))
                    {
                        throw new Exception($"O orçamento {objInsert.IdOrcamento} informado na medição não existe");
                    }

                    uint idMedicao = Insert(transaction, objInsert);

                    transaction.Commit();
                    transaction.Close();

                    return(idMedicao);
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    transaction.Close();

                    throw ex;
                }
            }
        }
示例#3
0
        /// <summary>
        /// Cancela um encontro de contas
        /// </summary>
        public void CancelaEncontro(uint idEncontroContas, string movito)
        {
            lock (EncontroContasLock)
            {
                using (var transaction = new GDA.GDATransaction())
                {
                    try
                    {
                        transaction.BeginTransaction();

                        //Apaga os vinculos das contas a pagar/receber (desmarca a conta como paga ou recebida)
                        ContasPagarEncontroContasDAO.Instance.RemoveVinculoContaPagar(transaction, idEncontroContas);
                        ContasReceberEncontroContasDAO.Instance.RemoveVinculoContaReceber(transaction, idEncontroContas);

                        //Apaga os contas a pagar/receber gerados
                        var tipoConta = Instance.ObtemTipoContaGerar(transaction, idEncontroContas);

                        if (tipoConta == 1)
                        {
                            ContasPagarDAO.Instance.DeleteByEncontroContas(transaction, idEncontroContas);
                        }
                        else if (tipoConta == 2)
                        {
                            ContasReceberDAO.Instance.DeleteByEncontroContas(transaction, idEncontroContas);
                        }

                        var ec = GetElement(transaction, idEncontroContas);

                        LogCancelamentoDAO.Instance.LogEncontroContas(transaction, ec, movito, true);

                        if (ec.Situacao == (int)EncontroContas.SituacaoEncontroContas.Aberto)
                        {
                            Delete(transaction, ec);

                            transaction.Commit();
                            transaction.Close();

                            return;
                        }

                        ec.Situacao   = (int)EncontroContas.SituacaoEncontroContas.Cancelado;
                        ec.IdFuncCanc = UserInfo.GetUserInfo.IdCliente;
                        ec.DataCanc   = DateTime.Now;

                        Update(transaction, ec);

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

                        throw;
                    }
                }
            }
        }
示例#4
0
        /// <summary>
        /// Gera uma medição definitiva para um orçamento.
        /// </summary>
        /// <param name="idOrca"></param>
        public uint GerarMedicaoDefinitivaOrca(uint idOrca)
        {
            lock (_medicaoDefinitivaLock)
            {
                using (var transaction = new GDA.GDATransaction())
                {
                    try
                    {
                        transaction.BeginTransaction();

                        Orcamento orca = OrcamentoDAO.Instance.GetElementByPrimaryKey(transaction, idOrca);

                        if (orca.IdMedicaoDefinitiva.GetValueOrDefault() > 0 &&
                            objPersistence.ExecuteSqlQueryCount("SELECT IdMedicao FROM medicao WHERE Situacao=" +
                                                                (int)Medicao.SituacaoMedicao.Aberta + " AND IdMedicao=" + orca.IdMedicaoDefinitiva.Value) > 0)
                        {
                            throw new Exception("Este orçamento já possui uma medição definitiva, cancele-a para gerar outra.");
                        }

                        Medicao medicao = new Medicao();
                        medicao.Bairro            = orca.BairroObra != null ? orca.BairroObra : orca.Bairro;
                        medicao.Cidade            = orca.CidadeObra != null ? orca.CidadeObra : orca.Cidade;
                        medicao.Endereco          = orca.EnderecoObra != null ? orca.EnderecoObra : orca.Endereco;
                        medicao.IdFunc            = orca.IdFuncionario;
                        medicao.NomeCliente       = orca.NomeCliente;
                        medicao.TelCliente        = orca.TelCliente;
                        medicao.EmailCliente      = orca.Email;
                        medicao.Situacao          = (int)Medicao.SituacaoMedicao.Aberta;
                        medicao.Turno             = 1;
                        medicao.IdLoja            = orca.IdLoja.GetValueOrDefault(LojaDAO.Instance.ObtemValorCampo <uint>(transaction, "idLoja", null));
                        medicao.MedicaoDefinitiva = true;
                        /* Chamado 51781. */
                        medicao.IdOrcamento = idOrca;

                        uint idMedicao = Insert(transaction, medicao);

                        //objPersistence.ExecuteCommand(transaction, "update orcamento set idMedicaoDefinitiva=" + idMedicao +
                        //    " where idOrcamento=" + idOrca);

                        transaction.Commit();
                        transaction.Close();

                        return(idMedicao);
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        transaction.Close();

                        throw ex;
                    }
                }
            }
        }
示例#5
0
        /// <summary>
        /// Finaliza o encontro de contas
        /// </summary>
        public void FinalizaEncontro(uint idEncontroContas, DateTime dataVenc, ref int contaGerada, ref decimal valorGerado)
        {
            lock (EncontroContasLock)
            {
                using (var sessao = new GDA.GDATransaction())
                {
                    try
                    {
                        sessao.BeginTransaction();

                        var idsContasPagarPagas = ContasPagarEncontroContasDAO.Instance.ValidaContasPagar(sessao, idEncontroContas);

                        if (!string.IsNullOrEmpty(idsContasPagarPagas))
                        {
                            throw new Exception(string.Format("As contas a pagar: {0} já foram pagas.", idsContasPagarPagas));
                        }

                        var idsContasReceberRecebidas = ContasReceberEncontroContasDAO.Instance.ValidaContasReceber(sessao, idEncontroContas);

                        if (!string.IsNullOrEmpty(idsContasReceberRecebidas))
                        {
                            throw new Exception(string.Format("As contas a receber: {0} já foram recebidas.", idsContasReceberRecebidas));
                        }

                        //Vincula contas a pagar/receber (Marca a conta como paga ou recebida)
                        ContasPagarEncontroContasDAO.Instance.GeraVinculoContaPagar(sessao, idEncontroContas);
                        ContasReceberEncontroContasDAO.Instance.GeraVinculoContaReceber(sessao, idEncontroContas);

                        Instance.GeraContasPagarReceber(sessao, idEncontroContas, dataVenc,
                                                        ref contaGerada, ref valorGerado);

                        string sql = @"UPDATE encontro_contas
                           SET situacao=" + (int)EncontroContas.SituacaoEncontroContas.Finalizado + @",
                               dataFin=?dtFin, idFuncFin=" + UserInfo.GetUserInfo.CodUser + @"
                           WHERE idEncontroContas=" + idEncontroContas;

                        objPersistence.ExecuteCommand(sessao, sql, new GDAParameter("?dtFin", DateTime.Now));


                        sessao.Commit();
                        sessao.Close();
                    }
                    catch
                    {
                        sessao.Rollback();
                        sessao.Close();

                        throw;
                    }
                }
            }
        }
示例#6
0
        public void RemoveComissaoContasRecebidas(Comissao objDelete)
        {
            // Verifica a conta a pagar gerada por esta comissão foi paga
            if (objPersistence.ExecuteSqlQueryCount("Select Count(*) From contas_pagar Where paga=true And idComissao=" +
                                                    objDelete.IdComissao) > 0)
            {
                throw new Exception("Cancele o pagamento da conta gerada por esta comissão.");
            }

            using (var trans = new GDA.GDATransaction())
            {
                try
                {
                    trans.BeginTransaction();

                    //remove o vinculo das contas recebidas com a comissão
                    ComissaoContasReceberDAO.Instance.DeleteByComissao(trans, objDelete.IdComissao);

                    // Apaga a conta a pagar da comissão
                    ContasPagarDAO.Instance.DeleteByComissao(trans, objDelete.IdComissao, "Cancelamento");

                    //Apaga a comissão
                    DeleteByPrimaryKey(objDelete.IdComissao);

                    trans.Commit();
                    trans.Close();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    trans.Close();

                    ErroDAO.Instance.InserirFromException("Cancelar comissão de contas recebidas", ex);

                    throw ex;
                }
            }
        }
示例#7
0
        /// <summary>
        /// Gera a comissão das contas recebidas
        /// </summary>
        /// <param name="idFunc"></param>
        /// <param name="idsContasR"></param>
        /// <param name="dataContaPg"></param>
        /// <param name="dataCadIni"></param>
        /// <param name="dataCadFim"></param>
        /// <param name="dataRecIni"></param>
        /// <param name="dataRecFim"></param>
        public void GerarComissaoContasRecebidas(uint idFunc, string idsContasR, string dataContaPg, string dataCadIni, string dataCadFim, string dataRecIni, string dataRecFim)
        {
            using (var trans = new GDA.GDATransaction())
            {
                trans.BeginTransaction();

                idsContasR = idsContasR.Trim(',');

                if (idFunc == 0)
                {
                    throw new Exception("O funcionário não foi informado.");
                }

                if (String.IsNullOrEmpty(idsContasR))
                {
                    throw new Exception("Nenhuma conta foi informada.");
                }

                var ids = idsContasR.Trim(',').Split(',').Select(x => x.StrParaUint()).ToList();

                if (ids.Count == 0)
                {
                    throw new Exception("Nenhuma conta foi informada.");
                }

                var contas = ContasReceberDAO.Instance.ObtemContasRecebidasParaComissao(trans, idFunc, idsContasR);

                var contasFora = contas.Where(f => !ids.Contains(f.IdContaR)).Select(f => f.IdContaR).ToList();
                contasFora.AddRange(ids.Where(f => !contas.Select(x => x.IdContaR).ToList().Contains(f)).Select(f => f).ToList());

                if (contasFora.Count > 0)
                {
                    throw new Exception("As contas: " + string.Join(",", contasFora.Select(f => f.ToString()).ToArray()) + " não estão na listagem");
                }

                var valorComissao = contas.Sum(f => f.ValorComissao);

                if (valorComissao <= 0)
                {
                    throw new Exception("Não há valor para gerar comissão.");
                }

                try
                {
                    // Cria uma nova comissao
                    Comissao comissao = new Comissao();
                    comissao.Total      = valorComissao;
                    comissao.DataRefIni = dataCadIni.StrParaDate().GetValueOrDefault();
                    comissao.DataRefFim = dataCadFim.StrParaDate().GetValueOrDefault();
                    comissao.DataRecIni = dataRecIni.StrParaDate();
                    comissao.DataRecFim = dataRecFim.StrParaDate();
                    comissao.DataCad    = DateTime.Now;
                    comissao.IdFunc     = idFunc;

                    var idComissao = Insert(trans, comissao);

                    #region Gera a conta a pagar para a comissão

                    DateTime dataPagar;
                    if (!DateTime.TryParse(dataContaPg, out dataPagar))
                    {
                        dataPagar = DateTime.Now.AddMonths(1);
                    }

                    ContasPagar cp = new ContasPagar();
                    cp.IdComissao = idComissao;
                    cp.IdConta    = FinanceiroConfig.PlanoContaComissao;
                    cp.DataVenc   = dataPagar;
                    cp.ValorVenc  = valorComissao;
                    cp.IdLoja     = UserInfo.GetUserInfo.IdLoja;
                    cp.NumParc    = 1;
                    cp.NumParcMax = 1;
                    cp.Usucad     = UserInfo.GetUserInfo.CodUser;

                    ContasPagarDAO.Instance.Insert(trans, cp);

                    #endregion

                    #region Vincula as contas marcadas para gerar comissão

                    foreach (var c in contas)
                    {
                        ComissaoContasReceberDAO.Instance.Insert(trans, new ComissaoContasReceber()
                        {
                            IdComissao = (int)idComissao,
                            IdContaR   = (int)c.IdContaR,
                            Valor      = c.ValorComissao
                        });
                    }

                    #endregion

                    trans.Commit();
                    trans.Close();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    trans.Close();

                    ErroDAO.Instance.InserirFromException("Comissão de contas recebidas", ex);
                    throw ex;
                }
            }
        }
示例#8
0
        /// <summary>
        /// Finaliza a medição passada e gera um orçamento para a mesma, retornando o id deste
        /// </summary>
        public uint FinalizarMedicao(uint idMedicao)
        {
            using (var transaction = new GDA.GDATransaction())
            {
                try
                {
                    transaction.BeginTransaction();

                    var login = UserInfo.GetUserInfo;

                    if (!Config.PossuiPermissao(Config.FuncaoMenuMedicao.EfetuarMedicao))
                    {
                        throw new Exception("Apenas o Aux. Escritório Medição pode finalizar medições.");
                    }

                    var medicao = GetMedicao(transaction, idMedicao);

                    //variavel utilizada apenas para o log, para não ter que ir no banco novamente buscar a medição.
                    var medicaoLog = medicao;

                    if (medicao.Situacao == (int)Medicao.SituacaoMedicao.Finalizada)
                    {
                        throw new Exception("Medição já finalizada.");
                    }

                    medicao.Situacao   = (int)Medicao.SituacaoMedicao.Finalizada;
                    medicao.IdFuncConf = login.CodUser;
                    medicao.DataConf   = DateTime.Now;

                    uint idOrca = 0;

                    /* Chamado 50817. */
                    // Caso a medição esteja associada a um pedido ou a um orçamento, não gera o orçamento ou
                    // retorna o ID do orçamento com medição definitiva.
                    if (medicao.IdPedido.GetValueOrDefault() == 0 && medicao.IdOrcamento.GetValueOrDefault() == 0)
                    {
                        Orcamento orca = new Orcamento();
                        orca.Bairro        = medicao.Bairro;
                        orca.Cidade        = medicao.Cidade;
                        orca.Endereco      = medicao.Endereco;
                        orca.IdFuncionario = medicao.IdFunc == 0 ? null : medicao.IdFunc;
                        orca.NomeCliente   = medicao.NomeCliente;
                        orca.TelCliente    = medicao.TelCliente;
                        orca.CelCliente    = medicao.CelCliente;
                        orca.Email         = medicao.EmailCliente;
                        orca.TipoEntrega   = (int?)Orcamento.TipoEntregaOrcamento.Temperado;
                        orca.Validade      = OrcamentoConfig.DadosOrcamento.ValidadeOrcamento;
                        orca.PrazoEntrega  = OrcamentoConfig.DadosOrcamento.PrazoEntregaOrcamento;

                        orca.FormaPagto = !string.IsNullOrEmpty(medicao.FormaPagto) ? medicao.FormaPagto :
                                          OrcamentoConfig.DadosOrcamento.FormaPagtoOrcamento;

                        orca.Situacao = (int)Orcamento.SituacaoOrcamento.EmAberto;

                        idOrca = OrcamentoDAO.Instance.Insert(transaction, orca);

                        medicao.IdOrcamento = idOrca;
                    }

                    LogAlteracaoDAO.Instance.LogMedicao(GetMedicao(idMedicao), medicao);
                    Update(transaction, medicao);

                    transaction.Commit();
                    transaction.Close();

                    return(idOrca);
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    transaction.Close();

                    throw ex;
                }
            }
        }
示例#9
0
        /// <summary>
        /// Retifica um encontro de contas
        /// </summary>
        public void RetificaEncontro(int idEncontroContas, List <string> idsContasPagar, List <string> idsContasReceber,
                                     DateTime dataVenc, ref int contaGerada, ref decimal valorGerado)
        {
            lock (EncontroContasLock)
            {
                using (var transaction = new GDA.GDATransaction())
                {
                    try
                    {
                        transaction.BeginTransaction();

                        //Apaga as contas a pagar/receber geradas
                        var tipoConta = Instance.ObtemTipoContaGerar(transaction, (uint)idEncontroContas);

                        if (tipoConta == 1)
                        {
                            ContasPagarDAO.Instance.DeleteByEncontroContas(transaction, (uint)idEncontroContas);
                        }
                        else if (tipoConta == 2)
                        {
                            ContasReceberDAO.Instance.DeleteByEncontroContas(transaction, (uint)idEncontroContas);
                        }

                        //Apaga os vinculos das contas a pagar/receber (desmarca a conta como paga ou recebida)
                        ContasPagarEncontroContasDAO.Instance.RemoveVinculoContaPagar(transaction, (uint)idEncontroContas);
                        ContasReceberEncontroContasDAO.Instance.RemoveVinculoContaReceber(transaction, (uint)idEncontroContas);

                        foreach (var idContaPg in idsContasPagar)
                        {
                            ContasPagarEncontroContasDAO.Instance.DeleteByIdContaPg(transaction, idContaPg.StrParaUint());
                        }
                        foreach (var idContaR in idsContasReceber)
                        {
                            ContasReceberEncontroContasDAO.Instance.DeleteByIdContaR(transaction, idContaR.StrParaUint());
                        }

                        //Vincula contas a pagar/receber (Marca a conta como paga ou recebida)
                        ContasPagarEncontroContasDAO.Instance.GeraVinculoContaPagar(transaction, (uint)idEncontroContas);
                        ContasReceberEncontroContasDAO.Instance.GeraVinculoContaReceber(transaction, (uint)idEncontroContas);

                        //Gera contas a pagar/receber
                        Instance.GeraContasPagarReceber(transaction, (uint)idEncontroContas, dataVenc, ref contaGerada, ref valorGerado);

                        //Salva log de retificação
                        var dados =
                            string.Format(
                                "Contas a pagar removidas: {0} Contas a receber removidas: {1}",
                                string.Join(",", idsContasPagar), string.Join(",", idsContasReceber));

                        Instance.AtualizaObs(transaction, (uint)idEncontroContas, dados);

                        var ec = Instance.GetElement(transaction, (uint)idEncontroContas);
                        ec.DadosRetificar = dados;

                        LogAlteracaoDAO.Instance.LogEncontroContas(transaction, ec);

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

                        throw;
                    }
                }
            }
        }