Ejemplo n.º 1
0
        private static ExprBeneficiario GeneraPredicadoBeneficiario(ReglaEntradaBeneficiario regla, out List <MensajeConfiguracionRegla> listaMensajes)
        {
            listaMensajes = new List <MensajeConfiguracionRegla>();

            ExprBeneficiario predicado = ConstructorPredicado.True <Beneficiario>();

            if (regla.IsNull())
            {
                return(predicado);
            }

            if (regla.RelacionDependiente.IsNotNullOrEmpty())
            {
                ExprBeneficiario criterio = beneficiario => regla.RelacionDependiente.Contains(beneficiario.RelacionDependiente, StringComparison.InvariantCultureIgnoreCase);
                predicado = predicado.And(criterio);
            }

            if (regla.Genero.IsNotNullOrEmpty())
            {
                ExprBeneficiario criterio = beneficiario => regla.Genero.Contains(beneficiario.Genero, StringComparison.InvariantCultureIgnoreCase);
                predicado = predicado.And(criterio);
            }

            if (regla.Edad.IsNotNull())
            {
                var nombrePropiedad = "Edad";
                var expresionLogica = new ExpresionLogica(regla.Edad);
                if (!expresionLogica.EsExpresionLogica)
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorExpresionLogica(nombrePropiedad, regla.Edad));
                    return(null);
                }

                expresionLogica.Proposiciones.Select(x => { x.NombrePropiedad = nombrePropiedad; return(x); }).ToList();

                ExprBeneficiario exprAnd = ConstruirArbolExpresionAnd <Beneficiario>(expresionLogica.Proposiciones);
                if (exprAnd.IsNull())
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
                    return(null);
                }
                predicado = predicado.And(exprAnd);
            }

            if (regla.DeducibleCubierto.IsNotNullOrEmpty())
            {
                var nombrePropiedad = "DeducibleCubierto";
                var expresionLogica = new ExpresionLogica(regla.DeducibleCubierto);
                if (!expresionLogica.EsExpresionLogica)
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorExpresionLogica(nombrePropiedad, regla.DeducibleCubierto));
                    return(null);
                }

                expresionLogica.Proposiciones.Select(x => { x.NombrePropiedad = nombrePropiedad; return(x); }).ToList();

                ExprBeneficiario exprAnd = ConstruirArbolExpresionAnd <Beneficiario>(expresionLogica.Proposiciones);
                if (exprAnd.IsNull())
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
                    return(null);
                }
                predicado = predicado.And(exprAnd);
            }

            if (regla.EnCarencia.IsNotNull())
            {
                ExprBeneficiario criterio = beneficiario => beneficiario.EnCarencia == regla.EnCarencia;
                predicado = predicado.And(criterio);
            }

            if (regla.DiasFinCarencia.IsNotNullOrEmpty())
            {
                var nombrePropiedad = "DiasFinCarencia";
                var expresionLogica = new ExpresionLogica(regla.DiasFinCarencia);
                if (!expresionLogica.EsExpresionLogica)
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorExpresionLogica(nombrePropiedad, regla.DiasFinCarencia));
                    return(null);
                }

                expresionLogica.Proposiciones.Select(x => { x.NombrePropiedad = nombrePropiedad; return(x); }).ToList();

                ExprBeneficiario exprAnd = ConstruirArbolExpresionAnd <Beneficiario>(expresionLogica.Proposiciones);
                if (exprAnd.IsNull())
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
                    return(null);
                }
                predicado = predicado.And(exprAnd);
            }

            if (regla.EnCarenciaHospitalaria.IsNotNull())
            {
                ExprBeneficiario criterio = beneficiario => beneficiario.EnCarenciaHospitalaria == regla.EnCarenciaHospitalaria;
                predicado = predicado.And(criterio);
            }

            if (regla.DiasFinCarenciaHospitalaria.IsNotNullOrEmpty())
            {
                var nombrePropiedad = "DiasFinCarenciaHospitalaria";
                var expresionLogica = new ExpresionLogica(regla.DiasFinCarenciaHospitalaria);
                if (!expresionLogica.EsExpresionLogica)
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorExpresionLogica(nombrePropiedad, regla.DiasFinCarenciaHospitalaria));
                    return(null);
                }

                expresionLogica.Proposiciones.Select(x => { x.NombrePropiedad = "DeducibleCubierto"; return(x); }).ToList();

                ExprBeneficiario exprAnd = ConstruirArbolExpresionAnd <Beneficiario>(expresionLogica.Proposiciones);
                if (exprAnd.IsNull())
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
                    return(null);
                }
                predicado = predicado.And(exprAnd);
            }

            if (regla.BeneficioOda.IsNotNull())
            {
                ExprBeneficiario criterio = beneficiario => beneficiario.BeneficioOda == regla.BeneficioOda;
                predicado = predicado.And(criterio);
            }

            if (regla.Maternidad.IsNotNull())
            {
                ExprBeneficiario criterio = beneficiario => beneficiario.Maternidad == regla.Maternidad;
                predicado = predicado.And(criterio);
            }

            if (regla.SuperaDeducible.IsNotNull())
            {
                if (regla.SuperaDeducible.Value)
                {
                    ExprBeneficiario criterio = beneficiario => beneficiario.DeducibleCubierto >= regla.DeducibleTotal;
                    predicado = predicado.And(criterio);
                }
                else
                {
                    ExprBeneficiario criterio = beneficiario => beneficiario.DeducibleCubierto < regla.DeducibleTotal;
                    predicado = predicado.And(criterio);
                }
            }

            return(predicado);
        }
Ejemplo n.º 2
0
        private static ExprContrato GeneraPredicadoContrato(ReglaEntradaContrato regla, out List <MensajeConfiguracionRegla> listaMensajes)
        {
            listaMensajes = new List <MensajeConfiguracionRegla>();

            ExprContrato predicado = ConstructorPredicado.True <Contrato>();

            if (regla.IsNull())
            {
                return(predicado);
            }

            if (regla.Region.IsNotNullOrEmpty())
            {
                ExprContrato criterio = contrato => regla.Region.Contains(contrato.Region, StringComparison.InvariantCultureIgnoreCase);
                predicado = predicado.And(criterio);
            }

            if (regla.Producto.IsNotNullOrEmpty())
            {
                ExprContrato criterio = contrato => regla.Producto.Contains(contrato.Producto, StringComparison.InvariantCultureIgnoreCase);
                predicado = predicado.And(criterio);
            }

            if (regla.CodigoEstado.IsNotNullOrEmpty())
            {
                ExprContrato criterio = contrato => regla.CodigoEstado.Contains(contrato.CodigoEstado);
                predicado = predicado.And(criterio);
            }

            if (regla.CodigoPlan.IsNotNullOrEmpty())
            {
                var nombrePropiedad = "CodigoPlan";

                var filtros = new List <FiltroExpresion>();

                foreach (var codigo in regla.CodigoPlan)
                {
                    var valor = ExpresionRegular.EliminarComodin(codigo);
                    if (valor.IsNullOrEmpty())
                    {
                        continue;
                    }

                    var filtro = new FiltroExpresion
                    {
                        NombrePropiedad = nombrePropiedad,
                        Valor           = valor
                    };
                    if (codigo.StartsWith("*") && codigo.EndsWith("*"))
                    {
                        filtro.Operador = Operador.Contiene;
                    }
                    else if (codigo.StartsWith("*"))
                    {
                        filtro.Operador = Operador.TerminaCon;
                    }
                    else if (codigo.EndsWith("*"))
                    {
                        filtro.Operador = Operador.IniciaCon;
                    }
                    else if (codigo.Trim().IsNotNullOrEmpty())
                    {
                        filtro.Operador = Operador.IgualQue;
                    }
                    filtros.Add(filtro);
                }

                ExprContrato exprOr = ConstruirArbolExpresionOr <Contrato>(filtros);
                if (exprOr.IsNull())
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
                    return(null);
                }
                predicado = predicado.And(exprOr);
            }

            if (regla.Version.IsNotNullOrEmpty())
            {
                ExprContrato criterio = contrato => regla.Version.Contains(contrato.Version);
                predicado = predicado.And(criterio);
            }

            if (regla.CoberturaMaxima.IsNotNullOrEmpty())
            {
                var nombrePropiedad = "CoberturaMaxima";
                var expresionLogica = new ExpresionLogica(regla.CoberturaMaxima);
                if (!expresionLogica.EsExpresionLogica)
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorExpresionLogica(nombrePropiedad, regla.CoberturaMaxima));
                    return(null);
                }

                expresionLogica.Proposiciones.Select(x => { x.NombrePropiedad = nombrePropiedad; return(x); }).ToList();

                ExprContrato exprAnd = ConstruirArbolExpresionAnd <Contrato>(expresionLogica.Proposiciones);
                if (exprAnd.IsNull())
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
                    return(null);
                }
                predicado = predicado.And(exprAnd);
            }

            if (regla.Nivel.IsNotNullOrEmpty())
            {
                ExprContrato criterio = contrato => regla.Nivel.Contains(contrato.Nivel);
                predicado = predicado.And(criterio);
            }

            if (regla.DeducibleTotal.IsNotNullOrEmpty())
            {
                var nombrePropiedad = "DeducibleTotal";
                var expresionLogica = new ExpresionLogica(regla.DeducibleTotal);
                if (!expresionLogica.EsExpresionLogica)
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorExpresionLogica(nombrePropiedad, regla.DeducibleTotal));
                    return(null);
                }

                expresionLogica.Proposiciones.Select(x => { x.NombrePropiedad = nombrePropiedad; return(x); }).ToList();

                ExprContrato exprAnd = ConstruirArbolExpresionAnd <Contrato>(expresionLogica.Proposiciones);
                if (exprAnd.IsNull())
                {
                    listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
                    return(null);
                }
                predicado = predicado.And(exprAnd);
            }

            if (regla.TieneImpedimento.IsNotNull())
            {
                ExprContrato criterio = contrato => contrato.TieneImpedimento == regla.TieneImpedimento;
                predicado = predicado.And(criterio);
            }

            if (regla.EsMoroso.IsNotNull())
            {
                ExprContrato criterio = contrato => contrato.EsMoroso == regla.EsMoroso;
                predicado = predicado.And(criterio);
            }

            if (regla.NumeroEmpresa.IsNotNullOrEmpty())
            {
                ExprContrato criterio = contrato => regla.NumeroEmpresa.Contains(contrato.NumeroEmpresa);
                predicado = predicado.And(criterio);
            }

            if (regla.CodigoSucursal.IsNotNullOrEmpty())
            {
                ExprContrato criterio = contrato => regla.CodigoSucursal.Contains(contrato.CodigoSucursal);
                predicado = predicado.And(criterio);
            }

            if (regla.NumeroLista.IsNotNullOrEmpty())
            {
                ExprContrato criterio = contrato => regla.NumeroLista.Contains(contrato.NumeroLista);
                predicado = predicado.And(criterio);
            }

            if (regla.EsDeducibleAnual.IsNotNull())
            {
                ExprContrato criterio = contrato => contrato.EsDeducibleAnual == regla.EsDeducibleAnual;
                predicado = predicado.And(criterio);
            }

            if (regla.EsVigente.IsNotNull())
            {
                if (regla.EsVigente.Value)
                {
                    ExprContrato criterio = contrato => contrato.FechaVigencia > DateTime.Now.Date;
                    predicado = predicado.And(criterio);
                }
                else
                {
                    ExprContrato criterio = contrato => contrato.FechaVigencia <= DateTime.Now.Date;
                    predicado = predicado.And(criterio);
                }
            }

            return(predicado);
        }