public async Task <IActionResult> PutCursos(int id, Cursos cursos)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
if (id != cursos.Id)
{
return(BadRequest());
}
_context.Entry(cursos).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CursosExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
[Route("PutProfesor")]//Actualiza el perfil
public async Task <IActionResult> PutProfesor(Profesores profesores)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null && profesor.Id != profesores.Id)
{
return(BadRequest());
}
// Se realiza de esta manera, ya que habría conflicto con la entidad entrante (son iguales),
// por lo que se modifica la ultima retornada por el ef
profesor.Nombre = profesores.Nombre;
profesor.PrimerApellido = profesores.PrimerApellido;
profesor.SegundoApellido = profesores.SegundoApellido;
profesor.Correo = profesores.Correo;
profesor.Contrasenia = profesores.Contrasenia;
_context.Entry(profesor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(NoContent());
}
public async Task <Boolean> DeleteAllAsignaciones()
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(false);
}
try
{
var evaluaciones = await _context.Evaluaciones.Where(eva => eva.Profesor == profesor.Id).ToListAsync();
_context.Evaluaciones.RemoveRange(evaluaciones);
await _context.SaveChangesAsync();
var listaAsignaciones = await _context.Asignaciones.Include(x => x.NotificacionesCorreo)
.Where(x => x.Profesor == profesor.Id).ToListAsync();
_context.Asignaciones.RemoveRange(listaAsignaciones);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(false);
}
return(true);
}
public async Task <ActionResult <Cursos> > DeleteCursos(int id)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
var listaAsignaciones = _context.Asignaciones.Include(z => z.NotificacionesCorreo).Where(x => x.Curso == id).ToList();
foreach (Asignaciones asignacion in listaAsignaciones)
{
await DeleteAsignacionesC(asignacion);
}
_context.Asignaciones.RemoveRange(listaAsignaciones);
await _context.SaveChangesAsync();
var cursos = await _context.Cursos.Include(curso => curso.CursosGrupos)
.ThenInclude(cursoGrupo => cursoGrupo.IdGrupoNavigation)
.Where(curso => curso.Id == id).FirstOrDefaultAsync();
if (cursos == null)
{
return(NotFound());
}
_context.Cursos.Remove(cursos);
await _context.SaveChangesAsync();
return(cursos);
}
public async Task <ActionResult <Asignaciones> > DeleteAsignaciones(int id)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
var evaluaciones = await _context.Evaluaciones.Where(eva => eva.Asignacion == id).ToListAsync();
_context.Evaluaciones.RemoveRange(evaluaciones);
await _context.SaveChangesAsync();
var asignacion = await _context.Asignaciones.Where(asig => asig.Id == id).FirstOrDefaultAsync();
if (asignacion == null)
{
return(NotFound());
}
_context.Asignaciones.Remove(asignacion);
await _context.SaveChangesAsync();
return(asignacion);
}
public async Task <IActionResult> DeleteCursosGrupos(List <CursosGrupos> cursosGrupos)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
CursosGrupos borrarGC;
foreach (CursosGrupos cg in cursosGrupos)
{
borrarGC = _context.CursosGrupos.FirstOrDefault(cgt => cgt.Id == cg.Id);
_context.CursosGrupos.Remove(borrarGC);
}
//_context.CursosGrupos.RemoveRange(cursosGrupos);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(NoContent());
}
public async Task <ActionResult <Profesores> > GetProfesor()
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
return(profesor);
}
public async Task <ActionResult <IEnumerable <Grupos> > > GetGrupos()
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
return(await _context.Grupos.Where(grupo => grupo.IdProfesor == profesor.Id).Include(grupo => grupo.EstudiantesXgrupos).ToListAsync());
}
public async Task <ActionResult <IEnumerable <CursosGrupos> > > GetCursosGrupos()
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
return(await _context.CursosGrupos.Include(cursoGrupo => cursoGrupo.IdGrupoNavigation).ToListAsync());
}
public async Task <ActionResult <IEnumerable <Profesores> > > GetProfesores()
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null && profesor.Administrador)
{
return(BadRequest());
}
return(await _context.Profesores.ToListAsync());
}
public async Task <ActionResult <IEnumerable <Evaluaciones> > > GetEvaluacionesXAsignatura(int asignacion, int periodo)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
return(await _context.Evaluaciones.Where(evaluacion => evaluacion.Asignacion == asignacion && evaluacion.Periodo == periodo && evaluacion.Profesor == profesor.Id).ToArrayAsync());
}
public async Task <ActionResult <IEnumerable <Evaluaciones> > > GetEvaluaciones()
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
return(await _context.Evaluaciones.Where(evaluacion => evaluacion.Profesor == profesor.Id).ToListAsync());
}
public async Task <ActionResult <IEnumerable <EstudiantesXgrupos> > > GetEGOffline()
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
var lista = _context.EstudiantesXgrupos.Include(z => z.IdEstudianteNavigation).ToListAsync();
return(await lista);
}
public async Task <Boolean> DeleteGrupos(Grupos grupo)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(false);
}
_context.Grupos.Remove(grupo);
await _context.SaveChangesAsync();
return(true);
}
public async Task <ActionResult <Estudiantes> > PostEstudiantes(Estudiantes estudiantes)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
estudiantes.IdProfesor = profesor.Id;
_context.Estudiantes.Add(estudiantes);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEstudiantes", new { id = estudiantes.Id }, estudiantes));
}
public async Task <ActionResult <Profesores> > PostProfesores(Profesores profesores)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null && profesor.Administrador)
{
return(BadRequest());
}
_context.Profesores.Add(profesores);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetProfesores", new { id = profesores.Id }, profesores));
}
public async Task <ActionResult <Asignaciones> > PostAsignaciones(Asignaciones asignacion)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
asignacion.Profesor = profesor.Id;
_context.Asignaciones.Add(asignacion);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAsignaciones", new { id = asignacion.Id }, asignacion));
}
public async Task <ActionResult <Grupos> > PostGrupos(Grupos grupos)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
grupos.IdProfesor = profesor.Id;
_context.Grupos.Add(grupos);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetGrupos", new { id = grupos.Id }, grupos));
}
public async Task <ActionResult <Cursos> > GetCursos(int id)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
var cursos = await _context.Cursos.FindAsync(id);
if (cursos == null)
{
return(NotFound());
}
return(cursos);
}
public async Task <ActionResult <Profesores> > GetProfesor(int id)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null && profesor.Administrador)
{
return(BadRequest());
}
var profesores = await _context.Profesores.FindAsync(id);
if (profesores == null)
{
return(NotFound());
}
return(profesores);
}
public async Task <ActionResult <Asignaciones> > GetAsignaciones(int id)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
var asignacion = await _context.Asignaciones.FindAsync(id);
if (asignacion == null)
{
return(NotFound());
}
return(asignacion);
}
public async Task <IActionResult> PutGrupos(Grupos grupos)
{
try
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
_context.Entry(grupos).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(NoContent());
}
public async Task <Boolean> DeleteAllEstudiantes()
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(false);
}
try
{
var listaEstudiantes = _context.Estudiantes.Where(x => x.IdProfesor == profesor.Id).Include(EG => EG.EstudiantesXgrupos);
_context.Estudiantes.RemoveRange(listaEstudiantes);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(false);
}
return(true);
}
public async Task <ActionResult <Estudiantes> > DeleteEstudiantes(Estudiantes estudiante)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
var listaAsignaciones = _context.Evaluaciones.Where(x => x.Estudiante == estudiante.Id).ToList();
_context.Evaluaciones.RemoveRange(listaAsignaciones);
await _context.SaveChangesAsync();
Estudiantes estudianteEliminar = _context.Estudiantes.Where(x => x.Id == estudiante.Id).Include(EG => EG.EstudiantesXgrupos)
.FirstOrDefault();
_context.Remove(estudianteEliminar);
await _context.SaveChangesAsync();
return(estudiante);
}
public async Task <ActionResult <Profesores> > DeleteProfesores(int id)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null && profesor.Administrador)
{
return(BadRequest());
}
var profesorborrar = await GetProfesorCompleteData(profesor.Id);
if (profesorborrar == null)
{
return(NotFound());
}
_context.Profesores.Remove(profesorborrar);
await _context.SaveChangesAsync();
return(profesorborrar);
}
public async Task <Boolean> DeleteAllCursos()
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(false);
}
try
{
int idProfesor = profesor.Id;
var listaCursos = await _context.Cursos.Where(curso => curso.IdProfesor == idProfesor).ToListAsync();
_context.Cursos.RemoveRange(listaCursos);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(false);
}
return(true);
}
public async Task <IActionResult> PostCursosGrupos(List <CursosGrupos> cursosGrupos)
{
Profesores profesor = await ComprobacionSesion.ComprobarInicioSesion(HttpContext.Request.Headers, _context);
if (profesor == null)
{
return(BadRequest());
}
_context.CursosGrupos.AddRange(cursosGrupos);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(NoContent());
}