/// <summary>
        /// Obtiene lista de propuestas
        /// </summary>
        /// <returns>IEnumerable<Propuestas></returns>
        public async Task <IEnumerable <Propuestas> > GetPropuestas(int anio)
        {
            DateTime     anioconsulta = new DateTime(anio, 1, 1);
            DateTime     fechafin     = anioconsulta.AddYears(1);
            UORepository uo           = new UORepository(_gen);

            List <int?> empresasenproyectos = _gen.dbSetProyectoGEN
                                              .Where(e => e.EmpresaId != null && subprogramas.subprogramas.Contains(e.SubPrograma))
                                              .Select(e => e.EmpresaId).Distinct().Distinct().ToList();

            var propuestas = await _gen.dbSetPropuesta.Include(e => e.Empresa)
                             .Where(e => (e.Fecha > anioconsulta && e.Fecha < fechafin) && empresasenproyectos.Contains(e.EmpresaId))
                             .AsNoTracking().ToListAsync();

            var listaunidadesid = propuestas.Select(e => e.UnidadOrganizacionalId).ToList();
            IEnumerable <UnidadOrganizacional> unidadorganizacional = await uo.GetAllCollectionMAX(listaunidadesid);

            foreach (var propuesta in propuestas)
            {
                if (propuesta.UnidadOrganizacionalId != null)
                {
                    propuesta.UnidadOrganizacional = unidadorganizacional
                                                     .Where(e => e.ClaveUnidad == propuesta.UnidadOrganizacionalId)
                                                     .FirstOrDefault();
                }
            }

            return(propuestas);
        }
        public async Task <IEnumerable <Iniciativas> > GetProspectosIniciativas()
        {
            //DateTime anioconsulta = new DateTime(anio, 1, 1);
            //DateTime fechafin = anioconsulta.AddYears(1);
            UORepository uo = new UORepository(_gen);

            List <int?> empresasenproyectos = _gen.dbSetProyectoGEN
                                              .Where(e => e.EmpresaId != null && subprogramas.subprogramas.Contains(e.SubPrograma))
                                              .Select(e => e.EmpresaId).Distinct().Distinct().ToList();

            var iniciativas = await _gen.dbSetIniciativa
                              .Where(e => !empresasenproyectos.Contains(e.EmpresaId))
                              .AsNoTracking().ToListAsync();

            var listaunidadesid = iniciativas.Select(e => e.UnidadOrganizacionalId).ToList();
            var listaempresaid  = iniciativas.Select(e => e.EmpresaId);
            IEnumerable <UnidadOrganizacional> unidadorganizacional = await uo.GetAllCollectionMAX(listaunidadesid);

            IEnumerable <Empresa> empresas = await new EmpresasRepository(_cr).GetEmpresasByTrue();

            foreach (var iniciativa in iniciativas)
            {
                if (iniciativa.UnidadOrganizacionalId != null)
                {
                    iniciativa.UnidadOrganizacional = unidadorganizacional
                                                      .Where(e => e.ClaveUnidad == iniciativa.UnidadOrganizacionalId)
                                                      .FirstOrDefault();
                }
                if (iniciativa.EmpresaId != null)
                {
                    iniciativa.Empresa = empresas
                                         .Where(e => e.EmpresaId == iniciativa.EmpresaId)
                                         .FirstOrDefault();
                }
            }

            return(iniciativas);
        }
        /// <summary>
        /// Obtiene todos los proyectos con unidad organizacional y empresas respectivas
        /// </summary>
        /// <returns>Object[]</returns>
        public async Task <Object[]> GetTotalProyectos()
        {
            try
            {
                UORepository       uo  = new UORepository(_gen);
                EmpresasRepository emp = new EmpresasRepository(_cr);

                var proyectos = await _gen.dbSetProyectoGEN.Where(e => e.EmpresaId != null && subprogramas.subprogramas.Contains(e.SubPrograma)).AsNoTracking().ToListAsync();

                var      unidadesId = proyectos.Select(e => e.UnidadOrganizacionalId).ToList();
                Object[] lista      = new Object[proyectos.Count];

                IEnumerable <UnidadOrganizacional> unidadOrganizacional = await uo.GetAllCollectionMAX(unidadesId);

                IEnumerable <Empresa> empresas = await emp.GetEmpresas();

                foreach (var item in proyectos)
                {
                    lista[proyectos.IndexOf(item)] = new
                    {
                        cliente    = empresas.Where(e => e.EmpresaId == item.EmpresaId).Select(e => e.NombreEmpresa).FirstOrDefault(),
                        proyectoID = item.ProyectoId,
                        nombre     = item.Nombre,
                        monto      = item.Costo,
                        fInicio    = item.FechaInicio,
                        fFinal     = item.FechaFin,
                        gerencia   = unidadOrganizacional.Where(e => e.ClaveUnidad == item.UnidadOrganizacionalId).Select(e => e.NombreUnidad).FirstOrDefault()
                    };
                }
                return(lista);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
        /// <summary>
        /// Obtiene proyectos vigentes con unidad organizacional y empresa respectivos
        /// </summary>
        /// <returns>IEnumerable<Proyecto></returns>
        public async Task <IEnumerable <Proyecto> > GetProyectosVigentes()
        {
            DateTime           hoy          = DateTime.Now;
            UORepository       uo           = new UORepository(_gen);
            EmpresasRepository empresasrepo = new EmpresasRepository(_cr);

            var proyectos = await _gen.dbSetProyectoGEN
                            .Where(e => e.FechaFin > hoy && subprogramas.subprogramas.Contains(e.SubPrograma))
                            .Include(e => e.UnidadOrganizacionalEmpresas)
                            .AsNoTracking().ToListAsync();

            var listaunidadesid = proyectos.Select(e => e.UnidadOrganizacionalId).ToList();

            var listaempresasid = proyectos
                                  .Where(e => e.EmpresaId != null)
                                  .Select(e => e.EmpresaId).ToList();

            IEnumerable <Empresa> empresas = await empresasrepo.GetEmpresas();

            IEnumerable <UnidadOrganizacional> unidadorganizacional = await uo.GetAllCollectionMAX(listaunidadesid);

            foreach (var proyecto in proyectos)
            {
                if (proyecto.UnidadOrganizacionalId != null)
                {
                    proyecto.UnidadOrganizacional = unidadorganizacional.Where(e => e.ClaveUnidad == proyecto.UnidadOrganizacionalId).FirstOrDefault();
                }
                if (proyecto.EmpresaId != null)
                {
                    proyecto.Empresa = empresas.Where(e => e.EmpresaId == proyecto.EmpresaId).FirstOrDefault();
                }
            }


            return(proyectos.OrderByDescending(e => e.FechaInicio));
        }
        //public async Task<IEnumerable<LAproy>> OtrosMetodos(){ ... }
        public async Task <IEnumerable <InformeTecnicoFinal> > getData(DataServerSide ss, int EstadoITFFlujoId)
        {
            //EstadoITFFlujoId 4 is pubicado
            try
            {
                var v = (from a in
                         _db.dbSetInformeTFs
                         .Include(x => x.Proyecto.Empresa)
                         .Include(x => x.Proyecto.UnidadOrganizacionalEmpresas)
                         .Include(x => x.LActe)
                         .Include(x => x.LAcap)
                         .Include(x => x.LAproy)
                         .Where(x => x.EstadoITFFlujoId >= EstadoITFFlujoId &&
                                (x.LAproyId != null && x.LAproyId > 0))
                         select a);
                ss.recordsTotal = v.Count();
                //search


                List <datosCliente> clientes = new List <datosCliente>();



                foreach (var obj in v)
                {
                    if (obj.Proyecto != null)
                    {
                        if (obj.Proyecto.Empresa != null)
                        {
                            string a = obj.Proyecto.Empresa.NombreEmpresa;


                            if (obj.Proyecto.UnidadOrganizacionalEmpresas != null)
                            {
                                a = a + " " + obj.Proyecto.UnidadOrganizacionalEmpresas.NombreUnidad;
                            }

                            a = a.ToLower();

                            string caduax = "";

                            caduax = a.Replace("á", "a");
                            caduax = caduax.Replace("é", "e");
                            caduax = caduax.Replace("í", "i");
                            caduax = caduax.Replace("ó", "o");
                            caduax = caduax.Replace("ú", "u");
                            caduax = caduax.Replace("\r\n", " ");

                            datosCliente itemCliente = new datosCliente(obj.LAproyId.ToString(), caduax);

                            clientes.Add(itemCliente);
                        }
                    }
                }


                if (!string.IsNullOrEmpty(ss.ClaveUnidad))
                {
                    UORepository uo  = new UORepository();
                    var          uni = await uo.GetByIdWithChildren(ss.ClaveUnidad);

                    HashSet <String> clavesUnidad = null;
                    if (uni.tipoO < 3)
                    {
                        var unidades = uni.Children.Select(x => x.ClaveUnidad).ToList();
                        clavesUnidad = new HashSet <String>(unidades);
                        var x2 = await uo.GetAllCollectionMAX(clavesUnidad);
                    }
                    else
                    {
                        clavesUnidad = new HashSet <String>();
                        clavesUnidad.Add(ss.ClaveUnidad);
                    }

                    v = v.Where(e => clavesUnidad.Contains(e.Proyecto.UnidadOrganizacionalId));
                }
                if (!String.IsNullOrEmpty(ss.searchValue))
                {
                    var listaPalabrasClave = await GetPalabrasClave(ss.searchValue);

                    var proyecto = await GetJefeProyectoProyectoID(ss.searchValue);


                    List <int?> idSeleccionados = new List <int?>();

                    foreach (var elemento in clientes)
                    {
                        string cadenabusqueda = elemento.nombreDato;



                        if (cadenabusqueda.IndexOf(ss.searchValue) > 0)
                        {
                            int valor = int.Parse(elemento.idDato);
                            idSeleccionados.Add(valor);
                        }
                    }

                    v = v.Where(e => listaPalabrasClave.Contains(e.LAproyId) || proyecto.Contains(e.LAproyId) || idSeleccionados.Contains(e.LAproyId));
                }

                if (!String.IsNullOrEmpty(ss.palabras))
                {
                    var pal = ss.palabras.Split(' ');
                    //foreach (var p in pal)
                    //  {

                    var listaPalabrasClave = await GetPalabrasClave(ss.palabras);

                    var listaInsumos = await GetInsumos(ss.palabras);

                    var listaEquipo = await GetEquipo(ss.palabras);

                    var listaGestion = await GetGestion(ss.palabras);

                    var listaCumplimiento = await GetCumplimiento(ss.palabras);


                    v = v.Where(e => listaPalabrasClave.Contains(e.LAproyId) || listaInsumos.Contains(e.LAproyId) || listaEquipo.Contains(e.LAproyId) || listaGestion.Contains(e.LAproyId) || listaCumplimiento.Contains(e.LAproyId));
                    //}
                }
                if (!String.IsNullOrEmpty(ss.proyectoId))
                {
                    v = v.Where(e => e.Proyecto.ProyectoId.Equals(ss.proyectoId));
                }
                if (!String.IsNullOrEmpty(ss.EmpresaId))
                {
                    v = v.Where(e => e.Proyecto.EmpresaId.ToString().Equals(ss.EmpresaId));
                }
                if (!String.IsNullOrEmpty(ss.NumjefeProyecto))
                {
                    v = v.Where(e => e.Proyecto.NumjefeProyecto.Equals(ss.NumjefeProyecto));
                }
                //sort
                if (!(string.IsNullOrEmpty(ss.sortColumn) && string.IsNullOrEmpty(ss.sortColumnDir)))
                {
                    //for make sort simpler we will add Syste.Linq.Dynamic reference
                    v = v.OrderBy(ss.sortColumn + " " + ss.sortColumnDir);
                }

                ss.recordsFiltered = v.Count();
                var entities = await v.Skip(ss.skip).Take(ss.pageSize).AsNoTracking().ToListAsync();

                return(entities);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
        public async Task <IEnumerable <Insumos> > getData(DataServerSide ss)
        {
            try
            {
                int EstadoITFFlujoId = 4;
                var v = (from a in
                         _db.dbSetInsumos
                         .Include(x => x.InformeTecnicoFinal.Proyecto)
                         .Include(x => x.TipoAcceso)
                         .Include(x => x.TipoInsumo)
                         .Where(x => x.InformeTecnicoFinal.EstadoITFFlujoId == EstadoITFFlujoId)
                         select a);
                ss.recordsTotal = v.Count();


                //search
                if (!string.IsNullOrEmpty(ss.ClaveUnidad))
                {
                    UORepository uo  = new UORepository(_dbGen);
                    var          uni = await uo.GetByIdWithChildren(ss.ClaveUnidad);

                    HashSet <String> clavesUnidad = null;
                    if (uni.tipoO < 3)
                    {
                        var unidades = uni.Children.Select(x => x.ClaveUnidad).ToList();
                        clavesUnidad = new HashSet <String>(unidades);
                        var x2 = await uo.GetAllCollectionMAX(clavesUnidad);
                    }
                    else
                    {
                        clavesUnidad = new HashSet <String>();
                        clavesUnidad.Add(ss.ClaveUnidad);
                    }

                    v = v.Where(e => clavesUnidad.Contains(e.InformeTecnicoFinal.Proyecto.UnidadOrganizacionalId));
                }



                //BUSCAR POR
                if (!String.IsNullOrEmpty(ss.palabras))
                {
                    var listaDA0 = await GetPKInsumo(ss.palabras);

                    var listaDA2 = await GetPKInsumoUbicacion(ss.palabras);

                    var listaDA3 = await GetPKInsumoResponsable(ss.palabras);



                    v = v.Where(e =>
                                listaDA0.Contains(e.InsumosId) ||
                                listaDA2.Contains(e.InsumosId) ||
                                listaDA3.Contains(e.InsumosId)
                                );
                }


                if (!String.IsNullOrEmpty(ss.searchValue))
                {
                    var p = ss.searchValue;


                    var listaDA0 = await GetPKInsumo(ss.searchValue);

                    var listaDA2 = await GetPKInsumoUbicacion(ss.searchValue);

                    var listaDA3 = await GetPKInsumoResponsable(ss.searchValue);

                    var tipoInsumo = await GetTipoInsumo(ss.searchValue);



                    v = v.Where(e => listaDA0.Contains(e.InsumosId) ||
                                listaDA3.Contains(e.InsumosId) ||
                                listaDA2.Contains(e.InsumosId)

                                || tipoInsumo.Contains(e.TipoIns)
                                );
                }



                if (!String.IsNullOrEmpty(ss.proyectoId))
                {
                    var listaDA0 = await GetDAProyecto(ss.proyectoId);

                    v = v.Where(e => listaDA0.Contains(e.InformeTecnicoFinalId));
                }


                //TIPO DE INSUMO
                if (!String.IsNullOrEmpty(ss.Tipo))
                {
                    var listaDA0 = await GetTipoInsumoID(ss.Tipo);

                    v = v.Where(e => listaDA0.Contains(e.TipoIns));
                }


                if (!String.IsNullOrEmpty(ss.NumjefeProyecto))
                {
                    var listaDA0 = await GetJefeProyecto(ss.NumjefeProyecto);

                    v = v.Where(e => listaDA0.Contains(e.InformeTecnicoFinalId));
                }
                //sort
                if (!(string.IsNullOrEmpty(ss.sortColumn) && string.IsNullOrEmpty(ss.sortColumnDir)))
                {
                    //for make sort simpler we will add Syste.Linq.Dynamic reference
                    v = v.OrderBy(ss.sortColumn + " " + ss.sortColumnDir);
                }

                ss.recordsFiltered = v.Count();
                var entities = await v.Skip(ss.skip).Take(ss.pageSize).AsNoTracking().ToListAsync();

                return(entities);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }