public void ConsultarTipoEmprestimo()
        {
            Emprestimo emprestimo = new EmprestimoDAO().PesquisarEmprestimoPorId(5);

            Console.WriteLine(new PagamentoDAO().BuscarPagamentosPorEmprestimo(emprestimo)[0]);

            String tipo = new PagamentoDAO().TipoPagamentoEmprestimo(emprestimo);

            Console.Write(tipo);
        }
Example #2
0
        public ActionResult Pagamento(Pagamento pagamentoModel)
        {
            PagamentoDAO pagamentoDAO = new PagamentoDAO();

            pagamentoDAO.Inserir(pagamentoModel);

            Escola escolaModel = new EscolaDAO().ConsultarPorID(pagamentoModel.IdEscola);

            return(View("MainPage", escolaModel));
        }
        public ActionResult Index()
        {
            PagamentoDAO daoPgto = new PagamentoDAO();
            Pagamento    pgto    = new Pagamento();

            var Recebiveis = daoPgto.Listar().Count(x => x.Status != 1);
            var Pago       = daoPgto.Listar().Count(x => x.Status == 1);

            return(View(Recebiveis));
        }
Example #4
0
        double valorEmAberto = 0; // VARIÁVEL QUE SERÁ EDITADA PELA REGRA DE NEGÓCIO EM PAGAMENTO.CONTROLLER

        // GET: Contrato
        public ActionResult Adicionar(int idCliente, string nomeTitular, double valorContrato, int quantidadeParcelas, DateTime primeiroVencimento, string garantia, int empresaIdEmpresa)
        {
            Contrato    contrato = new Contrato();
            ContratoDAO dao      = new ContratoDAO();
            Cliente     cliente  = new Cliente();

            contrato.IdCliente          = idCliente;
            contrato.NomeTitular        = nomeTitular;
            contrato.ValorContrato      = valorContrato;
            contrato.QuantidadeParcelas = quantidadeParcelas;
            contrato.PrimeiroVencimento = primeiroVencimento;
            contrato.Garantia           = garantia;
            contrato.EmpresaIdEmpresa   = empresaIdEmpresa;


            contrato.ValorEmAberto = valorEmAberto;

            dao.Adicionar(contrato);

            double auxiliarValorParcela = 0;                                // Usada para ALTERAR a entidade valorEmABerto na entidade CONTRATO depois
            //que o método do método de valor de parcelas ter calculado o montante total

            double valorParcela;

            for (var i = 0; i < quantidadeParcelas; i++)
            {
                Pagamento pagamento = new Pagamento();

                valorParcela = pagamento.CalculoContrato(valorContrato, quantidadeParcelas);


                // INSERINDO NA TABELA PAGAMENTOS

                PagamentoDAO daoPagamento = new PagamentoDAO();
                pagamento.ValorIntegralDaParcela = valorParcela;
                pagamento.Status     = 0;
                pagamento.IdContrato = contrato.IdContrato;
                // ^ Metodo precisa vir depois de ADICIONAR CONTRATO, para que ele tenha uma ID pra ser registrada na table pagamentos
                pagamento.IdCliente = idCliente;
                // ^ Este dado não é pedido na entidade CONTRATO

                pagamento.DataVencimento = primeiroVencimento.AddMonths(i);
                daoPagamento.Adicionar(pagamento);

                auxiliarValorParcela = valorParcela * quantidadeParcelas;
            }

            contrato.ValorEmAberto = auxiliarValorParcela;

            dao.Alterar(contrato);

            return(RedirectToAction("Form"));
        }
Example #5
0
        //public bool SP_U_TB016_Vincula_TB025(Int64 TB016_id, Int64 TB012_id, Int64 TB025_id)
        //{
        //    try
        //    {
        //        PagamentoDAO DAO = new PagamentoDAO();
        //        return DAO.SP_U_TB016_Vincula_TB025(TB016_id, TB012_id, TB025_id);
        //    }
        //    catch (Exception ex)
        //    {
        //        throw ex;
        //    }
        //}

        //public long PagamentoIncluir(PagamentosController Pagamento, Int64 TB013_AlteradoPor,Int64 TB012_Id)
        //{
        //    try
        //    {
        //        PagamentoDAO DAO = new PagamentoDAO();

        //        Int64 Retorno = DAO.PagamentoIncluir(Pagamento);

        //        if(Retorno>0)
        //        {
        //            LogNegocios Log_N = new LogNegocios();
        //            LogController Log_C = new LogController();
        //            Log_C.TB012_Id = TB012_Id;
        //            Log_C.TB011_Id = TB013_AlteradoPor;
        //            Log_C.TB000_IdTabela = 25;
        //            Log_C.TB000_Tabela = "Pagamento";
        //            Log_C.TB000_Data = DateTime.Now;
        //            Log_C.TB000_Descricao = string.Format(MensagensLog.L0028.ToString(), Retorno);
        //            Log_N.LogInsert(Log_C);
        //        }

        //        return Retorno;
        //    }
        //    catch (Exception ex)
        //    {
        //        throw ex;
        //    }
        //}

        //public bool SP_U_TB013_GerarCartaoMassa()
        //{
        //    try
        //    {
        //        PagamentoDAO DAO = new PagamentoDAO();
        //        return DAO.SP_U_TB013_GerarCartaoMassa();
        //    }
        //    catch (Exception ex)
        //    {
        //        throw ex;
        //    }
        //}

        public List <PagamentosController> ParcelasListarErrosSICOOB(DateTime Inicio, DateTime fim)
        {
            try
            {
                PagamentoDAO DAO = new PagamentoDAO();
                return(DAO.ParcelasListarErrosSICOOB(Inicio, fim));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #6
0
 public List <PagamentosController> PagamentosMesAno(int Mes, int Ano)
 {
     try
     {
         PagamentoDAO DAO = new PagamentoDAO();
         return(DAO.PagamentosMesAno(Mes, Ano));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #7
0
        public ActionResult Details(int idContrato)
        {
            ContratoDAO  dao     = new ContratoDAO();
            PagamentoDAO daoPgto = new PagamentoDAO();
            ClienteDAO   Cldao   = new ClienteDAO();
            Cliente      cliente = new Cliente();

            ViewBag.ClienteSet   = dao.Listar().FirstOrDefault(X => X.IdContrato == idContrato);
            ViewBag.ContratoSet  = dao.Listar().FirstOrDefault(x => x.IdContrato == idContrato);
            ViewBag.PagamentoSet = daoPgto.Listar().FirstOrDefault(x => x.IdContrato == idContrato);

            return(View("Details"));
        }
Example #8
0
        public void Excluir(int ID)
        {
            using (Connection con = new Connection())
            {
                con.Abrir();
                IDAO <Pagamento> TableIDAO = new PagamentoDAO(con);

                Pagamento pagamento = new Pagamento();
                pagamento.PAGAMENTO_ID = ID;

                TableIDAO.Remover(pagamento);
            }
        }
Example #9
0
        public Pagamento LocalizarPorCodigo(int ID)
        {
            Pagamento result = null;

            using (Connection con = new Connection())
            {
                con.Abrir();
                IDAO <Pagamento> TableIDAO = new PagamentoDAO(con);

                result = TableIDAO.LocalizarPorCodigo(ID);
            }

            return(result);
        }
Example #10
0
        public Collection <Pagamento> ListarTudo()
        {
            Collection <Pagamento> result = null;

            using (Connection con = new Connection())
            {
                con.Abrir();
                IDAO <Pagamento> TableIDAO = new PagamentoDAO(con);

                result = TableIDAO.ListarTudo();
            }

            return(result);
        }
        // GET: Pagamento
        public ActionResult Adicionar(double valorIntegralDaParcela, DateTime dataVencimento, int contratoIdContrato,
                                      int clienteIdCliente)
        {
            Pagamento    pagamento = new Pagamento();
            PagamentoDAO dao       = new PagamentoDAO();

            pagamento.ValorIntegralDaParcela = valorIntegralDaParcela;
            pagamento.Status         = 0;
            pagamento.DataVencimento = dataVencimento;
            pagamento.IdContrato     = contratoIdContrato;
            pagamento.IdCliente      = clienteIdCliente;

            dao.Adicionar(pagamento);

            return(View());
        }
        public void TestListarTodosOsPagamentos()
        {
            PagamentoDAO pDAO = new PagamentoDAO();


            DataTable table = new DataTable();

            table = pDAO.BuscarPagamentosPorIdDoEmprestimo(1);

            foreach (DataRow item in table.Rows)
            {
                Console.WriteLine(item["Pagamento_Id"]);
            }

            Assert.AreNotEqual(false, table);
        }
        public ActionResult AlterarPagamento(int idpagamento, double valorIntegralDaParcela, int status, DateTime dataVencimento, double valorPago, int contratoIdContrato,
                                             int clienteIdCliente)
        {
            PagamentoDAO dao       = new PagamentoDAO();
            Pagamento    pagamento = dao.Listar().FirstOrDefault(x => x.IdPagamento == idpagamento);

            ContratoDAO CtDao    = new ContratoDAO();
            var         contrato = new Contrato();


            pagamento.Status = 1; // STATUS DE RECEBIMENTO

            var dataAtual = DateTime.Now;
            var outraData = pagamento.DataVencimento;

            TimeSpan Atraso = dataAtual.Subtract(outraData);

            double diasDeAtraso = Atraso.TotalDays;


            var novoValorPagamento = pagamento.CalculaJuroDiario(valorIntegralDaParcela, diasDeAtraso);

            if (valorPago < valorIntegralDaParcela)
            {
                var proximoPagamento = dao.BuscarProximoPagamento(pagamento);
                if (proximoPagamento == null)
                {
                    pagamento.ValorIntegralDaParcela = valorIntegralDaParcela;
                    pagamento.Status         = status;
                    pagamento.DataVencimento = dataVencimento;
                    pagamento.IdContrato     = contratoIdContrato;
                    pagamento.IdCliente      = clienteIdCliente;

                    dao.Adicionar(pagamento);
                }
            }

            pagamento.ValorIntegralDaParcela = valorIntegralDaParcela;
            pagamento.Status         = status;
            pagamento.DataVencimento = dataVencimento;
            pagamento.IdContrato     = contratoIdContrato;
            pagamento.IdCliente      = clienteIdCliente;

            dao.Alterar(pagamento);

            return(View(pagamento));
        }
Example #14
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (Session["contaCorrente"] == null)
            {
                Response.Redirect("~/Views/vwLogin.aspx");
            }
            PagamentoBoleto pagamentoBoleto = new PagamentoDAO().BuscarPagamentoPorId(Convert.ToInt32(Session["Pag_Boleto_id"])) as PagamentoBoleto;

            lblCodBarras.Text  = pagamentoBoleto.Codigo.ToString();
            lblConta.Text      = pagamentoBoleto.Emprestimo.ContaCorrente.Numero.ToString();
            lblEmpCod.Text     = pagamentoBoleto.Emprestimo.Id.ToString();
            lblPago.Text       = (pagamentoBoleto.Pago ? "Sim" : "Não");
            lblValor.Text      = pagamentoBoleto.Valor.ToString("c2");
            lblVencimento.Text = pagamentoBoleto.Vencimento.ToString("dd/MM/yyyy");
            lblCliente.Text    = pagamentoBoleto.Emprestimo.ContaCorrente.Pessoa.Nome;
            lblClienteCPF.Text = pagamentoBoleto.Emprestimo.ContaCorrente.Pessoa.Cpf;
        }
Example #15
0
        public IList <Passeio> PasseiosConcluidoDaEscola(Escola escola)
        {
            Pagamento        pagamento     = new PagamentoDAO().BuscarEscolaPorId(escola.IdEscola);
            PasseioEscolaDAO dao           = new PasseioEscolaDAO();
            IList <Passeio>  listaPasseios = new List <Passeio>();

            IList <PasseioEscola> listaPasseiosEscola = new List <PasseioEscola>();

            listaPasseiosEscola = dao.ListarTodosPasseios().Where(p => p.idEscola == pagamento.IdEscola).ToList();

            foreach (var item in listaPasseiosEscola)
            {
                listaPasseios.Add(new PasseioDAO().BuscarPorId(item.IdPasseio));
            }

            return(listaPasseios.Where(p => p.PasseioRealizado == true).ToList());
        }
Example #16
0
        //se o pagamento for bem sucedido
        public ActionResult sucessopg(int id)
        {
            if (Session["idVendedor"] != null)
            {
                PagamentoDAO objPD = new PagamentoDAO();
                Pagamento    objP  = objPD.GetPagamento(id);

                ParcelasDAO objPrD = new ParcelasDAO();
                Parcelas    objPr  = objPrD.GetParcelas(id);

                return(View(Tuple.Create(objPr, objP)));
            }
            else
            {
                return(RedirectToAction("Index"));
            }
        }
        public ActionResult Quitar(int idpagamento)
        {
            PagamentoDAO dao       = new PagamentoDAO();
            Pagamento    pagamento = dao.Listar().FirstOrDefault(x => x.IdPagamento == idpagamento);

            double pgtoRealizado = 0;

            pagamento.ValorIntegralDaParcela = pgtoRealizado;
            pagamento.Status         = 1;
            pagamento.DataVencimento = pagamento.DataVencimento;
            pagamento.IdContrato     = pagamento.IdContrato;
            pagamento.IdCliente      = pagamento.IdCliente;

            dao.Alterar(pagamento);

            return(Json(pagamento));
        }
Example #18
0
    public ReportDocument GerarRelatorioPgtoProdutores(Pagamento pgto, String strPathreport)
    {
        PagamentoDAO obj = new PagamentoDAO();
        ReportDocument rpt = new ReportDocument();

        DateTime dtInicialDigitada = Convert.ToDateTime(pgto.Dt_inicio);
        DateTime dtFinalDigitada = Convert.ToDateTime(pgto.Dt_fim);

        String dataInicialDigitada = dtInicialDigitada.ToString("dd/MM/yyyy");
        String dataFinalDigitada = dtFinalDigitada.ToString("dd/MM/yyyy");

        if (pgto.Id_regiao == 0)
            throw new Exception("Selecione a região!");
        else if (pgto.Id_cooperativa == 0)
            throw new Exception("Selecione a cooperativa!");
        else if (Convert.ToDateTime(dataInicialDigitada) > Convert.ToDateTime(dataFinalDigitada))
            throw new Exception("A data final não pode ser inferior a data inicial");

        rpt = obj.GerarRelatorioPgtoProdutores(pgto, strPathreport);
        return rpt;
    }
Example #19
0
        public void Inserir(Pagamento obj)
        {
            using (Connection con = new Connection())
            {
                con.Abrir();
                IDAO <Pagamento> TableIDAO = new PagamentoDAO(con);

                Pagamento pagamento = new Pagamento();

                pagamento.PAGAMENTO_DATA         = obj.PAGAMENTO_DATA;
                pagamento.PAGAMENTO_VENCIMENTO   = obj.PAGAMENTO_VENCIMENTO;
                pagamento.PAGAMENTO_VALORPAGAR   = obj.PAGAMENTO_VALORPAGAR;
                pagamento.PAGAMENTO_VALORPAGO    = obj.PAGAMENTO_VALORPAGO;
                pagamento.PAGAMENTO_PAGADOR      = obj.PAGAMENTO_PAGADOR;
                pagamento.PAGAMENTO_BENEFICIARIO = obj.PAGAMENTO_BENEFICIARIO;
                pagamento.PAGAMENTO_METODOPAG    = obj.PAGAMENTO_METODOPAG;
                pagamento.PAGAMENTO_FORMAPAG     = obj.PAGAMENTO_FORMAPAG;
                pagamento.PAGAMENTO_TIPOPAG      = obj.PAGAMENTO_TIPOPAG;

                TableIDAO.Inserir(pagamento);
            }
        }
Example #20
0
        private async void btnEnviar_Click(object sender, EventArgs e)
        {
            tDesabilitaBtn.Tick += tDesabilitaBtn_Tick;
            tDesabilitaBtn.Start();
            btnEnviar.Enabled = false;

            divida.valor = (divida.valor / (lbParcelas.SelectedIndex + 1));

            for (int i = 0; i <= lbParcelas.SelectedIndex; i++)
            {
                //envia email d acordo com as parcelas selecionadas
                mail.enviarEmail(devedor.email, divida);
                await Task.Delay(1000);

                //registra na tabela de pagamentos
                var pmt = new Pagamento();
                pmt.valorParcela = divida.valor;
                pmt.vencimento   = divida.dataVencimento;
                pmt.iddivida     = divida.idDevedor;
                PagamentoDAO.SetPagamento(pmt);

                //mes de vencimento ++ para poder registrar e mandar emails com vencimentos diferentes
                divida.dataVencimento = divida.dataVencimento.AddMonths(1);
            }

            //atualiza status da divida para sair da lista de cobrança
            divida.status = "boleto emitido";
            DividaDAO.UpdateStatus(divida);

            //faz registro para gerar relatorio depois
            var registro = "Email enviado com o valor de " + divida.valor.ToString("c") +
                           "por parcela a ser pago, divido em "
                           + (lbParcelas.SelectedIndex + 1).ToString() + " vezes";

            RelatorioDAO.inserirRegistro(divida.idDivida, devedor.iddevedor, registro);
        }
Example #21
0
 public bool LiberarPagamento(Pagamento pgto, String usuario)
 {
     PagamentoDAO obj = new PagamentoDAO();
     return obj.LiberarPagamento(pgto, usuario);
 }
 public PagamentoController(PagamentoDAO pagamentoDAO, AlunoDAO alunoDAO)
 {
     this.pagamentoDAO = pagamentoDAO;
     this.alunoDAO     = alunoDAO;
 }
        public void TestBuscarPagamentoBoleto()
        {
            Pagamento pagamento = new PagamentoDAO().BuscarPagamentoPorId(1);

            Console.Write(pagamento);
        }
Example #24
0
 public DevolucaoController(ReservaDAO reservaDAO, PagamentoDAO pagamentoDAO)
 {
     _reservaDAO   = reservaDAO;
     _pagamentoDAO = pagamentoDAO;
 }
Example #25
0
    public bool LiberarPagamento(Pagamento pgto, String usuario)
    {
        PagamentoDAO obj = new PagamentoDAO();

        return(obj.LiberarPagamento(pgto, usuario));
    }