private bool VerifyBeforeDelete(long IDEntrada,
                                        ref List <objMovimentacao> listMovs,
                                        AcessoDados dbTran)
        {
            try
            {
                bool   err        = false;
                string errMessage = "";

                // VERIFY MOVIMENTACAO ENTRADA FROM Entrada
                //------------------------------------------------------------------------------------------------------------
                MovimentacaoBLL mBLL = new MovimentacaoBLL();
                listMovs = mBLL.GetMovimentacaoListByOrigem(EnumMovOrigem.Entrada, IDEntrada, false, dbTran);

                // VERIFY RECEBIMENTOS WITH CAIXA OR BLOCKED
                //------------------------------------------------------------------------------------------------------------
                errMessage = "Essa Entrada possui movimentações que foram inseridas no caixa...\n";

                foreach (objMovimentacao entrada in listMovs)
                {
                    if (entrada.IDCaixa != null)
                    {
                        errMessage += $"Reg.: {entrada.IDMovimentacao:D4} | {entrada.MovData.ToShortDateString()} | Caixa: {entrada.IDCaixa:D4}\n";
                        err         = true;
                    }
                }

                if (err == true)
                {
                    errMessage += "Favor remover o(s) caixa(s) se desejar EXCLUIR a(s) Entrada.";
                    throw new AppException(errMessage);
                }

                return(true);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        // VERIFY DESPESA BEFORE DELETE
        //------------------------------------------------------------------------------------------------------------
        public bool VerifyBeforeDelete(objDespesaCartao despesa,
                                       ref List <objAPagar> listAPagar,
                                       ref List <objMovimentacao> listMovSaidas,
                                       AcessoDados dbTran)
        {
            try
            {
                long IDDespesa = (long)despesa.IDDespesa;

                // VERIFY IMAGEM
                //------------------------------------------------------------------------------------------------------------
                if (despesa.Imagem != null && !string.IsNullOrEmpty(despesa.Imagem.ImagemFileName))
                {
                    throw new AppException("A despesa não pode ser excluída pois possui uma imagem vinculada a ela...");
                }

                // GET APAGAR
                //------------------------------------------------------------------------------------------------------------
                listAPagar = new APagarBLL().GetListAPagarByDespesa(IDDespesa, dbTran);

                // VERIFY APAGAR
                //------------------------------------------------------------------------------------------------------------
                bool   err        = false;
                string errMessage = "Os a PAGAR abaixo possuem pagamentos...\n";

                Action <objAPagar> addMessage = (pagar) =>
                {
                    errMessage += $"Reg.: {pagar.IDAPagar:D4}    {pagar.Vencimento.ToShortDateString()}\n";
                    err         = true;
                };

                listAPagar.Where(x => x.IDSituacao == 2).ToList().ForEach(addMessage);

                if (err == true)
                {
                    errMessage += "Favor estornar antes os pagamentos se deseja EXCLUIR a despesa.";
                    throw new AppException(errMessage);
                }

                // VERIFY APAGAR IMAGES
                //------------------------------------------------------------------------------------------------------------
                errMessage = "Os APagar abaixo possuem IMAGEM associada\n";

                listAPagar.Where(x => x.Imagem != null && !string.IsNullOrEmpty(x.Imagem.ImagemFileName)).ToList().ForEach(addMessage);

                if (err == true)
                {
                    errMessage += "Favor remover/desassociar as imagens do APagar se deseja EXCLUIR a despesa.";
                    throw new AppException(errMessage);
                }

                // VERIFY MOVIMENTACAO SAIDA FROM APAGAR
                //------------------------------------------------------------------------------------------------------------
                MovimentacaoBLL mBLL = new MovimentacaoBLL();
                listMovSaidas = new List <objMovimentacao>();

                if (listAPagar.Count > 0)
                {
                    foreach (objAPagar pagar in listAPagar)
                    {
                        listMovSaidas.AddRange(mBLL.GetMovimentacaoListByOrigem(EnumMovOrigem.APagar, (long)pagar.IDAPagar, true, dbTran));
                    }
                }

                // VERIFY RECEBIMENTOS WITH CAIXA OR BLOCKED
                //------------------------------------------------------------------------------------------------------------
                errMessage = "Essa Despesa possui pagamentos que foram inseridas no caixa...\n";

                Action <objMovimentacao> addMessageMov = (saida) =>
                {
                    errMessage += $"Reg.: {saida.IDMovimentacao:D4} | {saida.MovData.ToShortDateString()} | Caixa: {saida.IDCaixa:D4}\n";
                    err         = true;
                };

                listMovSaidas.Where(x => x.IDCaixa != null).ToList().ForEach(addMessageMov);

                if (err == true)
                {
                    errMessage += "Favor remover o(s) caixa(s) se desejar EXCLUIR a(s) DESPESA.";
                    throw new AppException(errMessage);
                }

                // VERIFY MOVIMENTACAO SAIDA IMAGES
                //------------------------------------------------------------------------------------------------------------
                errMessage = "As Saídas abaixo possuem IMEGEM associada\n";

                listMovSaidas.Where(x => x.Imagem != null && !string.IsNullOrEmpty(x.Imagem.ImagemFileName)).ToList().ForEach(addMessageMov);

                if (err == true)
                {
                    errMessage += "Favor remover/desassociar as imagens das Saídas se deseja EXCLUIR a despesa.";
                    throw new AppException(errMessage);
                }

                return(true);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #3
0
        private bool VerifyBeforeDelete(long IDContribuicao,
                                        ref List <objAReceber> listAReceber,
                                        ref List <objMovimentacao> listEntradas,
                                        AcessoDados dbTran)
        {
            try
            {
                // GET ARECEBER
                //------------------------------------------------------------------------------------------------------------
                listAReceber = new AReceberBLL().GetListAReceberByIDContribuicao(IDContribuicao, dbTran);

                // VERIFY ARECEBER
                //------------------------------------------------------------------------------------------------------------
                bool   err        = false;
                string errMessage = "Os ARECEBER abaixo possuem recebimentos...\n";

                foreach (objAReceber receber in listAReceber)
                {
                    if (receber.IDSituacao == 2)
                    {
                        errMessage += $"Reg.: {receber.IDAReceber:D4}    {receber.CompensacaoData.ToShortDateString()}\n";
                        err         = true;
                    }
                }

                if (err == true)
                {
                    errMessage += "Favor estornar antes os recebimentos se deseja EXCLUIR a contribuição.";
                    throw new AppException(errMessage);
                }

                // VERIFY MOVIMENTACAO ENTRADA FROM CONTRIBUICAO
                //------------------------------------------------------------------------------------------------------------
                MovimentacaoBLL mBLL = new MovimentacaoBLL();
                listEntradas = mBLL.GetMovimentacaoListByOrigem(EnumMovOrigem.Contribuicao, IDContribuicao, false, dbTran);

                // VERIFY MOVIMENTACAO ENTRADA FROM ARECEBER
                //------------------------------------------------------------------------------------------------------------
                if (listAReceber.Count > 0)
                {
                    foreach (objAReceber receber in listAReceber)
                    {
                        listEntradas.AddRange(mBLL.GetMovimentacaoListByOrigem(EnumMovOrigem.AReceber, (long)receber.IDAReceber, false, dbTran));
                    }
                }

                // VERIFY RECEBIMENTOS WITH CAIXA OR BLOCKED
                //------------------------------------------------------------------------------------------------------------
                errMessage = "Essa Contribuição possui entradas que foram inseridas no caixa...\n";

                foreach (objMovimentacao entrada in listEntradas)
                {
                    if (entrada.IDCaixa != null)
                    {
                        errMessage += $"Reg.: {entrada.IDMovimentacao:D4} | {entrada.MovData.ToShortDateString()} | Caixa: {entrada.IDCaixa:D4}\n";
                        err         = true;
                    }
                }

                if (err == true)
                {
                    errMessage += "Favor remover o(s) caixa(s) se desejar EXCLUIR a(s) contribuição.";
                    throw new AppException(errMessage);
                }

                return(true);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }