public async Task <IHttpActionResult> GetById(int id, string id2)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
var solicitudes = await _solicitudesRepo.GetByInfo(id, id2);
List <BitacoraSolicitudesGI> Bita = new List <BitacoraSolicitudesGI>();
foreach (var item in solicitudes)
{
var result = await _repository.GetById(item.SolicitudId);
foreach (var item2 in result)
{
Bita.Add(item2);
}
}
foreach (var obj in Bita)
{
var p = await _PersonasRepository.GetByClave(obj.ClavePersona);
obj.NombreCompleto = p.NombreCompleto;
}
return(Ok(Bita));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task Update(BecarioInterno BI)// UpdateSolicitud
{
try
{
var result = await _ctx.BecarioInterno.FirstOrDefaultAsync(e => e.BecarioInternoId == BI.BecarioInternoId);
if (result != null)
{
if (await ValidarDuplicados(BI))
{
throw new ApplicationException("Ya existe un registro con ese nombre. Intente cambiar el tipo de beca o las fecha de inicio o término");
}
if (BI.Adjunto != null)
{
Adjunto key = await new AdjuntoRepository().CreateAd(BI.Adjunto);
BI.AdjuntoId = key.AdjuntoId;
}
_ctx.Entry(result).CurrentValues.SetValues(BI);
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(BI.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object> GetById(int id)
{
try
{
var entities = await _db.DbSetMiembros
.Include(e => e.RolesCP)
.Include(e => e.Comunidad)
.AsNoTracking()
.FirstOrDefaultAsync(e => e.MiembroId == id);
PersonasRepository personas = new PersonasRepository();
Object resultado = new Object();
var datosPersona = await personas.GetByClave(entities.idPersonas);
resultado = new { nombre = datosPersona.NombreCompleto
, roles = new { rolId = entities.RolesCP.RolId, nombre = entities.RolesCP.Nombre }
, comunidades = new { nombreComunidad = entities.Comunidad.Descripcion, categoria = entities.Comunidad.CategoriaCP }
, entities.idCP
, entities.idPersonas
, entities.MiembroId
, entities.FechaAlta
, entities.FechaBaja
, entities.Aceptacion
, entities.FechaAceptacion };
return(resultado);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateSolicitud(FormacionAcademica formacionAcademica)
{
try
{
var _fa = await _ctx.FormacionAcademica.FirstOrDefaultAsync(e => e.FormacionAcademicaId == formacionAcademica.FormacionAcademicaId);
if (_fa != null)
{
//_fa.EstadoFlujoId = formacionAcademica.EstadoFlujoId;
//_fa.GradoAcademicoId = formacionAcademica.GradoAcademicoId;
//_fa.CarreraId = formacionAcademica.CarreraId;
//_fa.Especialidad = formacionAcademica.Especialidad;
//_fa.Cedula = formacionAcademica.Cedula;
//_fa.InstitucionID = formacionAcademica.InstitucionID;
//_fa.PaisID = formacionAcademica.PaisID;
//_fa.FechaInicio = formacionAcademica.FechaInicio;
//_fa.FechaTermino = formacionAcademica.FechaTermino;
//_fa.IdArchivo = formacionAcademica.IdArchivo;
//_fa.EstaTitulado = formacionAcademica.EstaTitulado;
//_fa.FechaValidacion = formacionAcademica.FechaValidacion;
_ctx.Entry(_fa).CurrentValues.SetValues(formacionAcademica);
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(formacionAcademica.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <BecarioInterno> GetById(int id)
{
try
{
var result = await _ctx.BecarioInterno.Where(e => e.BecarioInternoId == id)
.Include(e => e.EstadoFlujo)
.Include(e => e.BecaInterna)
.Include(e => e.Carrera)
.Include(e => e.Institucion)
.Include(e => e.Institucion.Pais)
.Include(e => e.Pais)
.Include(e => e.Adjunto)
.AsNoTracking()
.FirstOrDefaultAsync();
if (result.ClavePersona != null)
{
PersonasRepository personarepo = new PersonasRepository();
var persona = await personarepo.GetByClave(result.ClavePersona);
result.Persona = persona;
}
return(result);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object> GetByComunidad(int id)
{
try
{
var entities = await _db.DbSetMiembros
.Where(e => e.idCP == id && e.estado == true)
.Include(e => e.RolesCP)
.AsNoTracking()
.ToListAsync();
PersonasRepository personas = new PersonasRepository();
foreach (var item in entities)
{
var datosPersona = await personas.GetByClave(item.idPersonas);
item.correo = datosPersona.Correo;
}
return(entities);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object[]> GetAll()
{
try
{
var entities = await _db.DbSetMiembros
.Where(e => e.estado == true)
.Include(e => e.RolesCP)
.Include(e => e.Comunidad)
.AsNoTracking().ToListAsync();
PersonasRepository personas = new PersonasRepository();
Object [] lista = new Object[entities.Count];
foreach (var obj in entities)
{
var datosPersona = await personas.GetByClave(obj.idPersonas);
lista[entities.IndexOf(obj)] = new { nombre = datosPersona.NombreCompleto
, roles = new { rolId = obj.RolesCP.RolId, nombre = obj.RolesCP.Nombre }
, comunidades = new { nombreComunidad = obj.Comunidad.Descripcion, categoria = obj.Comunidad.CategoriaCP }
, obj.idCP
, obj.idPersonas
, obj.MiembroId
, obj.FechaAlta
, obj.FechaBaja
, obj.Aceptacion
, obj.FechaAceptacion };
}
return(lista);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateSolicitud(Idiomas idioma)
{
try
{
var _idioma = await _ctx.Idiomas.FirstOrDefaultAsync(e => e.IdiomasId == idioma.IdiomasId);
if (_idioma != null)
{
_idioma.FechaValidacion = idioma.FechaValidacion;
_idioma.EstadoFlujoId = idioma.EstadoFlujoId;
_idioma.IdiomaId = idioma.IdiomaId;
_idioma.PorcentajeGradoDominio = idioma.PorcentajeGradoDominio;
_idioma.PorcentajeConversacion = idioma.PorcentajeConversacion;
_idioma.PorcentajeEscritura = idioma.PorcentajeEscritura;
_idioma.PorcentajeLectura = idioma.PorcentajeLectura;
_idioma.FechaAcreditacion = idioma.FechaAcreditacion;
_idioma.Puntuacion = idioma.Puntuacion;
_idioma.CertificacionId = idioma.CertificacionId;
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(idioma.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
[HttpGet] public async Task <IHttpActionResult> GetAll()
{
try {
var result = await _Repository.GetAll();
foreach (var soli in result)
{
var p = await _PersonasRepository.GetByClave(soli.ClavePersona);
soli.NombrePersona = p.NombreCompleto;
}
return(Ok(result));
}
catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e)); }
}
public async Task <Object> EnviaNotificaciones(Correo correo)
{
try
{
string correosMiembros = "";
string mensaje = "";
var entities = await _db.DbSetMiembros
.Where(e => e.idCP == correo.id)
.Include(e => e.RolesCP)
.AsNoTracking()
.ToListAsync();
AgendaCPRepository agendaCP = new AgendaCPRepository();
PersonasRepository personas = new PersonasRepository();
foreach (var item in entities)
{
var datosPersona = await personas.GetByClave(item.idPersonas);
correosMiembros = correosMiembros + datosPersona.Correo + ",";
}
getCorreoConfig conf = new getCorreoConfig();
SendCorreo send = new SendCorreo();
if (await send.SendMails(correo, correosMiembros, conf))
{
mensaje = "enviado";
Agenda ag = new Agenda();
ag = correo.agenda;
ag.NotificacionEnviada = true;
await agendaCP.Update(ag);
}
else
{
mensaje = "falla";
}
return(mensaje);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object[]> GetByInvitadoComunidad(int id)
{
try
{
PersonasRepository personas = new PersonasRepository();
var entities = await _db.DbSetDocumentos
.Where(e => e.idComunidadCP == id && e.TipoAcceso == true)
.Include(e => e.Miembros)
.Include(e => e.TipoDocumento)
.Include(e => e.Adjunto)
.AsNoTracking().ToListAsync();
Object[] lista = new Object[entities.Count];
foreach (var item in entities)
{
item.nombrePersona = "";
if (item.idMiembroCP == null)
{
var datosPersona = await personas.GetByClave(item.idPersona);
//item.nombrePersona = datosPersona.NombreCompleto;
item.nombrePersona = item.idPersona + " " + datosPersona.NombreCompleto;
}
else
{
//item.nombrePersona = item.Miembros.nombrePersona;
item.nombrePersona = item.Miembros.idPersonas + " " + item.Miembros.nombrePersona;
}
lista[entities.IndexOf(item)] = new { item.nombrePersona
, item.TipoDocumento.Nombre
, item.Adjunto
, item.idMiembroCP
, item.TipoAcceso
, item.FechaRegistro
, item.DocumentoId
, item.Estado
, item.nombreDocumento
, item.idAdjunto };
}
return(lista);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IEnumerable <IdeaInnovadora> > getAllAceptadas()
{
try
{
var entities = await dbGI.DbSetIdeaInnovadora
.Where(e => e.EstadoFlujoId == 10)
.Include(e => e.EstadoFlujo)
.AsNoTracking().ToListAsync();
foreach (var item in entities)
{
AutoresIdea proponente = await autores.getProponentePrincipalById(item.IdeaInnovadoraId);
if (proponente != null)
{
Personas autor = await _personaRepo.GetByClave(proponente.ClavePersona);
item.proponenteNombre = autor.NombreCompleto;
}
if (item.TipoAcceso == 1)
{
item.AccesoPublico = true;
}
else
{
item.AccesoPublico = false;
}
}
return(entities);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> GetByClave(string Id)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData), new InfoException(Id));
var persona = await _repository.GetByClave(Id);
return(Ok(persona));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
/// <summary>
/// Asocia el registro de un becario con un investigador
/// </summary>
/// <returns></returns>
public async Task ActualizaRegistroBecaEmpleado(int id, string clave)
{
try
{
var _model = await _dbch.BecarioExternoINEEL
.FirstOrDefaultAsync(e => e.BecarioId == id);
if (_model != null)
{
var notificacion = await _dbgen.dbSetNuevoOC.Where(e => e.OcsId.Equals("BecarioExterno") && e.IdExterno == _model.BecarioId + "").AsNoTracking().FirstOrDefaultAsync();;
if (clave == "null") //La clave sera nula cuando el registro sea desasociado al empleado
{
clave = null;
}
if (notificacion == null)
{
NuevoOCRepository repo = new NuevoOCRepository();
await repo.Create("CH", "BecarioExterno", _model.NombreBecario, "indexCH.html#/InformeBecarioDetails/" + _model.BecarioId, Convert.ToString(_model.BecarioId));
}
if (notificacion != null && clave == null)
{
NuevoOCRepository repo = new NuevoOCRepository();
await repo.Delete(notificacion.NuevoOCId);
}
_model.ClavePersona = clave;
await _dbch.SaveChangesAsync();
}
else
{
throw new ApplicationException("Error al asociar el registro con el empleado");
}
if (clave != null)
{
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(clave);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object[]> GetByComunidad(Post model)
{
try
{
var entities = await _db.DbSetPost
.Where(e => e.idComunidad == model.idComunidad)
.Include(e => e.Miembros)
.OrderByDescending(e => e.FechaRegistro)
.AsNoTracking()
.ToListAsync();
Object [] lista = new Object[entities.Count];
ComentariosRepository c = new ComentariosRepository();
PersonasRepository personas = new PersonasRepository();
foreach (var obj in entities)
{
if (obj.idMiembroCP == null)
{
Miembros m = new Miembros();
obj.Miembros = m;
var datosPersona = await personas.GetByClave(obj.idPersona);
obj.Miembros.nombrePersona = datosPersona.NombreCompleto;
obj.Miembros.idPersonas = datosPersona.ClavePersona;
}
lista[entities.IndexOf(obj)] = new { obj.PostId
, obj.Tema
, obj.Descripcion
, obj.publico
, obj.accesoGeneral
, obj.FechaRegistro
, miembro = new { obj.Miembros.nombrePersona, obj.Miembros.idPersonas }
, obj.adjuntoId
, comentarios = await c.GetByPost(obj.PostId) };
}
return(lista);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <EvaluadoresIdea> GetComentarios(int id)
{
try
{
var entities = await dbGI.DbSetEvaluadoresIdea.AsNoTracking()
.Where(x => x.IdeaInnovadoraId == id)
.Where(x => x.Comentarios != null).FirstOrDefaultAsync();
if (entities != null)
{
PersonasRepository p = new PersonasRepository();
var evaluador = await p.GetByClave(entities.ClavePersona);
entities.nombrePersona = evaluador.NombreCompleto;
}
return(entities);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateSolicitud(Asociaciones Asociaciones)
{
try
{
var _Asociaciones = await _ctx.Asociaciones.FirstOrDefaultAsync(e => e.AsociacionesId == Asociaciones.AsociacionesId);
if (_Asociaciones != null)
{
_ctx.Entry(_Asociaciones).CurrentValues.SetValues(Asociaciones);
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(Asociaciones.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <UnidadOrganizacional> UnidadByFecha(DateTime fechaReferencia, String idUnidad)
{
try
{
var unidad = await _db.dbSetUnidadOrganizacional.AsNoTracking()
.Where(x => x.ClaveUnidad == idUnidad && x.FechaEfectiva == _db.dbSetUnidadOrganizacional.Where(
p => p.FechaEfectiva <= fechaReferencia &&
p.ClaveUnidad == x.ClaveUnidad
).Max(e => e.FechaEfectiva))
.FirstOrDefaultAsync();
if (unidad != null)
{
var persona = new PersonasRepository(_db);
unidad.Responsable = await persona.GetByClave(unidad.ClaveResponsable);
}
return(unidad);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> GetBySolicitudAccesoId(int id)
{
try{ log.Info(new MDCSet(this.ControllerContext.RouteData), new InfoException(id));
var Bita = await _repository.GetBySolicitudAccesoId(id);
var _PersonasRepository = new PersonasRepository();
foreach (var obj in Bita)
{
var p = await _PersonasRepository.GetByClave(obj.ClavePersona);
obj.NombreCompleto = p.NombreCompleto;
}
return(Ok(Bita)); }
catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e)); }
}
public async Task Update(TesisDirigida TD)// UpdateSolicitud
{
try
{
if (TD.EstadoFlujoId == 1 && TD.BecarioDirigidoId != null)
{
var becario = await _ctx.BecarioDirigido.FirstOrDefaultAsync(e => e.BecarioDirigidoId == TD.BecarioDirigidoId);
if (becario != null)
{
becario.EstadoFlujoId = 2;
await _ctx.SaveChangesAsync();
}
}
if (TD.EstadoFlujoId == 3 && TD.BecarioDirigidoId != null)
{
var becario = await _ctx.BecarioDirigido.FirstOrDefaultAsync(e => e.BecarioDirigidoId == TD.BecarioDirigidoId);
if (becario != null)
{
becario.EstadoFlujoId = 3;
becario.AdjuntoId = TD.AdjuntoId;
becario.NombreBecario = TD.Autor;
becario.TesisDirigidaId = TD.TesisDirigidaId;
becario.ClavePersona = TD.ClavePersona;
becario.FechaInicio = TD.FechaInicio;
becario.FechaTermino = TD.FechaTermino;
//becario.FechaTermino = TD.FechaTermino;
becario.TipoBecaId = TD.GradoAcademicoId;
becario.NombreEstancia = TD.Titulo;
becario.FechaValidacion = TD.FechaValidacion;
await _ctx.SaveChangesAsync();
}
}
////Agregar a OC
if (TD.EstadoFlujoId == 3)
{
await new NuevoOCRepository().Create(
new NuevoOC("CH",
"TesisDirigida",
TD.Titulo,
"IndexCH.html#/detallestesisdirigida/" + TD.TesisDirigidaId + "/",
TD.TesisDirigidaId + ""
));
}
/////////////////
var result = await _ctx.TesisDirigida.FirstOrDefaultAsync(e => e.TesisDirigidaId == TD.TesisDirigidaId);
if (TD.EstadoFlujoId == 1 && result.EstadoFlujoId == 3)
{
await new NuevoOCRepository().DeleteId("TesisDirigida", TD.TesisDirigidaId + "");
}
if (result != null)
{
if (TD.Adjunto != null)
{
//Eliminar archivo
AdjuntoRepository adjuntoRepo = new AdjuntoRepository();
if (TD.Adjunto.nombre == "eliminar")
{
int id = Convert.ToInt32(TD.Adjunto.AdjuntoId);
result.AdjuntoId = null;
await _ctx.SaveChangesAsync();
await adjuntoRepo.Delete(id);
}
///Agregar archivo al editar
if (TD.Adjunto.AdjuntoId == 0)
{
if (result.AdjuntoId != null)
{
var id = result.AdjuntoId;
result.AdjuntoId = null;
await _ctx.SaveChangesAsync();
await adjuntoRepo.Delete(id);
}
Adjunto key = await adjuntoRepo.CreateAd(TD.Adjunto);
TD.AdjuntoId = key.AdjuntoId;
TD.Adjunto.AdjuntoId = key.AdjuntoId;
}
}
_ctx.Entry(result).CurrentValues.SetValues(TD);
await _ctx.SaveChangesAsync();
}
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(TD.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
/// <summary>
/// Se requiere EmpleadoId, JefeHiperonimo </summary>
public async Task <Boolean> isJefeHiperonimo(Jerarquia model)
{
try
{
if (model == null || String.IsNullOrEmpty(model.EmpleadoId) || String.IsNullOrEmpty(model.JefeHiperonimo))
{
return(false);
}
if (model.EmpleadoId.Equals(model.JefeHiperonimo))
{
return(true);
}
Personas empleado = await dbP.GetByClave(model.EmpleadoId);
if (empleado == null)
{
return(false);
}
var idUnidad = empleado.ClaveUnidad;
var unidad = await dbP.GetUnidadOrgByClaveWithoutStatus(idUnidad);
if (unidad == null)
{
return(false);
}
var responsable = await dbP.GetResponsableByClaveUnidadWithoutStatus(unidad);
if (responsable == null)
{
return(false);
}
if (responsable.ClavePersona == model.JefeHiperonimo)
{
return(true);
}
if (String.IsNullOrEmpty(unidad.padre))
{
return(false);
}
//unidad padre: --------------------------------------
var unidadPadre = await dbP.GetUnidadOrgByClaveWithoutStatus(unidad.padre);
if (unidadPadre == null)
{
return(false);
}
var responsablePadre = await dbP.GetResponsableByClaveUnidadWithoutStatus(unidadPadre);
if (responsablePadre == null)
{
return(false);
}
if (responsablePadre.ClavePersona == model.JefeHiperonimo)
{
return(true);
}
if (String.IsNullOrEmpty(unidadPadre.padre))
{
return(false);
}
return(await isJefeHiperonimo(new Jerarquia(responsablePadre.ClavePersona, model.JefeHiperonimo, null)));
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> GetByColaboracionRequisicion(int id)
{
try{ log.Info(new MDCSet(this.ControllerContext.RouteData), new InfoException(id));
var result = await _repository.GetByColaboracion(id);
foreach (var soli in result)
{
var p = await _PersonasRepository.GetByClave(soli.ClavePersona);
soli.NombreCompleto = p.NombreCompleto;
}
return(Ok(result)); }
catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e)); }
}
public async Task UpdateSolicitud(SNI sni)
{
try
{
var _sni = await _ctx.SNI.FirstOrDefaultAsync(e => e.SNIId == sni.SNIId);
if (_sni != null)
{
_sni.fechaValidacion = sni.fechaValidacion;
_sni.EstadoFlujoId = sni.EstadoFlujoId;
_sni.fechaIngreso = sni.fechaIngreso;
_sni.numeroCVU = sni.numeroCVU;
_sni.fechaInicioNombramiento = sni.fechaInicioNombramiento;
_sni.fechaTerminoNombramiento = sni.fechaTerminoNombramiento;
_sni.NivelSNIId = sni.NivelSNIId;
_sni.AreaSNIId = sni.AreaSNIId;
_sni.numeroExpediente = sni.numeroExpediente;
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(sni.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(CapacitacionYcertificacion Obj)// UpdateSolicitud
{
try
{
var result = await _ctx.dbSetCapacitacionYcertificacion.FirstOrDefaultAsync(e => e.CapacitacionYcertificacionId == Obj.CapacitacionYcertificacionId);
if (result != null)
{
if (Obj.Adjunto != null)
{
AdjuntoRepository _adjuntoRepo = new AdjuntoRepository();
//Elimar archivo
if (Obj.Adjunto.nombre == "eliminar")
{
int id = Convert.ToInt32(Obj.AdjuntoId);
result.AdjuntoId = null;
Obj.AdjuntoId = null;
await _ctx.SaveChangesAsync();
await _adjuntoRepo.Delete(id);
}
///Agregar archivo al editar
if (Obj.Adjunto.AdjuntoId == 0)
{
if (result.AdjuntoId != null)
{
var id = result.AdjuntoId;
result.AdjuntoId = null;
await _ctx.SaveChangesAsync();
await _adjuntoRepo.Delete(id);
}
Adjunto key = await _adjuntoRepo.CreateAd(Obj.Adjunto);
Obj.AdjuntoId = key.AdjuntoId;
}
}
_ctx.Entry(result).CurrentValues.SetValues(Obj);
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(Obj.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> GetAllAceptadas(int id, string clave)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
//0)AdminCH 1
//1)Gerente 4
//2)Admin CP 19
var claveUnidad = clave;
List <Solicitud> ListaSol = new List <Solicitud>();
if (id == 0) //ADMINISTRADORES
{
if (claveUnidad != null) //La clave se utiliza para saber que tipo de administrador hizo la solicitud
{
var resultadosBitacoras = await _bita.GetByRol(1);
var Solicitudes = await _SolicitudRepository.getbyId(resultadosBitacoras, claveUnidad); //Clave de unidad funge como el rol del tipo de administrador
ListaSol.AddRange(Solicitudes);
}
else
{
var resultadosBitacoras = await _bita.GetByRol(1);
var Solicitudes = await _SolicitudRepository.getbyId(resultadosBitacoras);
ListaSol.AddRange(Solicitudes);
}
foreach (var soli in ListaSol)
{
var p = await _PersonasRepository.GetByClave(soli.ClavePersona);
soli.NombreCompleto = p.NombreCompleto;
}
}
if (id == 1) //GERENTES
{
var resultadosBitacoras = await _bita.GetByRolGerente(4);
var Solicitudes = await _SolicitudRepository.getbyIdUnidad(resultadosBitacoras, claveUnidad);
ListaSol.AddRange(Solicitudes);
foreach (var soli in ListaSol)
{
var p = await _PersonasRepository.GetByClave(soli.ClavePersona);
soli.NombreCompleto = p.NombreCompleto;
}
}
if (id == 2) ////ADMINISTRADOR CENTRO POSGRADO
{
var resultadosBitacoras = await _bita.GetByRol(19);
var Solicitudes = await _SolicitudRepository.getbyId(resultadosBitacoras);
ListaSol.AddRange(Solicitudes);
foreach (var soli in ListaSol)
{
var p = await _PersonasRepository.GetByClave(soli.ClavePersona);
soli.NombreCompleto = p.NombreCompleto;
}
}
return(Ok(ListaSol));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task Update(Publicacion Obj)// UpdateSolicitud
{
try
{
var result = await _ctx.Publicacion.FirstOrDefaultAsync(e => e.PublicacionId == Obj.PublicacionId);
// if(await ValidarDuplicados(Obj))
// {
// throw new ApplicationException("Intente cambiar la revista asociada, la fecha de publicación o el número de páginas");
// }
if (Obj.EstadoFlujoId == 1 && result.EstadoFlujoId == 3)
{
await new NuevoOCRepository().DeleteId("ArtículoCH", result.PublicacionId + "");
}
if (result != null)
{
if (Obj.Adjunto != null)
{
AdjuntoRepository _adjuntoRepo = new AdjuntoRepository();
if (Obj.Adjunto.nombre == "eliminar")
{
int id = Convert.ToInt32(Obj.Adjunto.AdjuntoId);
Obj.AdjuntoId = null;
_ctx.Entry(result).CurrentValues.SetValues(Obj);
await _ctx.SaveChangesAsync();
await _adjuntoRepo.Delete(id);
}
///Agregar archivo al editar
if (Obj.Adjunto.AdjuntoId == 0)
{
if (result.AdjuntoId != null)
{
var id = result.AdjuntoId;
Obj.AdjuntoId = null;
_ctx.Entry(result).CurrentValues.SetValues(Obj);
await _ctx.SaveChangesAsync();
await _adjuntoRepo.Delete(id);
}
Adjunto key = await _adjuntoRepo.CreateAd(Obj.Adjunto);
Obj.AdjuntoId = key.AdjuntoId;
}
}
_ctx.Entry(result).CurrentValues.SetValues(Obj);
await _ctx.SaveChangesAsync();
}
//if (Obj.EstadoFlujoId == 3)
//{
// await new NuevoOCRepository().Create(
// new NuevoOC("MT",
// "ARTÍCULO",
// Obj.TituloPublicacion,
// "indexMT.html#/PublicacionDetails/" + Obj.PublicacionId
// ));
//}
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(Obj.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object> competencias(string noEmpleado)
{
PersonasRepository ObjetoPersona = new PersonasRepository();
Personas persona = await ObjetoPersona.GetByClave(noEmpleado);
int datosConductuales = 0;
int datostecnicas = 0;
try
{
var resultado = new Object();
if (persona.TipoPersonalId.Equals("SIN") || persona.TipoPersonalId.Equals("ADM"))
{
var entities = await _db.listadoEmpleadosSind.AsNoTracking().FirstOrDefaultAsync(e => e.NoEmpleado == noEmpleado);
if (entities != null)
{
EvaluacionEmpleadoSindRepository repEvaluacionSindicalizados = new EvaluacionEmpleadoSindRepository();
EvaluacionEmpleadosSind evaluacion = await repEvaluacionSindicalizados.Get(entities.ListaId);
RegistroEvaluacionSindRepository repRegistroEvaluacion = new RegistroEvaluacionSindRepository();
ResultadoEvaluacionSindicalizado resultadoEvaluacion = new ResultadoEvaluacionSindicalizado();
resultadoEvaluacion.idEmpleado = entities;
resultadoEvaluacion.RegistroEvaluacion = evaluacion;
resultadoEvaluacion.Competencias = await repRegistroEvaluacion.CompetenciasEvaluadas(evaluacion.EvaluacionId);
EvaluacionEmpleadosCompetenciasConductuales evaluacionConductualDoble = new EvaluacionEmpleadosCompetenciasConductuales();
EvaluacionConductualesRepository evaluacionRepository = new EvaluacionConductualesRepository();
DetalleEvaluacionConductualesRepository detalleRepository = new DetalleEvaluacionConductualesRepository();
evaluacionConductualDoble = await evaluacionRepository.GetTopByPersona(noEmpleado);
if (evaluacionConductualDoble != null)
{
var detalleEvaluacion = await detalleRepository.GetByClaveEvaluacionResultado(evaluacionConductualDoble.claveEvaluacion);
if (detalleEvaluacion != null)
{
var conductual = new { datosEvaluado = evaluacionConductualDoble, competencias = detalleEvaluacion };
resultado = new { TipoPersonalId = persona.TipoPersonalId, info = resultadoEvaluacion, conductuales = conductual, incluyeConductuales = 2, incluyeSindicalizados = 1, incluyeTecnicas = 0 };
}
else
{
resultado = new { TipoPersonalId = persona.TipoPersonalId, info = resultadoEvaluacion, incluyeConductuales = 0, incluyeSindicalizados = 1, incluyeTecnicas = 0 };
}
}
else
{
resultado = new { TipoPersonalId = persona.TipoPersonalId, info = resultadoEvaluacion, incluyeConductuales = 0, incluyeSindicalizados = 1, incluyeTecnicas = 0 };
}
}
else
{
EvaluacionEmpleadosCompetenciasConductuales evaluacionConductual = new EvaluacionEmpleadosCompetenciasConductuales();
EvaluacionConductualesRepository evaluacionRepository = new EvaluacionConductualesRepository();
DetalleEvaluacionConductualesRepository detalleRepository = new DetalleEvaluacionConductualesRepository();
var conductual = new object();
evaluacionConductual = await evaluacionRepository.GetTopByPersona(noEmpleado);
if (evaluacionConductual != null)
{
var detalleEvaluacion = await detalleRepository.GetByClaveEvaluacionResultado(evaluacionConductual.claveEvaluacion);
conductual = new { datosEvaluado = evaluacionConductual, competencias = detalleEvaluacion };
if (detalleEvaluacion != null)
{
datosConductuales = 1;
}
else
{
datosConductuales = 0;
}
}
//DATOS DEL PERSONAL DE BASE
resultado = new { TipoPersonalId = persona.TipoPersonalId, conductuales = conductual, incluyeConductuales = datosConductuales, incluyeSindicalizados = 0, incluyeTecnicas = 0 };
}
}
else
{
datosConductuales = 0;
datostecnicas = 0;
EvaluacionEmpleadosCompetenciasConductuales evaluacionConductual = new EvaluacionEmpleadosCompetenciasConductuales();
EvaluacionConductualesRepository evaluacionRepository = new EvaluacionConductualesRepository();
DetalleEvaluacionConductualesRepository detalleRepository = new DetalleEvaluacionConductualesRepository();
var conductual = new object();
evaluacionConductual = await evaluacionRepository.GetTopByPersona(noEmpleado);
if (evaluacionConductual != null)
{
var detalleEvaluacion = await detalleRepository.GetByClaveEvaluacionResultado(evaluacionConductual.claveEvaluacion);
conductual = new { datosEvaluado = evaluacionConductual, competencias = detalleEvaluacion };
if (detalleEvaluacion != null)
{
datosConductuales = 1;
}
else
{
datosConductuales = 0;
}
}
EvaluacionEmpleadosCompetenciasTecnicas eval = new EvaluacionEmpleadosCompetenciasTecnicas();
EvaluacionTecnicasRepository evaluacionTecRepository = new EvaluacionTecnicasRepository();
DetalleEvaluacionTecnicasRepository detalleTecRepository = new DetalleEvaluacionTecnicasRepository();
eval = await evaluacionTecRepository.GetTopByPersona2(noEmpleado);
var tecnica = new Object();
if (eval != null)
{
var detalleEvaluacionTec = await detalleTecRepository.GetByEmpleado2(noEmpleado, eval.idPeriodo);
tecnica = new { datosEvaluado = eval, competencias = detalleEvaluacionTec };
if (detalleEvaluacionTec != null)
{
datostecnicas = 1;
}
else
{
datostecnicas = 0;
}
}
//DATOS DEL PERSONAL DE BASE
resultado = new { TipoPersonalId = persona.TipoPersonalId, conductuales = conductual, tecnicas = tecnica, incluyeConductuales = datosConductuales, incluyeSindicalizados = 0, incluyeTecnicas = datostecnicas };
}
return(resultado);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <DerechosAutor> Update(DerechosAutor derechoautor)
{
try
{
var _derechoautor = await _pictx.DerechosAutor.FirstOrDefaultAsync(e => e.DerechosAutorId == derechoautor.DerechosAutorId);
if (_derechoautor.AdjuntoId != null && _derechoautor != null && (!String.IsNullOrEmpty(derechoautor.accion) && derechoautor.accion == "elimina"))
{
var id = _derechoautor.AdjuntoId; //Se procede a eliminar el adjunto anterior en estos pasos
_derechoautor.AdjuntoId = null;
await _pictx.SaveChangesAsync();
await new AdjuntoRepository().Delete(id);
}
if (derechoautor.Adjunto != null)
{
if (derechoautor.Adjunto.AdjuntoId == 0)
{
Adjunto key = await new AdjuntoRepository().CreateAd(derechoautor.Adjunto);
derechoautor.AdjuntoId = key.AdjuntoId;
derechoautor.Adjunto.AdjuntoId = key.AdjuntoId;
}
}
var autores = await _pictx.AutoresDA.Where(e => e.DerechosAutorId == derechoautor.DerechosAutorId).ToListAsync();
if (autores.Count > 0)
{
_pictx.AutoresDA.RemoveRange(autores);
await _pictx.SaveChangesAsync();
}
if (derechoautor.Autores.Count > 0)
{
foreach (var autor in derechoautor.Autores)
{
autor.DerechosAutorId = derechoautor.DerechosAutorId;
}
_pictx.AutoresDA.AddRange(derechoautor.Autores);
await _pictx.SaveChangesAsync();
}
if (_derechoautor != null)
{
_pictx.Entry(_derechoautor).State = EntityState.Modified;
_pictx.Entry(_derechoautor).CurrentValues.SetValues(derechoautor);
await _pictx.SaveChangesAsync();
}
if (_derechoautor.EstadoFlujoId == 2)
{
var nuevasolicitud = await this.GeneraSolicitud(_derechoautor);
if (nuevasolicitud != null && nuevasolicitud.SolicitudId > 0)
{
//crear registro bitacora
var bitacora = RegistraBitacora(nuevasolicitud.SolicitudId, nuevasolicitud.ClavePersona);
}
if (!String.IsNullOrEmpty(derechoautor.listacoautores))
{
_derechoautor.listacoautores = derechoautor.listacoautores;
}
await EnviarNotificacion(nuevasolicitud.ClavePersona, _derechoautor);
}
if (_derechoautor.EstadoFlujoId == 3)
{
await new NuevoOCRepository().Create(
new NuevoOC("CH",
"DA",
_derechoautor.Titulo,
"IndexCH.html#/detallesdaexterno/" + _derechoautor.DerechosAutorId + "/",
_derechoautor.DerechosAutorId + ""
));
}
PersonasRepository prep = new PersonasRepository();
if (derechoautor.ClavePersona != null)
{
Personas p = await prep.GetByClave(derechoautor.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
return(derechoautor);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object> obtenMiembros()
{
try
{
await cargaComunidades();
var queryString = "select * from [SIGCO].[CP].[tMiembroCP]";
var DTMiembros = await Task.Run(() => { return(CreateCommandSIGCO2(queryString)); });
foreach (DataRow row in DTMiembros.Rows)
{
Miembros nuevoMiembro = new Miembros();
var foo = "";
var idCPE2 = row[1];
var numEmpE2 = row[2];
var rolE2 = row[3];
var fechaRegE2 = row[4];
//Obtiene los datos de CPE3 para posteriormente utilizarlos
var nombreCPE2 = await obtenNombreComunidadE2(Convert.ToInt32(idCPE2));
if (nombreCPE2 != "")
{
var ComunidadE3 = await _db.DbSetComunidades.FirstOrDefaultAsync(e => e.Descripcion == nombreCPE2);
//Obtiene el rol de los miembros
var rol = Convert.ToString(rolE2);
if (rol == "Lider")
{
nuevoMiembro.rolId = 3;
}
if (rol == "Secretario")
{
nuevoMiembro.rolId = 4;
}
if (rol == "Miembro")
{
nuevoMiembro.rolId = 2;
}
//Obtiene el nombre de la persona
PersonasRepository persona = new PersonasRepository();
var datosPersona = await persona.GetByClave(Convert.ToString(numEmpE2));
if (datosPersona != null)
{
//se procede a crear el nuevo miembro
nuevoMiembro.idCP = ComunidadE3.ComunidadId;
nuevoMiembro.FechaAlta = Convert.ToDateTime(fechaRegE2);
nuevoMiembro.Aceptacion = false;
nuevoMiembro.idPersonas = datosPersona.ClavePersona;
nuevoMiembro.nombrePersona = datosPersona.NombreCompleto;
nuevoMiembro.estado = true;
_db.DbSetMiembros.Add(nuevoMiembro);
await _db.SaveChangesAsync();
}
}
}
return(null);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(BecarioExterno model)
{
try
{
var _model = await _db.BecarioExterno
.FirstOrDefaultAsync(e => e.BecarioExternoId == model.BecarioExternoId);
if (model.EstadoFlujoId == 1 && _model.EstadoFlujoId == 3)
{
await new NuevoOCRepository().DeleteId("BecarioExterno", _model.BecarioExternoId + "");
}
if (_model != null)
{
foreach (var adjuntoBecarioExterno in model.AdjuntoBecarioExterno)
{
if (adjuntoBecarioExterno.Adjunto != null)
{
try
{
if (adjuntoBecarioExterno.Adjunto.AdjuntoId < 1) //NUEVO ADJUNTO
{
_dbGen.dbSetAdjuntos.Add(adjuntoBecarioExterno.Adjunto);
await _dbGen.SaveChangesAsync(); //guardar el adjunto
adjuntoBecarioExterno.AdjuntoId = adjuntoBecarioExterno.Adjunto.AdjuntoId;
adjuntoBecarioExterno.BecarioExternoId = model.BecarioExternoId;
//guardar nuevo adjuntoBecarioExterno
_db.AdjuntoBecarioExterno.Add(adjuntoBecarioExterno);
await _db.SaveChangesAsync(); //guardar el adjunto
_dbGen = new GEN_Context();
}
else //adjunto existente: actualizar el adjunto
{
if (adjuntoBecarioExterno.Adjunto.nombre.Equals("eliminar"))
{
var _adjuntoBe = await _db.AdjuntoBecarioExterno.FirstOrDefaultAsync(e => e.AdjuntoId == adjuntoBecarioExterno.Adjunto.AdjuntoId);
if (_adjuntoBe != null)
{
_db.AdjuntoBecarioExterno.Remove(_adjuntoBe);
await _db.SaveChangesAsync();
}
}
else
{
var _modelAdjunto = await _dbGen.dbSetAdjuntos.FirstOrDefaultAsync(e => e.AdjuntoId == adjuntoBecarioExterno.Adjunto.AdjuntoId);
_dbGen.Entry(_modelAdjunto).CurrentValues.SetValues(adjuntoBecarioExterno.Adjunto);
await _dbGen.SaveChangesAsync();
}
//if (model.EstadoFlujoId == 3)
//{
// await new NuevoOCRepository().Create(
// new NuevoOC("CH",
// "IBE",
// model.Titulo,
// "indexMT.html#/InformeBecariooDetails/" + model.BecarioExternoId
// ));
//}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
}
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(model.Asesor_ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
