Exemplo n.º 1
0
        public async Task <FondoPrograma> GetPP(int id)
        {
            try
            {
                var entities = await _db.FondoPrograma.AsNoTracking()
                               .Include("PropuestaPorFondo.Propuestas")
                               .Include("ProyectoPorFondo.Proyecto")
                               .Include(e => e.Empresa)
                               .Include(e => e.FuenteFinanciamiento)
                               .Include(e => e.SitioWebFondoPrograma)
                               .Include("TematicaPorFondoPrograma.Tematica")
                               .AsNoTracking().FirstOrDefaultAsync(e => e.FondoProgramaId == id);

                UORepository       unidad  = new UORepository(_dbGEN);
                PersonasRepository persona = new PersonasRepository(_dbGEN);
                foreach (PropuestaPorFondo objeto in entities.PropuestaPorFondo)
                {
                    objeto.Propuestas.UnidadOrganizacional = await unidad.UnidadActualWithoutStatus(objeto.Propuestas.UnidadOrganizacionalId);

                    objeto.Propuestas.Personas = await persona.GetById(objeto.Propuestas.ClaveEmpPropuesta);
                }

                foreach (ProyectoPorFondo objeto in entities.ProyectoPorFondo)
                {
                    objeto.Proyecto.UnidadOrganizacional = await unidad.UnidadActualWithoutStatus(objeto.Proyecto.UnidadOrganizacionalId);
                }

                return(entities);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
Exemplo n.º 2
0
        public async Task <Competidor> Get(int id)
        {
            try
            {
                var entities = await _dbComp.Competidor
                               .AsNoTracking()
                               .Include(e => e.Empresa)
                               .Include(e => e.SegmentoMercado)
                               .Include(e => e.LineaDesarrolloTecnologico)
                               .Include(e => e.TamanoEmpresa)
                               .Include("AdjuntoPorCompetidor.Adjunto")
                               .Include("ServicioPorCompetidor.Servicio")
                               .Include("ProductoPorCompetidor.Producto")
                               .FirstOrDefaultAsync(e => e.CompetidorId == id);

                UORepository uo = new UORepository(_dbGEN);

                var unidadId = entities.ClaveUnidad;
                entities.UnidadOrganizacional = await uo.UnidadActualWithoutStatus(unidadId);

                return(entities);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
Exemplo n.º 3
0
        //hacer esto reduce el performance de las consultas  (O_O)!!!
        public async Task <Convocatoria> GetFKByIdWithGerencia(int id)
        {
            try
            {
                var entities = await _db.Convocatoria
                               .AsNoTracking()
                               .Include(e => e.SitioWebPorConvocatoria)
                               .Include("ContactoPorConvocatoria.Contacto")
                               //.Include(e => e.PropuestaPorConvocatoria)
                               .Include("PropuestaPorConvocatoria.Propuestas")
                               .Include("ProyectoPorConvocatoria.Proyecto")
                               .Include("AdjuntoPorConvocatoria.Adjunto")
                               .Include("FondoPrograma.FuenteFinanciamiento")
                               .Include("FondoPrograma.Empresa")
                               .Include("FondoPrograma.TematicaPorFondoPrograma.Tematica")

                               .FirstOrDefaultAsync(e => e.ConvocatoriaId == id);

                UORepository uo = new UORepository(_dbGEN);
                foreach (ProyectoPorConvocatoria ppc in entities.ProyectoPorConvocatoria)
                {
                    var unidadId = ppc.Proyecto.UnidadOrganizacionalId;
                    ppc.Proyecto.UnidadOrganizacional = await uo.UnidadActualWithoutStatus(unidadId);
                }

                UORepository       uo2 = new UORepository(_dbGEN);
                PersonasRepository per = new PersonasRepository(_dbGEN);
                foreach (PropuestaPorConvocatoria prpc in entities.PropuestaPorConvocatoria)
                {
                    var unidadId2 = prpc.Propuestas.UnidadOrganizacionalId;
                    prpc.Propuestas.UnidadOrganizacional = await uo2.UnidadActualWithoutStatus(unidadId2);

                    var personaId = prpc.Propuestas.ClaveEmpPropuesta;
                    prpc.Propuestas.Personas = await per.GetById(personaId);
                }

                return(entities);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
Exemplo n.º 4
0
                                                       public async Task <List <ProyectosFF> > GetConvocatoria(int ConvocatoriaId, string ClaveUnidad, List <ProyectosFF> ProyectosFF)
                                                       {
                                                           // List<ProyectosFF> ProyectosFFSelect = new List<ProyectosFF>();

                                                           var ProyectoPC = new List <ProyectoPorConvocatoria>();

                                                           ProyectoPC = await(from ppc in _db.ProyectoPorConvocatoria
                                                                              where ppc.ConvocatoriaId == ConvocatoriaId
                                                                              select ppc)
                                                                        .Include(e => e.Proyecto)
                                                                        .Include(e => e.Convocatoria)
                                                                        .AsNoTracking()
                                                                        .ToListAsync();

                                                           //unidades organizacionales de los proyectos en la convocatoria
                                                           List <String> uos1 = new List <string>(ProyectoPC.Select(x => x.Proyecto.UnidadOrganizacionalId.Trim()));

                                                           //Unidades organizacionales de acuerdo a la UO seleccionada en el formulario
                                                           UORepository uo       = new UORepository(_dbGen);
                                                           var          unidades = await uo.GetByIdWithChildren(ClaveUnidad);

                                                           var unidSel = await uo.UnidadActualWithoutStatus(ClaveUnidad);

                                                           List <String> uos2 = null;

                                                           if (ClaveUnidad == "")
                                                           {
                                                               uos2 = uos1;
                                                           }
                                                           else
                                                           {
                                                               uos2 = new List <string>(unidades.Children.Select(x => x.ClaveUnidad));
                                                               uos2.Add(unidSel.ClaveUnidad.ToString());
                                                           }


                                                           var ProyectoPCSelect = new List <ProyectoPorConvocatoria>();

                                                           foreach (ProyectoPorConvocatoria ppc in ProyectoPC)
                                                           {
                                                               var unidadId = ppc.Proyecto.UnidadOrganizacionalId.Trim();
                                                               var vigencia = "Inactiva";
                                                               if (uos2.Contains(unidadId))
                                                               {
                                                                   ProyectosFF obj = new ProyectosFF();
                                                                   obj.NumProy      = ppc.ProyectoId;
                                                                   obj.NombreProy   = ppc.Proyecto.Nombre;
                                                                   obj.FInicioProy  = ppc.Proyecto.FechaInicio;
                                                                   obj.FTerminoProy = ppc.Proyecto.FechaFin;
                                                                   obj.MontoProy    = ppc.Proyecto.Costo;

                                                                   var unid = await uo.UnidadActualWithoutStatus(unidadId);

                                                                   obj.Claveunidad = unidadId;
                                                                   obj.UnidadProy  = unid.NombreUnidad;

                                                                   obj.FondoProgramaId = ppc.Convocatoria.FondoProgramaId;
                                                                   var fond = await(from nfond in _db.FondoPrograma
                                                                                    where nfond.FondoProgramaId == ppc.Convocatoria.FondoProgramaId
                                                                                    select nfond).FirstOrDefaultAsync();

                                                                   obj.NombreF = fond.NombreFP;
                                                                   obj.FuenteFinanciamientoId = fond.FuenteFinanciamientoId;

                                                                   var fuent = await(from nfue in _db.FuenteFinanciamiento
                                                                                     where nfue.FuenteFinanciamientoId == fond.FuenteFinanciamientoId
                                                                                     select nfue).FirstOrDefaultAsync();

                                                                   obj.NombreFF = fuent.NombreFF;
                                                                   //obj.TipoFuenteFinanciamientoId = fuent.TipoFuenteFinanciamientoId;

                                                                   obj.NombreTipoFF = await(from ntfue in _db.TipoFuenteFinanciamiento
                                                                                            //where ntfue.TipoFuenteFinanciamientoId == fuent.TipoFuenteFinanciamientoId
                                                                                            select ntfue.Nombre).FirstOrDefaultAsync();

                                                                   obj.ConvocatoriaId = ppc.ConvocatoriaId;
                                                                   obj.NombreC        = ppc.Convocatoria.NombreConvocatoria;

                                                                   if (ppc.Convocatoria.FechaTermino > DateTime.Now)
                                                                   {
                                                                       vigencia = "Activa";
                                                                   }

                                                                   obj.VigenciaC = vigencia;
                                                                   ProyectosFF.Add(obj);
                                                               }
                                                           }

                                                           return(ProyectosFF);
                                                       }