public List <DTO.CuentaActiva> ObtenerCuentasActivasPorFiltro(int[] años, int[] meses, int[] empresas, int[] rubros, int[] grupos, int[] cuentas)
        {
            List <DTO.CuentaActiva> lista = new List <DTO.CuentaActiva>();

            WhereBuilder <Resources.CuentaActiva> donde = new WhereBuilder <Resources.CuentaActiva>();

            if (años.Count() > 0)
            {
                donde.SetAnd(ca => años.Contains(DbFunctions.TruncateTime(ca.CuentaActivaFecha).Value.Year));
            }
            if (meses.Count() > 0)
            {
                donde.SetAnd(ca => meses.Contains(DbFunctions.TruncateTime(ca.CuentaActivaFecha).Value.Month));
            }
            if (empresas.Count() > 0)
            {
                donde.SetAnd(ca => empresas.Contains(ca.Cuenta.Empresa.EmpresaId));
            }
            if (rubros.Count() > 0)
            {
                donde.SetAnd(ca => rubros.Contains(ca.Cuenta.Rubro.RubroId));
            }
            if (grupos.Count() > 0)
            {
                donde.SetAnd(ca => grupos.Contains(ca.Cuenta.Grupo.GrupoId));
            }
            if (cuentas.Count() > 0)
            {
                donde.SetAnd(ca => cuentas.Contains(ca.Cuenta.CuentaId));
            }

            var cuentasActivas = db.CuentaActiva.Where(donde.GetWhere());

            foreach (var ca in cuentasActivas)
            {
                lista.Add(DTOBuilder.CuentaActiva(ca));
            }

            return(lista);
        }
Exemple #2
0
        public List <DTO.CuentaActiva> obtenerCuentasActivas(int mes, int año, int analista = -1, int validador = -1, int certificador = -1)
        {
            List <DTO.CuentaActiva> lista = new List <DTO.CuentaActiva>();

            try
            {
                WhereBuilder <Resources.CuentaActiva> donde = new WhereBuilder <Resources.CuentaActiva>();

                donde.SetWhere(ca =>
                               DbFunctions.TruncateTime(ca.CuentaActivaFecha).Value.Year == año &&
                               DbFunctions.TruncateTime(ca.CuentaActivaFecha).Value.Month == mes
                               );
                if (analista != -1)
                {
                    donde.And(ca => ca.Usuario.UsuarioId == analista);
                }
                if (validador != -1)
                {
                    donde.And(ca => ca.Usuario2.UsuarioId == validador);
                }
                if (certificador != -1)
                {
                    donde.And(ca => ca.Usuario1.UsuarioId == certificador);
                }

                var cuentasActivas = db.CuentaActiva.Where(donde.GetWhere()).OrderBy(ca => ca.CuentaActivaFecha);

                foreach (var cuenta in cuentasActivas)
                {
                    lista.Add(DTOBuilder.CuentaActiva(cuenta));
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine("SAC.Models.EtapasModel (obtenerCuentasActivas): " + ex.Message);
                lista = new List <DTO.CuentaActiva>();
            }
            return(lista);
        }
        public List<DTO.Cuenta> obtenerCuentasNoActivas(int año, int mes, int empresaId, int grupoId, int rubroId)
        {
            List<DTO.Cuenta> lista = new List<DTO.Cuenta>();
            try
            {
                var donde = new WhereBuilder<Cuenta>();

                if (empresaId != -1)
                {
                    donde.SetAnd(c => c.Empresa.EmpresaId == empresaId);
                }
                if (rubroId != -1)
                {
                    donde.SetAnd(c => c.Rubro.RubroId == rubroId);
                }
                if (grupoId != -1)
                {
                    donde.SetAnd(c => c.Grupo.GrupoId == grupoId);
                }

                var cas = from ca in db.CuentaActiva
                          where
                          DbFunctions.TruncateTime(ca.CuentaActivaFecha).Value.Year == año &&
                          DbFunctions.TruncateTime(ca.CuentaActivaFecha).Value.Month == mes
                          select ca.CuentaActivaId;
                var cuentas = db.Cuenta.Where(c => !cas.Contains(c.CuentaId));
                cuentas = cuentas.Where(donde.GetWhere());

                //foreach (var i in cas)
                //{
                //    System.Diagnostics.Debug.WriteLine(">>>>>>" + i);
                //}

                foreach (var cuenta in cuentas)
                {
                    //var c = new DTO.Cuenta();
                    //c.id = cuenta.CuentaId;
                    //c.numero = cuenta.CuentaNumero;
                    //c.nombre = cuenta.CuentaNombre;
                    //c.empresa = new DTO.Empresa();
                    //c.empresa.razonSocial = cuenta.Empresa.EmpresaRazonSocial;
                    //c.empresa.empresaId = cuenta.Empresa.EmpresaId;
                    //c.rubro = new DTO.Rubro();
                    //c.rubro.rubroNombre = cuenta.Rubro.RubroNombre;
                    //c.rubro.rubroId = cuenta.Rubro.RubroId;
                    //c.grupo = new DTO.Grupo();
                    //c.grupo.grupoNombre = cuenta.Grupo.GrupoNombre;
                    //c.grupo.grupoId = cuenta.Grupo.GrupoId;
                    //c.descripcion = cuenta.CuentaDescripcion;
                    //lista.Add(c);
                    lista.Add(DTOBuilder.Cuenta(cuenta));
                }

            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine("SAC.Models.MantenedorModel (obtenerCuentasNoActivas): " + ex.Message);
                lista = new List<DTO.Cuenta>();
            }
            return lista;
        }