public async Task cambiaEstadoPublicacion(EstudiosEspecializados model)
{
try
{
var infoAgregada = await _genContext.dbSetNuevoOC.Where(e => e.descripcion.Equals(model.Nombre)).FirstOrDefaultAsync();
var estatusComunidad = await _db.DbSetComunidades.Where(e => e.ComunidadId == model.idCP).AsNoTracking().Select(x => x.Estado).FirstOrDefaultAsync();
if (estatusComunidad) //Solo se pueden hacer operaciones si la comunidad esta activa
{
if (infoAgregada != null && !model.Estado.Equals("Aprobado"))
{
infoAgregada.nuevo = false;
await _genContext.SaveChangesAsync();
}
else if (infoAgregada != null && model.Estado.Equals("Aprobado"))
{
infoAgregada.nuevo = true;
await _genContext.SaveChangesAsync();
}
else
{
await repo.Create("CP", "EstudiosEspecializados", model.Nombre, "indexCP.html#/detallesEstudios/" + model.EstudiosId, Convert.ToString(model.EstudiosId));
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Create(EstudiosEspecializados model)
{
try
{
if (model.claveAutores != null)
{
var estudios = _db.DbSetEstudios.Add(model);
await _db.SaveChangesAsync();
var estatusComunidad = await _db.DbSetComunidades.Where(e => e.ComunidadId == model.idCP).AsNoTracking().Select(x => x.Estado).FirstOrDefaultAsync();
if (model.Estado.Equals("Aprobado") && estatusComunidad)
{
//Los parametros son: moduloid, id del oc (en este caso son strings), descripcion, liga del detalle del oc
await repo.Create("CP", "EstudiosEspecializados", estudios.Nombre, "indexCP.html#/detallesEstudios/" + estudios.EstudiosId, Convert.ToString(estudios.EstudiosId));
}
Autores autor = new Autores();
foreach (var clave in model.claveAutores)
{
autor.clave = clave;
autor.ContenidoId = estudios.EstudiosId;
autor.idOC = 3;
autor.FechaRegistro = DateTime.Now;
_db.DbSetAutores.Add(autor);
await _db.SaveChangesAsync();
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(EstudiosEspecializados model)
{
try
{
var _model = await _db.DbSetEstudios.FirstOrDefaultAsync(e => e.EstudiosId == model.EstudiosId);
if (_model != null)
{
//Cuando se elimina el adjunto en modo edicion
if (model.adjuntoId != null)
{
int id = Convert.ToInt32(model.adjuntoId);
model.adjuntoId = null;
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
await _adjuntoRepo.Delete(id);
}
//Cuando se agrega un nuevo archivo
if (model.Adjunto != null && model.adjuntoId == null)
{
Adjunto key = await _adjuntoRepo.CreateAd(model.Adjunto);
model.adjuntoId = key.AdjuntoId;
model.Adjunto.AdjuntoId = key.AdjuntoId;
}
if (model.claveAutores != null)
{
var autoresRegistro = await _db.DbSetAutores.Where(e => e.idOC == 3 && e.ContenidoId == model.EstudiosId).AsNoTracking().ToListAsync();
//Eliminacion de autores
AutoresCPRepository autoresRepo = new AutoresCPRepository();
foreach (var c in autoresRegistro)
{
await autoresRepo.Delete(c.AutorId);
}
Autores autor = new Autores();
foreach (var clave in model.claveAutores)
{
autor.clave = clave;
autor.ContenidoId = model.EstudiosId;
autor.idOC = 3;
autor.FechaRegistro = DateTime.Now;
_db.DbSetAutores.Add(autor);
await _db.SaveChangesAsync();
}
}
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
await cambiaEstadoPublicacion(_model);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IEnumerable <Object> > GetAllConsultaPorOC(EstudiosEspecializados parametros)
{
try
{
var entities = (from ee in _db.DbSetEstudios select ee).Include(e => e.Comunidad);
AutoresCPRepository autoresOC = new AutoresCPRepository();
Autores a = new Autores();
if (entities != null)
{
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)));
}
if (!String.IsNullOrEmpty(parametros.nombreComunidad)) //busqueda por el nombre de la comunidad
{
ComunidadesRepository comunidad = new ComunidadesRepository();
var listaComunidades = await comunidad.GetPKComunidadesByCollateLatin1(parametros.nombreComunidad);
entities = entities.Where(e => listaComunidades.Contains(e.idCP));
}
if (!String.IsNullOrEmpty(parametros.Nombre)) //busqueda por nombre del EA
{
var listaPKs = await GetPKEstudiosByCollateLatin1(parametros.Nombre);
entities = entities.Where(e => listaPKs.Contains(e.EstudiosId));
}
if (!String.IsNullOrEmpty(parametros.PalabrasClave)) //busqueda por palabras clave
{
var listaPalabras = await GetPKPalabrasClaveByCollateLatin1(parametros.PalabrasClave);
entities = entities.Where(e => listaPalabras.Contains(e.EstudiosId));
}
if (!String.IsNullOrEmpty(parametros.nombrePersona)) //busqueda por autores del OC
{
List <int> listaIds = await autoresOC.GetPKAutoresByCollateLatin1(parametros.nombrePersona, 3);
entities = entities.Where(e => listaIds.Contains(e.EstudiosId));
}
foreach (var estado in entities)
{
estado.personas = await autoresOC.GetByOC(estado.EstudiosId, 3);
}
}
return(entities.OrderByDescending(e => e.FechaRegistro));
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> GetAllConsultaPorOC(EstudiosEspecializados parametros)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
var entities = await _entityRepo.GetAllConsultaPorOC(parametros);
return(Ok(entities));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <IHttpActionResult> Update([FromBody] EstudiosEspecializados model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
await _entityRepo.Update(model);
return(Ok("Registro actualizado exitosamente!"));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
