Esempio n. 1
0
        /// <summary>
        /// Excluir os beneficiarios que não da lista
        /// </summary>
        /// <param name="id_cliente">Id do cliente</param>
        /// <param name="beneficiarios">Lista de beneficiarios</param>
        /// <returns></returns>
        public void ExcluirOsQueNaoSaoDaLista(long id_cliente, List <DML.Beneficiario> beneficiarios)
        {
            DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
            List <string>       lista = this.Converter(beneficiarios);

            benef.ExcluirOsQueNaoSaoDaLista(id_cliente, lista);
        }
Esempio n. 2
0
        /// <summary>
        /// Altera um cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public void Alterar(DML.Cliente cliente)
        {
            DAL.DaoCliente cli = new DAL.DaoCliente();
            cli.Alterar(cliente);

            // Cadastra beneficiários
            DAL.DaoBeneficiario ben = new DAL.DaoBeneficiario();
            cliente.Beneficiarios.ForEach(cliBen => {
                var beneficiario = ben.Consultar(CPF: cliBen.CPF);

                if (beneficiario == null)
                {
                    ben.Incluir(cliBen);
                }
                else
                {
                    cliBen.Id = beneficiario.Id;
                    ben.Alterar(cliBen);
                }
            });

            // Remove beneficiários
            var beneficios = ben.Listar()
                             .Where(beneficiario => cliente.Id.Equals(beneficiario.IdCliente)).ToList();
            var beneficiosExcluidos = beneficios
                                      .Where(beneficiario => !cliente.Beneficiarios.Select(b => b.CPF).Contains(beneficiario.CPF)).ToList();

            beneficiosExcluidos.ForEach(beneficiario => {
                ben.Excluir(beneficiario.Id);
            });
        }
Esempio n. 3
0
 /// <summary>
 /// Inclui os beneficiários de um cliente
 /// </summary>
 /// <param name="cliente">Objeto de cliente</param>
 public void IncluirBeneficiarios(DML.Cliente cliente)
 {
     DAL.DaoBeneficiario benefDAO = new DAL.DaoBeneficiario();
     foreach (var benef in cliente.Beneficiarios)
     {
         benef.IdCliente = cliente.Id;
         benefDAO.Incluir(benef);
     }
 }
Esempio n. 4
0
        /// <summary>
        /// Consulta o cliente pelo id
        /// </summary>
        /// <param name="id">id do cliente</param>
        /// <returns></returns>
        public DML.Cliente Consultar(long id)
        {
            DAL.DaoCliente      cli = new DAL.DaoCliente();
            DAL.DaoBeneficiario ben = new DAL.DaoBeneficiario();

            DML.Cliente cliente = cli.Consultar(id);
            cliente.Beneficiarios = ben.Listar(cliente.Id);

            return(cliente);
        }
Esempio n. 5
0
        /// <summary>
        /// Exclui os beneficiários de um cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public void ExcluirBeneficiarios(long IdCliente)
        {
            DAL.DaoBeneficiario benefDAO = new DAL.DaoBeneficiario();

            var cli = Consultar(IdCliente);

            foreach (var benef in cli.Beneficiarios)
            {
                benefDAO.Excluir(benef.Id);
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Altera um cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public void Alterar(DML.Cliente cliente)
        {
            DAL.DaoCliente      cliDAO   = new DAL.DaoCliente();
            DAL.DaoBeneficiario benefDAO = new DAL.DaoBeneficiario();

            cliDAO.Alterar(cliente);

            foreach (var benef in cliente.Beneficiarios)
            {
                benefDAO.Alterar(benef);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Consulta o cliente pelo id
        /// </summary>
        /// <param name="id">id do cliente</param>
        /// <returns></returns>
        public DML.Cliente Consultar(long id)
        {
            DAL.DaoCliente cli     = new DAL.DaoCliente();
            var            cliente = cli.Consultar(id);

            // Obtém beneficiários
            DAL.DaoBeneficiario ben = new DAL.DaoBeneficiario();
            var Beneficiario        = ben.Listar(IdCliente: cliente.Id);

            cliente.Beneficiarios = Beneficiario;
            return(cliente);
        }
Esempio n. 8
0
        /// <summary>
        /// Altera um cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public void Alterar(DML.Cliente cliente)
        {
            DAL.DaoBeneficiario daoBene = new DAL.DaoBeneficiario();
            DAL.DaoCliente      cli     = new DAL.DaoCliente();
            cli.Alterar(cliente);

            List <Beneficiario> listaBeneficiarioAlterar = new List <Beneficiario>();
            List <Beneficiario> listaBeneficiarioInserir = new List <Beneficiario>();
            List <Beneficiario> listaBeneficiario        = daoBene.ListarBeneficiarioDoCliente(cliente.Id);

            if (listaBeneficiario != null && listaBeneficiario.Count > 0)
            {
                foreach (var beneficiario in cliente.ListaBeneficiario)
                {
                    if (listaBeneficiario.Any(b => b.Cpf == beneficiario.Cpf))
                    {
                        beneficiario.Cliente.Id = cliente.Id;
                        beneficiario.Id         = listaBeneficiario.First(b => b.Cpf == beneficiario.Cpf).Id;
                        listaBeneficiarioAlterar.Add(beneficiario);
                        listaBeneficiario.RemoveAll(b => b.Cpf == beneficiario.Cpf);
                    }
                    else
                    {
                        beneficiario.Cliente.Id = cliente.Id;
                        listaBeneficiarioInserir.Add(beneficiario);
                    }
                }

                foreach (var beneficiario in listaBeneficiarioInserir)
                {
                    daoBene.Incluir(beneficiario);
                }

                foreach (var beneficiario in listaBeneficiarioAlterar)
                {
                    daoBene.Alterar(beneficiario);
                }

                foreach (var beneficiario in listaBeneficiario)
                {
                    daoBene.Excluir(beneficiario.Id);
                }
            }
            else
            {
                foreach (var beneficiario in cliente.ListaBeneficiario)
                {
                    beneficiario.Cliente.Id = cliente.Id;
                    daoBene.Incluir(beneficiario);
                }
            }
        }
Esempio n. 9
0
        /// <summary>
        /// Lista os clientes
        /// </summary>
        public List <DML.Cliente> Pesquisa(int iniciarEm, int quantidade, string campoOrdenacao, bool crescente, out int qtd)
        {
            DAL.DaoCliente cli      = new DAL.DaoCliente();
            var            clientes = cli.Pesquisa(iniciarEm, quantidade, campoOrdenacao, crescente, out qtd);

            DAL.DaoBeneficiario ben = new DAL.DaoBeneficiario();
            for (int i = 0; i < clientes.Count(); i++)
            {
                var Beneficiario = ben.Listar(IdCliente: clientes[i].Id);
                clientes[i].Beneficiarios = Beneficiario;
            }
            return(clientes);
        }
Esempio n. 10
0
 /// <summary>
 /// Inclui ou alterar um novo beneficiario
 /// </summary>
 /// <param name="id_cliente">Id do cliente</param>
 /// <param name="beneficiario">Objeto de beneficiario</param>
 public long IncluirOuAlterar(long id_cliente, DML.Beneficiario beneficiario)
 {
     DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
     if (beneficiario.Id > 0 && this.VerificarExistencia(id_cliente, beneficiario.CPF))
     {
         DML.Beneficiario ben = this.PesquisarPorCPF(id_cliente, beneficiario.CPF);
         if (ben.Id > 0)
         {
             beneficiario.Id = ben.Id;
         }
     }
     return(benef.IncluirOuAlterar(id_cliente, beneficiario));
 }
        /// <summary>
        /// Inclui um novo cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public long Incluir(DML.Cliente cliente)
        {
            DAL.DaoCliente      cli = new DAL.DaoCliente();
            DAL.DaoBeneficiario bnf = new DAL.DaoBeneficiario();
            long id = cli.Incluir(cliente);

            foreach (Beneficiario beneficiario in cliente.Beneficiarios)
            {
                beneficiario.IdCliente = id;
                bnf.Incluir(beneficiario);
            }
            return(id);
        }
Esempio n. 12
0
        public bool VerificarExistencia(string CPF, long idCliente, long idBeneficiario)
        {
            string valor = CPF;

            if (CPF.Length > 11)
            {
                valor = valor.Replace(".", "");
                valor = valor.Replace("-", "");
            }

            DAL.DaoBeneficiario ben = new DAL.DaoBeneficiario();

            return(ben.VerificarExistencia(valor, idCliente, idBeneficiario));
        }
Esempio n. 13
0
        /// <summary>
        /// Inclui um novo cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public long Incluir(DML.Cliente cliente)
        {
            DAL.DaoCliente      cli  = new DAL.DaoCliente();
            DAL.DaoBeneficiario bene = new DAL.DaoBeneficiario();
            long idCliente           = cli.Incluir(cliente);

            foreach (var beneficiario in cliente.ListaBeneficiario)
            {
                beneficiario.Cliente.Id = idCliente;
                bene.Incluir(beneficiario);
            }

            return(idCliente);
        }
Esempio n. 14
0
        /// <summary>
        /// Lista os clientes
        /// </summary>
        public List <DML.Cliente> Listar()
        {
            DAL.DaoCliente cli      = new DAL.DaoCliente();
            var            clientes = cli.Listar();

            // Obtém beneficiários
            DAL.DaoBeneficiario ben = new DAL.DaoBeneficiario();
            for (int i = 0; i < clientes.Count(); i++)
            {
                var Beneficiario = ben.Listar(IdCliente: clientes[i].Id);
                clientes[i].Beneficiarios = Beneficiario;
            }
            return(clientes);
        }
Esempio n. 15
0
        /// <summary>
        /// Inclui um novo cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public long Incluir(DML.Cliente cliente)
        {
            DAL.DaoCliente cli = new DAL.DaoCliente();
            long           Id  = cli.Incluir(cliente);

            // Cadastra beneficiários
            DAL.DaoBeneficiario ben = new DAL.DaoBeneficiario();
            cliente.Beneficiarios.ForEach(beneficiario => {
                beneficiario.IdCliente = Id;
                ben.Incluir(beneficiario);
            });

            return(Id);
        }
        /// <summary>
        /// Altera um cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public void Alterar(DML.Cliente cliente)
        {
            DAL.DaoCliente      cli = new DAL.DaoCliente();
            DAL.DaoBeneficiario bnf = new DAL.DaoBeneficiario();
            cli.Alterar(cliente);

            foreach (Beneficiario beneficiario in cliente.Beneficiarios)
            {
                if (beneficiario.Id == 0)
                {
                    beneficiario.IdCliente = cliente.Id;
                    bnf.Incluir(beneficiario);
                }
                else
                {
                    bnf.Alterar(beneficiario);
                }
            }
        }
Esempio n. 17
0
        /// <summary>
        /// Altera um cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public void Alterar(DML.Cliente cliente)
        {
            DAL.DaoCliente      cli = new DAL.DaoCliente();
            DAL.DaoBeneficiario ben = new DAL.DaoBeneficiario();

            /**
             * TODO: Incluir controle transacional
             */

            // Alterar cliente
            cli.Alterar(cliente);

            // Excluir beneficiários existentes que não estão na lista enviada
            List <DML.Beneficiario> bdBeneficiarios = ben.Listar(cliente.Id);

            if (bdBeneficiarios != null)
            {
                if (cliente.Beneficiarios != null)
                {
                    bdBeneficiarios.RemoveAll(b => cliente.Beneficiarios.Select(bc => bc.Id).ToArray().Contains(b.Id));
                }

                foreach (DML.Beneficiario beneficiario in bdBeneficiarios)
                {
                    ben.Excluir(beneficiario.Id);
                }
            }

            // Incluir/Alterar beneficiários
            foreach (DML.Beneficiario beneficiario in cliente.Beneficiarios)
            {
                if (beneficiario.Id == 0)
                {
                    beneficiario.Id = ben.Incluir(beneficiario);
                }
                else
                {
                    ben.Alterar(beneficiario);
                }
            }
        }
Esempio n. 18
0
        /// <summary>
        /// Inclui um novo cliente
        /// </summary>
        /// <param name="cliente">Objeto de cliente</param>
        public long Incluir(DML.Cliente cliente)
        {
            DAL.DaoCliente      cli = new DAL.DaoCliente();
            DAL.DaoBeneficiario ben = new DAL.DaoBeneficiario();

            /**
             * TODO: Incluir controle transacional
             */

            // Incluir cliente
            cliente.Id = cli.Incluir(cliente);

            // Incluir beneficiários
            if (cliente.Beneficiarios != null)
            {
                foreach (DML.Beneficiario beneficiario in cliente.Beneficiarios)
                {
                    beneficiario.IdCliente = cliente.Id;
                    beneficiario.Id        = ben.Incluir(beneficiario);
                }
            }

            return(cliente.Id);
        }
Esempio n. 19
0
 /// <summary>
 /// Consulta o beneficiario pelo id
 /// </summary>
 /// <param name="id">id do beneficiario</param>
 /// <returns></returns>
 public DML.Beneficiario Consultar(long id)
 {
     DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
     return(benef.Consultar(id));
 }
Esempio n. 20
0
 /// <summary>
 /// Altera um beneficiario
 /// </summary>
 /// <param name="beneficiario">Objeto de beneficiario</param>
 public void Alterar(DML.Beneficiario beneficiario)
 {
     DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
     benef.Alterar(beneficiario);
 }
Esempio n. 21
0
 /// <summary>
 /// Inclui um novo beneficiario
 /// </summary>
 /// <param name="beneficiario">Objeto de beneficiario</param>
 public long Incluir(DML.Beneficiario beneficiario)
 {
     DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
     return(benef.Incluir(beneficiario));
 }
 /// <summary>
 /// VerificaExistencia
 /// </summary>
 /// <param name="CPF"></param>
 /// <returns></returns>
 public bool VerificarExistencia(string CPF, long idCliente)
 {
     DAL.DaoBeneficiario bene = new DAL.DaoBeneficiario();
     return(bene.VerificarExistencia(CPF, idCliente));
 }
 /// <summary>
 /// Lista os beneentes
 /// </summary>
 public List <DML.Beneficiario> Listar()
 {
     DAL.DaoBeneficiario bene = new DAL.DaoBeneficiario();
     return(bene.Listar());
 }
Esempio n. 24
0
        ///// <summary>
        ///// Lista os beneficiarios
        ///// </summary>
        //public List<DML.Beneficiario> Listar()
        //{
        //    DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
        //    return benef.Listar();
        //}

        /// <summary>
        /// Lista os beneficiarios
        /// </summary>
        public List <DML.Beneficiario> Pesquisa(long idCliente, int iniciarEm, int quantidade, string campoOrdenacao, bool crescente, out int qtd)
        {
            DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
            return(benef.Pesquisa(idCliente, iniciarEm, quantidade, campoOrdenacao, crescente, out qtd));
        }
Esempio n. 25
0
 /// <summary>
 /// VerificaExistencia
 /// </summary>
 /// <param name="CPF"></param>
 /// <param name="IdCliente"></param>
 /// <returns></returns>
 public bool VerificarExistencia(string CPF, long IdCliente)
 {
     DAL.DaoBeneficiario cli = new DAL.DaoBeneficiario();
     return(cli.VerificarExistencia(CPF, IdCliente));
 }
Esempio n. 26
0
 /// <summary>
 /// Excluir o beneficiario pelo id
 /// </summary>
 /// <param name="id">id do beneficiario</param>
 /// <returns></returns>
 public void Excluir(long id)
 {
     DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
     benef.Excluir(id);
 }
Esempio n. 27
0
 /// <summary>
 /// Consulta o beneficiario pelo id
 /// </summary>
 /// <param name="id">id do beneficiario</param>
 /// <returns></returns>
 public List <DML.Beneficiario> ConsultarPorCliente(long idcliente)
 {
     DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
     return(benef.ConsultarByIdCliente(idcliente));
 }
Esempio n. 28
0
        /// <summary>
        /// VerificaExistencia
        /// </summary>
        /// <param name="CPF"></param>
        /// <returns></returns>
        public bool VerificarExistencia(string CPF)
        {
            var beneficiario = new DAL.DaoBeneficiario();

            return(beneficiario.VerificarExistencia(CPF));
        }
Esempio n. 29
0
 /// <summary>
 /// VerificaExistencia
 /// </summary>
 /// <param name="cpf"></param>
 /// <returns></returns>
 public bool VerificarExistencia(string cpf, long idCliente, long id)
 {
     DAL.DaoBeneficiario benef = new DAL.DaoBeneficiario();
     return(benef.VerificarExistencia(cpf, idCliente, id));
 }
 /// <summary>
 /// Altera um beneente
 /// </summary>
 /// <param name="beneente">Objeto de beneente</param>
 public void Alterar(DML.Beneficiario beneente)
 {
     DAL.DaoBeneficiario bene = new DAL.DaoBeneficiario();
     bene.Alterar(beneente);
 }