public async Task <IActionResult> Edit(int id, [Bind("ID,Name,InDate")] Student student)
{
if (id != student.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(student);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(student.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Tipo,Login,Password")] Usuario usuario)
{
if (id != usuario.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
//Actualiza el usuario en la BD
_context.Update(usuario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuarioExists(usuario.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(usuario));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ProfesorId,MateriaId")] MateriaProfesor materiaProfesor)
{
if (id != materiaProfesor.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
//Actualiza la relación en la BD
_context.Update(materiaProfesor);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MateriaProfesorExists(materiaProfesor.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
//En caso de recibir una relación invalida, vuelve a la view Edit y disponibiliza el mensaje de error
ViewBag.Erro = "display: inline; color:red;";
return(View(materiaProfesor));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nombre,Apellido,Dni,FechaNacimiento,Email,Telefono")] Alumno alumno)
{
if (id != alumno.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
//Hace un update en la tabla con los nuevos datos del profesor
_context.Update(alumno);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateConcurrencyException)
{
if (!AlumnoExists(alumno.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(View(alumno));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AlumnoId,CursoId")] CursoAlumno cursoAlumno)
{
if (id != cursoAlumno.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
//Actualiza la relación entre curso y alumno, asignando el alumno al nuevo curso
_context.Update(cursoAlumno);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CursoAlumnoExists(cursoAlumno.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(cursoAlumno));
}
public async Task <IActionResult> Edit(int id, [Bind("CourseID,Title,Credits")] Course course)
{
if (id != course.CourseID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(course);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseExists(course.CourseID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(course));
}
public async Task <IActionResult> ActualizarNota(int id, int nota1, int cuatrimestre, int alumnoId, int materiaId)
{
//Busca la nota que se desea actualizar
var nota = await _context.Nota
.FirstOrDefaultAsync(m => m.AlumnoId == alumnoId && m.MateriaId == materiaId && m.Cuatrimestre == cuatrimestre);
if (nota == null)
{
//En caso de no existir, se crea una nueva nota y se la inserta en la BD
Nota nuevaNota = new Nota();
nuevaNota.AlumnoId = alumnoId;
nuevaNota.MateriaId = materiaId;
nuevaNota.Cuatrimestre = cuatrimestre;
nuevaNota.Nota1 = nota1;
_context.Add(nuevaNota);
await _context.SaveChangesAsync();
}
else
{
try
{
//En caso de existir, se actualiza la nota en cuestion
nota.Nota1 = nota1;
_context.Update(nota);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NotaExists(nota.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
//Vuelve a la view Profesor
return(RedirectToAction("Profesor", "Notas", new { alumnoId = id }));
}
public IActionResult Put(int id, [FromBody] Teacher teacher)
{
if (teacher == null)
{
return(BadRequest());
}
if (!db.Teachers.Any(x => x.Id == teacher.Id))
{
return(NotFound());
}
db.Update(teacher);
db.SaveChanges();
return(Ok(teacher));
}
public IActionResult Put(int id, [FromBody] Student student)
{
if (student == null)
{
return(BadRequest());
}
if (!db.Students.Any(x => x.Id == student.Id))
{
return(NotFound());
}
db.Update(student);
db.SaveChanges();
return(Ok(student));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,CursoId,MateriaId")] CursoMateria cursoMateria)
{
if (id != cursoMateria.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
//Valida que el nuevo curso no tenga, previamente, la materia que se desea asignar
var cursoMat = _context.CursoMateria.Where(x => x.CursoId == cursoMateria.CursoId && x.MateriaId == cursoMateria.MateriaId).FirstOrDefault();
if (cursoMat == null)
{
_context.Update(cursoMateria);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateConcurrencyException)
{
if (!CursoMateriaExists(cursoMateria.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
//En caso de ser invalido, vuelve a la view Edit con la información necesaria
var materia = _context.Materia.Where(x => x.Id == cursoMateria.MateriaId).FirstOrDefault();
var cursos = (from c in _context.Curso
select c).ToList();
ViewBag.Materia = materia;
ViewBag.Curso = cursos;
ViewBag.Erro = "display: inline; color:red;";
return(View(cursoMateria));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Sigla")] Curso curso)
{
if (id != curso.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
//Valida que la sigla recibida sea del mismo curso y no de otro
//En caso de la sigla ser diferente, verifica que no sea una sigla ya existente en la BD
//En caso de no existir, se actualiza la sigla del curso
var mismoCurso = _context.Curso.Where(x => x.Id == id).FirstOrDefault();
var curs = _context.Curso.Where(x => x.Sigla == curso.Sigla).FirstOrDefault();
if (curs == null || curso.Sigla == mismoCurso.Sigla)
{
_context.Update(curso);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateConcurrencyException)
{
if (!CursoExists(curso.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
//En el caso de la sigla ser invalida, vuelve a la view Edit y disponibiliza el mensaje de error
ViewBag.Erro = "display: inline; color:red;";
return(View(curso));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nombre,Anio")] Materia materia)
{
if (id != materia.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
//Valido que los nuevos datos de la materia no coinciadn con otra materia
//En caso de ser valido, actualizo sus valores
var mismaMat = _context.Materia.Where(x => x.Id == id).FirstOrDefault();
var mat = _context.Materia.Where(x => x.Nombre == materia.Nombre && x.Anio == materia.Anio).FirstOrDefault();
if (mat == null || mat == mismaMat)
{
_context.Update(materia);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateConcurrencyException)
{
if (!MateriaExists(materia.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
//En caso de ser invalido, disponibilizo el mensaje de error
ViewBag.Erro = "display: inline; color:red;";
return(View(materia));
}