public async Task <IActionResult> Create([Bind("Id,Nombre,Apellido,Dni,FechaNacimiento,Email,Telefono")] Alumno alumno)
{
if (ModelState.IsValid)
{
//Busca en la BD un alumno que ya exista con el DNI que se desea crear el nuevo alumno
var alum = _context.Usuarios.Where(x => x.Login == alumno.Dni).FirstOrDefault();
//En caso de no existir, se agrega el nuevo alumno y se crea un nuevo usuario de alumno
if (alum == null)
{
_context.Add(alumno);
await _context.SaveChangesAsync();
Usuario user = new Usuario();
user.Tipo = 1;
user.Login = alumno.Dni;
user.Password = alumno.Nombre.ToLower();
_context.Add(user);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
//En caso de existir un alumno con el DNI recibido, se disponibiliza el mensaje de error
ViewBag.Erro = "display: inline; color:red;";
return(View(alumno));
}
public async Task <IActionResult> Create([Bind("Id,Nombre,Apellido,Dni,FechaNacimiento,Email,Telefono")] Profesor profesor)
{
if (ModelState.IsValid)
{
//Verifica que el DNI del profesor que se quiere crear no exista previamente
var profe = _context.Usuarios.Where(x => x.Login == profesor.Dni).FirstOrDefault();
if (profe == null)
{
//En caso de no existir, se crea el nuevo profesor y un usuario para el mismo
_context.Add(profesor);
await _context.SaveChangesAsync();
Usuario user = new Usuario();
user.Tipo = 2;
user.Login = profesor.Dni;
user.Password = profesor.Nombre.ToLower();
_context.Add(user);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
//En caso de ya existir, disponibiliza un mensaje de error y vuelve a la view Create
ViewBag.Erro = "display: inline; color:red;";
return(View(profesor));
}
public void RegisterStudent(string fname, string lname, string username, string passcode,
DateTime dob, string homePhone, string mobile, string email, string addr,
string postcode, string city, int credits)
{
using var db = new SchoolDBContext();
var mail = (fname.ElementAt(0) + lname) + emailSignature;
db.Add(new Student
{
FirstName = fname,
LastName = lname,
Username = username,
Passcode = passcode,
Dob = dob,
HomePhone = homePhone,
MobilePhone = mobile,
Email = mail,
Addr = addr,
Postcode = postcode,
City = city
});
db.SaveChanges();
}
public async Task <IActionResult> AddDepartment(Department department)
{
db.Add(department);
await db.SaveChangesAsync();
return(RedirectToAction("AllDepartment"));
}
public async Task <IActionResult> Create([Bind("Id,CursoId,MateriaId")] CursoMateria cursoMateria)
{
if (ModelState.IsValid)
{
//Valida que la materia no este asignada al curso, buscando una relacion entre ese curso y esa materia en la BD
var cursoMat = _context.CursoMateria.Where(x => x.CursoId == cursoMateria.CursoId && x.MateriaId == cursoMateria.MateriaId).FirstOrDefault();
if (cursoMat == null)
{
_context.Add(cursoMateria);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
//En caso de ya existir, vuelve a la view Create con toda la información necesaria y disponibiliza el mensaje de error
var materias = (from m in _context.Materia
orderby m.Nombre ascending
select m).ToList();
var cursos = (from c in _context.Curso
orderby c.Sigla ascending
select c).ToList();
ViewBag.Materias = materias;
ViewBag.Cursos = cursos;
ViewBag.Erro = "display: inline; color:red;";
return(View(cursoMateria));
}
public async Task <IActionResult> AddClub(ClubAddClubViewModel vm)
{
var department = await NewMethod(vm);
vm.Club.Department = department;
db.Add(vm.Club);
await db.SaveChangesAsync();
return(RedirectToAction("AllClub"));
}
public async Task <IActionResult> Create([Bind("ID,Name,InDate")] Student student)
{
if (ModelState.IsValid)
{
_context.Add(student);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task <IActionResult> Create([Bind("Id,Tipo,Login,Password")] Usuario usuario)
{
if (ModelState.IsValid)
{
_context.Add(usuario);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(usuario));
}
public void EnrolStudent(int courseId, int studentId)
{
using var db = new SchoolDBContext();
db.Add(new Enrolment
{
Grade = "A",
EnrolmentDate = DateTime.Today,
CourseId = courseId,
StudentId = studentId
});
}
public async Task <IActionResult> Create([Bind("CourseID,Title,Credits")] Course course)
{
if (ModelState.IsValid)
{
_context.Add(course);
await _context.SaveChangesAsync();
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 async Task <IActionResult> Create([Bind("Id,AlumnoId,CursoId")] CursoAlumno cursoAlumno)
{
if (ModelState.IsValid)
{
//Inserto el nuevo cursoAlumno en la BD
_context.Add(cursoAlumno);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
//En caso de ser invalido, disponibiliza el mensaje de error
ViewBag.Erro = "display: inline; color:red;";
return(View(cursoAlumno));
}
public async Task <IActionResult> Create([Bind("FirstName,LastName,Age,Address")] StudentCreateViewModel student)
{
//if(student.FirstName[0] != student.FirstName.ToUpper()[0])
//{
// ModelState.AddModelError(nameof(student.FirstName), "Names should begin with capital letter");
//}
if (ModelState.IsValid)
{
_context.Add(student.MapToDbModel());
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task <IActionResult> Create([Bind("Id,ProfesorId,MateriaId")] MateriaProfesor materiaProfesor)
{
if (ModelState.IsValid)
{
//Inserto la nueva relación entre materia y profesor en la BD
_context.Add(materiaProfesor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
//Si la relación es invalida vuelve a la view Create con toda la información necesaria y disponibiliza el mensaje de error
var profesores = (from p in _context.Profesor
select p).ToList();
List <Profesor> profesSinMateria = new List <Profesor>();
foreach (Profesor p in profesores)
{
MateriaProfesor profe = null;
profe = _context.MateriaProfesor.Where(m => m.ProfesorId == p.Id)
.FirstOrDefault();
if (profe == null)
{
profesSinMateria.Add(p);
}
}
var materias = (from m in _context.Materia
orderby m.Nombre ascending
select m).ToList();
List <Materia> materiasSinProfe = new List <Materia>();
foreach (Materia m in materias)
{
MateriaProfesor mate = null;
mate = _context.MateriaProfesor.Where(x => x.MateriaId == m.Id)
.FirstOrDefault();
if (mate == null)
{
materiasSinProfe.Add(m);
}
}
ViewBag.Profesores = profesSinMateria;
ViewBag.Materias = materiasSinProfe;
ViewBag.Erro = "display: inline; color:red;";
return(View(materiaProfesor));
}
public async Task <IActionResult> Create([Bind("Id,Nombre,Anio")] Materia materia)
{
if (ModelState.IsValid)
{
//Valido que la materia creada no exista previamente
var mat = _context.Materia.Where(x => x.Nombre == materia.Nombre && x.Anio == materia.Anio).FirstOrDefault();
if (mat == null)
{
_context.Add(materia);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
//En caso de ser invalido, disponibilizo el mensaje de error
ViewBag.Erro = "display: inline; color:red;";
return(View(materia));
}
public async Task <IActionResult> Create([Bind("Id,Sigla")] Curso curso)
{
if (ModelState.IsValid)
{
//Valida que la sigla del nuevo curso no exista en la BD
var curs = _context.Curso.Where(x => x.Sigla == curso.Sigla).FirstOrDefault();
if (curs == null)
{
_context.Add(curso);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
//En caso de existir un curso con la sigla recibida, se disponibiliza el mensaje de error
ViewBag.Erro = "display: inline; color:red;";
return(View(curso));
}
