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