Ejemplo n.º 1
0
        /// <summary>
        /// Obtiene las PK de los autores que han participado en un determinado OC
        /// </summary>
        /// <returns></returns>
        public async Task <List <int> > GetPKAutoresByCollateLatin1(string nombre, int oc)
        {
            try
            {
                PersonasRepository persona = new PersonasRepository();
                var clavesPersona          = await persona.GetAllClavesByLikeNombreLatin1(nombre); //obtenemos las claves de las personas

                var resultados = await _db.DbSetAutores.Where(e => clavesPersona.Contains(e.clave) && e.idOC == oc).Select(e => e.ContenidoId).ToListAsync();

                return(resultados);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
Ejemplo n.º 2
0
        public async Task <IHttpActionResult> GetAllIdByLikeFullNameLatin1(String id)
        {
            var likeName = id;

            try
            {
                log.Info(new MDCSet(this.ControllerContext.RouteData));
                var personas = await _repository.GetAllClavesByLikeNombreLatin1(likeName);

                return(Ok(personas));
            }
            catch (Exception e)
            {
                log.Error(new MDCSet(this.ControllerContext.RouteData), e);

                return(InternalServerError(e));
            }
        }
        public async Task <IEnumerable <Object> > GetConsultaCompendio(ProductoGI parametros)
        {
            try
            {
                var fechaActual = DateTime.Now;

                var entities = dbGI.DbSetProductoGI
                               .Where(e => e.EstadoFlujoComite == 18)
                               .Where(e => e.VoBoDuenio == true)
                               .AsNoTracking()
                               .Include(x => x.FactorInnovacion)
                               .Include(x => x.Proyecto);

                if (entities != null)
                {
                    if (!String.IsNullOrEmpty(parametros.JefeProyecto))    //busqueda por jefe de proyecto
                    {
                        PersonasRepository persona = new PersonasRepository();
                        var fkspersonas            = await persona.GetAllClavesByLikeNombreLatin1(parametros.JefeProyecto);

                        entities = entities.Where(e => fkspersonas.Contains(e.Proyecto.NumjefeProyecto)); ////<====== Revisar
                    }
                    if (!String.IsNullOrEmpty(parametros.ProyectoId))                                     //busqueda por numero de proyecto
                    {
                        entities = entities.Where(e => e.ProyectoId == parametros.ProyectoId);
                    }
                    if (!String.IsNullOrEmpty(parametros.UnidadOrganizacionalId))  //busqueda por gerencia
                    {
                        entities = entities.Where(e => e.UnidadOrganizacionalId == parametros.UnidadOrganizacionalId);
                    }
                    if (!String.IsNullOrEmpty(parametros.ClaveFactorInnovacion))  //busqueda por clave de factor de innovacion
                    {
                        var id = Convert.ToInt32(parametros.ClaveFactorInnovacion);
                        entities = entities.Where(e => e.FactorInnovacionId == id);
                    }
                    if (parametros.Periodo != 0)  //busqueda por periodo
                    {
                        var fechaMinComparacion = new DateTime(parametros.Periodo, 1, 1);
                        var fechaMaxComparacion = new DateTime(parametros.Periodo, 12, 31);
                        var fksproductos        = await dbGI.DbSetProductoGISolicitud.Where(e => DbFunctions.TruncateTime(e.FechaRegistro) >= DbFunctions.TruncateTime(fechaMinComparacion) &&
                                                                                            DbFunctions.TruncateTime(e.FechaRegistro) <= DbFunctions.TruncateTime(fechaMaxComparacion))
                                                  .AsNoTracking().Select(x => x.ProductoId).ToListAsync();

                        entities = entities.Where(e => fksproductos.Contains(e.ProductoId));
                    }

                    var datos = entities.Select(x => new {
                        ProductoId       = x.ProductoId,
                        ClavePersona     = x.ClavePersona,
                        FactorInnovacion = x.FactorInnovacion.Descripcion,
                        FechaRegistro    = dbGI.DbSetProductoGISolicitud.Where(ps => ps.ProductoId == x.ProductoId).Select(ps => ps.FechaRegistro).FirstOrDefault(),
                        NombreTecnico    = x.NombreTecnico,
                        ProyectoId       = x.ProyectoId,
                        Proyecto         = x.Proyecto.Nombre,
                        JefeProyecto     = x.Proyecto.NombreJefeProyecto,
                        CveJefeProyecto  = x.Proyecto.NumjefeProyecto,

                        UnidadOrganizacional =
                            (from unidad in dbGI.DbSetUnidadOrganizacional
                             where x.UnidadOrganizacionalId.Equals(unidad.ClaveUnidad) &&
                             unidad.FechaEfectiva == dbGI.DbSetUnidadOrganizacional.Where(
                                 p => p.FechaEfectiva <= fechaActual &&
                                 p.ClaveUnidad == unidad.ClaveUnidad
                                 ).Max(e => e.FechaEfectiva)
                             select unidad.NombreUnidad).FirstOrDefault()
                    })
                                .ToList();

                    return(datos);
                }

                return(entities);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
        public async Task <IEnumerable <Object> > GetConsultaIdeas(IdeaInnovadora parametros)
        {
            try
            {
                var entities = dbGI.DbSetIdeaInnovadora
                               .Include(e => e.EstadoFlujo)
                               .AsNoTracking();

                if (entities != null)
                {
                    /***Seccion [Buscar idea innovadora]**/
                    if (!String.IsNullOrEmpty(parametros.busqueda))//busqueda en general (seccion buscar 'idea innovadora')
                    {
                        entities = entities.Where(e => e.EstadoFlujoId == 10);
                    }
                    /***Seccion [Mis ideas innovadoras]**/
                    if (!String.IsNullOrEmpty(parametros.ClavePersona))//busqueda por los registros de la persona
                    {
                        var fksautores = await dbGI.DbSetAutoresIdea.Where(e => e.ClavePersona == parametros.ClavePersona).AsNoTracking().Select(x => x.IdeaInnovadoraId).ToListAsync();

                        entities = entities.Where(e => fksautores.Contains(e.IdeaInnovadoraId) || e.ClavePersona == parametros.ClavePersona);
                    }

                    /***Criterios de busqueda en general de ambos formularios**/
                    if (!String.IsNullOrEmpty(parametros.NombreIdea))//busqueda por el nombre de la idea innovadora
                    {
                        var fksideas = await GetIdeasLikeNombreLatin1(parametros.NombreIdea);

                        entities = entities.Where(e => fksideas.Contains(e.IdeaInnovadoraId));
                    }
                    if (!String.IsNullOrEmpty(parametros.busquedaFecha))  //busqueda por fechas
                    {
                        entities = entities.Where(e => (DbFunctions.TruncateTime(e.FechaRegistro) >= DbFunctions.TruncateTime(parametros.fechaInicioComparacion) && DbFunctions.TruncateTime(e.FechaRegistro) <= DbFunctions.TruncateTime(parametros.fechaFinalComparacion)));
                    }
                    if (!String.IsNullOrEmpty(parametros.proponenteNombre))  //busqueda por proponentes
                    {
                        PersonasRepository p = new PersonasRepository();
                        var claves           = await p.GetAllClavesByLikeNombreLatin1(parametros.proponenteNombre);

                        var fksproponentes = await dbGI.DbSetAutoresIdea.Where(e => claves.Contains(e.ClavePersona) && e.ContribucionProponenteId == 0).AsNoTracking().Select(x => x.IdeaInnovadoraId).ToListAsync();

                        entities = entities.Where(x => fksproponentes.Contains(x.IdeaInnovadoraId));
                    }
                    if (!String.IsNullOrEmpty(parametros.PalabrasClave))//busqueda por las palabras clave de las ideas innovadoras
                    {
                        var fkspalabras = await GetIdeasByPalabrasClaveLikeNombreLatin1(parametros.PalabrasClave);

                        entities = entities.Where(e => fkspalabras.Contains(e.IdeaInnovadoraId));
                    }

                    var datos = entities.ToList();

                    foreach (var item in datos)
                    {
                        AutoresIdea proponente = await autores.getProponentePrincipalById(item.IdeaInnovadoraId);

                        if (proponente != null)
                        {
                            Personas autor = await _personaRepo.GetByClave(proponente.ClavePersona);

                            item.proponenteNombre         = autor.NombreCompleto;
                            item.ClaveProponentePrincipal = proponente.ClavePersona;
                        }
                        if (item.TipoAcceso == 1)
                        {
                            item.AccesoPublico = true;
                        }
                        else
                        {
                            item.AccesoPublico = false;
                        }
                    }

                    return(datos);
                }

                return(entities);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
Ejemplo n.º 5
0
        public async Task <IEnumerable <Object> > GetConsultaCartera(Propuesta parametros)
        {
            try
            {
                var entities = dbGI.DbSetPropuesta.AsNoTracking().
                               Include(x => x.EstadoFlujo)
                               .Include(x => x.TipoAccesoGI)
                               .Include(x => x.SegmentoMercado)
                               .Include(x => x.Empresa);
                if (entities != null)
                {
                    if (parametros.EstadoFlujoId != 0) //Consulta hecha por el publico en general
                    {
                        entities = entities.Where(e => e.EstadoFlujoId == 10);
                    }
                    if (!String.IsNullOrEmpty(parametros.ClavePersona)) //consulta hecha para obtener las propuestas por cada persona
                    {
                        entities = entities.Where(x => x.ClaveProponentePrincipal == parametros.ClavePersona || x.ClavePersona == parametros.ClavePersona);
                    }
                    if (!String.IsNullOrEmpty(parametros.NombreTecnico)) //busqueda por el nombre tecnico de una propuesta
                    {
                        var fkspropuestas = await GetPropuestasLikeNombreLatin1(parametros.NombreTecnico);

                        entities = entities.Where(e => fkspropuestas.Contains(e.Id));
                    }
                    if (!String.IsNullOrEmpty(parametros.ProductoServicio)) //busqueda por el nombre propuesto del producto o servicio
                    {
                        var fksproductos = await GetPropuestasByNombreProductoServicioLatin1(parametros.ProductoServicio);

                        entities = entities.Where(e => fksproductos.Contains(e.Id));
                    }
                    if (parametros.EmpresaPromotorClave != null)  //busqueda por empresa
                    {
                        entities = entities.Where(e => e.EmpresaPromotorClave == parametros.EmpresaPromotorClave);
                    }
                    if (parametros.SegmentoMercadoId != 0)  //busqueda por el segmento de mercado
                    {
                        entities = entities.Where(e => e.SegmentoMercadoId == parametros.SegmentoMercadoId);
                    }
                    if (!String.IsNullOrEmpty(parametros.NombreProponentePrincipal))  //busqueda por el proponente principal
                    {
                        PersonasRepository persona = new PersonasRepository();
                        var clavesInv = await persona.GetAllClavesByLikeNombreLatin1(parametros.NombreProponentePrincipal);

                        entities = entities.Where(e => clavesInv.Contains(e.ClaveProponentePrincipal));
                    }
                    if (!String.IsNullOrEmpty(parametros.UnidadOrganizacionalId))  //busqueda por la clave de la unidad organizacional
                    {
                        entities = entities.Where(e => e.UnidadOrganizacionalId == parametros.UnidadOrganizacionalId);
                    }
                    if (!String.IsNullOrEmpty(parametros.busquedaFecha))  //busqueda por fecha
                    {
                        entities = entities.Where(e => (DbFunctions.TruncateTime(e.FechaRegistro) >= DbFunctions.TruncateTime(parametros.fechaInicioComparacion) && DbFunctions.TruncateTime(e.FechaRegistro) <= DbFunctions.TruncateTime(parametros.fechaFinalComparacion) && e.FechaRegistro != null));
                    }


                    var datos = entities.Select(x => new
                    {
                        Id                       = x.Id,
                        PropuestaId              = x.PropuestaId,
                        IdeaInnovadoraId         = x.IdeaInnovadoraId,
                        IdeaInnovadoraTitulo     = x.IdeaInnovadora.NombreIdea,
                        PropuestaInterna         = x.PropuestaInterna,
                        NombreTecnico            = x.NombreTecnico,
                        ProductoServicio         = x.ProductoServicio,
                        ClaveProponentePrincipal = x.ClaveProponentePrincipal,
                        Proponente               = dbGI.DbSetPersonas
                                                   .Where(p => p.ClavePersona.Equals(x.ClaveProponentePrincipal))
                                                   .OrderByDescending(p => p.FechaEfectiva)
                                                   .Select(p => String.Concat(p.Nombre, " ", p.ApellidoPaterno, " ", p.ApellidoMaterno)).FirstOrDefault(),
                        EmpresaPromotorClave       = x.EmpresaPromotorClave,
                        EmpresaPromotorNombre      = x.Empresa.NombreEmpresa,
                        UnidadOrganizacionalId     = x.UnidadOrganizacionalId,
                        NombreUnidadOrganizacional = x.NombreUnidadOrganizacional,
                        SegmentoMercadoId          = x.SegmentoMercadoId,
                        SegmentoMercadoNombre      = x.SegmentoMercado.NomSegMerc,
                        FechaRegistro     = x.FechaRegistro,
                        ClavePersona      = x.ClavePersona,
                        FechaValidacion   = x.FechaValidacion,
                        EstadoFlujoId     = x.EstadoFlujoId,
                        EstadoFlujoNombre = x.EstadoFlujo.Descripcion,
                        TipoAcceso        = x.TipoAcceso,
                        TipoAccesoNombre  = x.TipoAccesoGI.Nombre,
                        //PlanNegocioEvolutivoId = (dbGI.DbSetPlanNegocioEvolutivo.Where(w=> w.PropuestaClave==x.Id ).Select(z=> z.PlanNegocioEvolutivoId).FirstOrDefault())
                    })
                                .ToList();

                    return(datos);
                }

                return(entities);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
        public async Task <IEnumerable <SoftwarePersonal> > getData(DataServerSide ss)
        {
            UORepository uo = new UORepository();

            try
            {
                var v = (from a in
                         _db.dbSetSoftwarePersonal
                         .Include(x => x.Proyecto)
                         .Include(x => x.TipoSoftware)
                         .Include(x => x.Autores)
                         .Include(x => x.DerechosAutor)
                         .Where(x => x.EstadoFlujoId == 3)
                         select a);
                ss.recordsTotal = v.Count();



                if (!string.IsNullOrEmpty(ss.ClaveUnidad))
                {
                    //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);
                    //}
                    //else
                    //{
                    //    clavesUnidad = new HashSet<String>();
                    //    clavesUnidad.Add(ss.ClaveUnidad);
                    //}

                    v = v.Where(x => x.GerenciaClave == ss.ClaveUnidad);

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


                if (!String.IsNullOrEmpty(ss.Titulo)) //busqueda por titulo
                {
                    var listaDA = await GetPKTitulo(ss.Titulo);

                    v = v.Where(e => listaDA.Contains(e.SoftwarePersonalId));
                }


                if (!String.IsNullOrEmpty(ss.proyectoId))
                {
                    var listaDA = await GetDALikeProyecto(ss.proyectoId);

                    v = v.Where(e => listaDA.Contains(e.SoftwarePersonalId));
                }

                //if (!String.IsNullOrEmpty(ss.DerechoAutor))
                //{
                //    var listaDA = await GetPKDerechoAutor(ss.DerechoAutor);
                //    v = v.Where(e => listaDA.Contains(e.SoftwarePersonalId));
                //}

                if (ss.DerechosAutorId != null)
                {
                    v = v.Where(x => x.DerechosAutorId == ss.DerechosAutorId);
                }

                if (!String.IsNullOrEmpty(ss.Tipo))
                {
                    v = v.Where(e => e.TipoSoftwareId.ToString().Equals(ss.Tipo));
                }

                if (!String.IsNullOrEmpty(ss.Autor))
                {
                    var listaDA = await GetPKAutor(ss.Autor);

                    v = v.Where(e => listaDA.Contains(e.SoftwarePersonalId));
                }

                if (!String.IsNullOrEmpty(ss.searchValue))
                {
                    PersonasRepository rp = new PersonasRepository();
                    var clavesPer         = await rp.GetAllClavesByLikeNombreLatin1(ss.searchValue);

                    //var autor= await
                    var softwares = await _db.dbSetAutorSoftware.AsNoTracking()
                                    .Where(x => clavesPer.Contains(x.ClaveAutor))
                                    .Select(x => x.SoftwarePersonalId)
                                    .ToListAsync();

                    var listaUnidades = await uo.GetPorNombreUnidad(ss.searchValue);

                    var titulo = await GetPKTitulo(ss.searchValue);

                    var tipoSoftware = await GetPKTipoSoftware(ss.searchValue);

                    var proyecto = await GetProyectos(ss.searchValue);

                    var proyecto2 = await GetProyectos2(ss.searchValue);

                    var listaDA = await GetDerechosAutorByCollate(ss.searchValue);

                    //var listaAutor = await GetProyectos(ss.searchValue);


                    v = v.Where(e => titulo.Contains(e.SoftwarePersonalId) ||
                                listaDA.Contains(e.DerechosAutorId) ||
                                softwares.Contains(e.SoftwarePersonalId) ||
                                listaUnidades.Contains(e.GerenciaClave) ||
                                proyecto.Contains(e.ProyectoId) ||
                                proyecto2.Contains(e.ProyectoId) ||
                                tipoSoftware.Contains(e.TipoSoftwareId)


                                );
                }


                //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();

                if (entities != null && entities.Count > 0)
                {
                    AutorSoftwareRepository aut = new AutorSoftwareRepository(_db);
                    var listaSW       = entities.Select(x => x.SoftwarePersonalId).ToList();
                    var clavesAutores = await aut.GetClavesAutorBySoftwarsIdCollection(listaSW);

                    HashSet <String> clavesEmpleado = new HashSet <string>(clavesAutores);


                    PersonasRepository p = new PersonasRepository();
                    var personas         = await p.GetAllCollectionMAXTodos(clavesEmpleado);

                    List <Personas> pers = personas.ToList();

                    //var unidadesOrgs = (await uo.GetAllCollectionMAX(entities.Where(x => x.Proyecto != null).Select(x => x.Proyecto.UnidadOrganizacionalId).ToList())).ToList();
                    foreach (var e in entities)
                    {
                        foreach (var a in e.Autores)
                        {
                            try
                            {
                                string cad = a.ClaveAutor.Trim();
                                a.ClaveAutor     = a.ClaveAutor.Trim();
                                a.NombreCompleto = pers.Find(x => x.ClavePersona == cad).NombreCompleto;
                            }
                            catch (Exception ex) { }
                        }


                        if (e.GerenciaClave != null)
                        {
                            e.NombreUnidadOrganizacional = await uo.GetNameById(e.GerenciaClave);
                        }
                    }
                }
                return(entities);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
        public async Task <IEnumerable <Object> > getData(DataServerSide ss)
        {
            try
            {
                //Consulta que devuelve un objeto IQueryable , para mas informacion : https://stackoverflow.com/questions/1578778/using-iqueryable-with-linq/1578809#1578809
                var data = (from a in _ctx.BecarioInterno.AsNoTracking().Include(e => e.EstadoFlujo).Include(e => e.BecaInterna).Include(e => e.Institucion)
                            select a);


                if (!String.IsNullOrEmpty(ss.Tipo)) //Filtrado por estado flujo
                {
                    data = data.Where(x => x.EstadoFlujoId == 3);
                }

                ss.recordsTotal = data.Count();

                if (!String.IsNullOrEmpty(ss.Becario)) //busqueda por clave de empleado (becario)
                {
                    data = data.Where(x => x.ClavePersona.Contains(ss.Becario));
                }

                if (!string.IsNullOrEmpty(ss.Institucion))  //busqueda por institucion
                {
                    var id = Convert.ToInt32(ss.Institucion);
                    data = data.Where(x => x.InstitucionID == id);
                }

                if (ss.TipoBeca != 0)  //Tipo de beca interna
                {
                    data = data.Where(x => x.BecaInternaId == ss.TipoBeca);
                }

                if (!String.IsNullOrEmpty(ss.busquedaFecha))  //busqueda por fecha
                {
                    var fechaInicio  = Convert.ToDateTime(ss.NuevaFechaInicio);
                    var fechaTermino = Convert.ToDateTime(ss.NuevaFechaTermino);
                    data = data.Where(x => (DbFunctions.TruncateTime(x.FechaInicioBeca) >= DbFunctions.TruncateTime(fechaInicio) &&
                                            DbFunctions.TruncateTime(x.FechaTerminoBeca) <= DbFunctions.TruncateTime(fechaTermino)));
                }

                //caja
                if (!string.IsNullOrEmpty(ss.searchValue))
                {
                    var beca = await GetPorBecaTipo(ss.searchValue);

                    var institucion = await GetPorInstitucion(ss.searchValue);

                    var estados = await GetPorEstadoRegistroBusquedaColacion(ss.searchValue);

                    PersonasRepository p = new PersonasRepository();
                    var clavesPersonas   = await p.GetAllClavesByLikeNombreLatin1(ss.searchValue);

                    data = data.Where(e => e.FechaInicioBeca.ToString().Contains(ss.searchValue) ||
                                      e.FechaTerminoBeca.ToString().Contains(ss.searchValue) ||
                                      beca.Contains(e.BecaInternaId) ||
                                      institucion.Contains(e.InstitucionID) ||
                                      estados.Contains(e.EstadoFlujoId) ||
                                      e.ClavePersona.Contains(ss.searchValue) ||
                                      clavesPersonas.Contains(e.ClavePersona));
                }

                /**Esta solucion se implenta porque los registros se querian ordenar por el nombre de la persona */
                /**La coleccion de becarios internos no contiene una llave foranea, por lo que desde el inicio no se pueden traer los nombres de las personas */
                /**El objeto IQueryable (la coleccion)  no permite joins entre multiples contextos, por lo que tampoco se puede obtener de manera inicial los nombres*/
                /**La unica manera fue crear multiples objetos que fueran filtrando  la informacion de poco a poco */
                var claves   = data.Select(x => x.ClavePersona).ToList();
                var Personas = await _db.dbSetPersonas.Where(x => claves.Contains(x.ClavePersona)).AsNoTracking().ToListAsync();

                //Primero obtenemos los nombres y los agregamos a la coleccion (nota: a un objeto de tipo Iqueryable no se le pueden agregar mas objetos o propiedades, ya que es de solo lectura hasta el momento)
                var tempCollection = data.ToList();
                foreach (var item in tempCollection)
                {
                    var perso = Personas.Find(x => x.ClavePersona == item.ClavePersona);
                    if (perso != null)
                    {
                        item.NombrePersona = perso.NombreCompleto;
                    }
                }

                //Aplicamos el ordenamiento
                IEnumerable <BecarioInterno> lista = new List <BecarioInterno>();
                //sort
                if (!(string.IsNullOrEmpty(ss.sortColumn) && string.IsNullOrEmpty(ss.sortColumnDir)))
                {
                    lista = tempCollection.OrderBy(ss.sortColumn + " " + ss.sortColumnDir);  //Ordenamiento con dynamic linq
                }
                //Retornamos datos
                ss.recordsFiltered = lista.Count();
                var entities = lista.Skip(ss.skip).Take(ss.pageSize);


                //NOTA: En caso de que las condiciones del ordenamiento cambien descomentar el siguiente codigo, es mas optimo que el de arriba

                // if (!(string.IsNullOrEmpty(ss.sortColumn) && string.IsNullOrEmpty(ss.sortColumnDir)))
                // {
                //     lista = tempCollection.OrderBy(ss.sortColumn + " " + ss.sortColumnDir);

                // }

                // var claves = data.Select(x => x.ClavePersona).ToList();
                // var Personas = await _db.dbSetPersonas.Where(x => claves.Contains(x.ClavePersona)).AsNoTracking().ToListAsync();

                // foreach (var item in entities)
                // {
                //    var perso = Personas.Find(x => x.ClavePersona == item.ClavePersona);
                //    if (perso != null)
                //    {
                //        item.NombrePersona = perso.NombreCompleto;
                //    }
                // }

                // ss.recordsFiltered = data.Count();
                // var entities = data.Skip(ss.skip).Take(ss.pageSize);


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