public async Task <IActionResult> PutTeacher(int id, Teacher teacher)
{
if (id != teacher.Id)
{
return(BadRequest());
}
context.Entry(teacher).State = EntityState.Modified;
try
{
await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TeacherExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
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> 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 async Task <Education> Add(Education education)
{
/*try
* {
* var result = schoolDbContext.Educations.AddAsync(education); // ChangeTracker --> Iets dat in het geheugen bijhoudt wat je in de db gedaan hebt
* await schoolDbContext.SaveChangesAsync();
*//*
* By Value
* By Reference --> Het argument dat je aan de methode geeft --> MOesten er wijziggingen op gebruern --> Db geeft het terug
* --> Education kan veranderd zijn (bv ID = auto increment)
*//*
* //return result; --> Niet ok
* return education; // ByRef
* }
* catch (Exception ex)
* {
* Console.WriteLine(ex.Message);
* return null;
* }*/
try
{
var result = schoolDbContext.Educations.AddAsync(education); //ChangeTracking
await schoolDbContext.SaveChangesAsync(); //MUST !!!!
//return result; //NOK
return(education); //ByRef -> autoIdentity ingevuld
}
catch (Exception exc)
{
Debug.WriteLine(exc.InnerException.Message);
return(null);
}
}
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> PutStudent(int id, Student student)
{
if (id != student.StudentID)
{
return(BadRequest());
}
_context.Entry(student).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//CREATE ------------------------
public async Task <Student> Create(Student student)
{
try
{
var result = context.Students.AddAsync(student);
await context.SaveChangesAsync();
return(student); //heeft nu een id (autoidentity)
}
catch (Exception exc)
{
Console.WriteLine(exc.InnerException.Message);
return(null);
}
// SQL
//using (SqlConnection con = new SqlConnection(connectionString))
//{
// string SQL = "Insert into Students(Name, Gender, Email, DateOfBirth, PassWord , EducationId)";
// SQL += " Values(@Name, @Gender, @Email, @DateOfBirth, @PassWord , @EducationId)";
// SqlCommand cmd = new SqlCommand(SQL, con);
// cmd.Parameters.AddWithValue("@Name", student.Name);
// cmd.Parameters.AddWithValue("@Gender", student.Gender);
// cmd.Parameters.AddWithValue("@Email", student.Email ?? "");
// //cmd.Parameters.AddWithValue("@DateOfBirth", Student.DateOfBirth != null ? Student.DateOfBirth : (System.DateTime) SqlDateTime.Null);
// if (student.Birthday != null)
// {
// cmd.Parameters.AddWithValue("@DateOfBirth", student.Birthday);
// }
// else
// {
// cmd.Parameters.AddWithValue("@DateOfBirth", DBNull.Value);
// }
// cmd.Parameters.AddWithValue("@Password", student.Password ?? "");
// //Maak educationId Nullable via int? ( gezien het een integer is)
// if (student.EducationId != null)
// {
// cmd.Parameters.AddWithValue("@EducationId", student.EducationId);
// }
// else
// {
// cmd.Parameters.AddWithValue("@EducationId", DBNull.Value);
// }
// con.Open();
// //SqlDataReader reader = cmd.ExecuteReader();
// await cmd.ExecuteNonQueryAsync();
// //cmd.ExecuteNonQuery();
// con.Close();
// return student;
//}
}
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));
}
//POST
public async Task <IHttpActionResult> Post(Course course)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Courses.Add(course);
await db.SaveChangesAsync();
return(Created(course));
}
//POST
public async Task <IHttpActionResult> Post(Department department)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Departments.Add(department);
await db.SaveChangesAsync();
return(Created(department));
}
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> 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 async Task <IActionResult> Post([FromBody] Person Person)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Person.Add(Person);
await db.SaveChangesAsync();
return(Created(Person));
}
public async Task <ActionResult> Create([Bind(Include = "DepartmentID,Name,Budget,StartDate,InstructorID")] Department department)
{
if (ModelState.IsValid)
{
db.Departments.Add(department);
// In the Create, HttpPost Edit, and DeleteConfirmed methods, it is the SaveChanges method call that causes a command to be executed, not statements such as db.Departments.Add(department) which only cause entities in memory to be modified.
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.InstructorID = new SelectList(db.Instructors, "ID", "FullName", department.InstructorID);
return(View(department));
}
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 <Teacher> Add(Teacher teacher)
{
try
{
var result = _schoolDBContext.Teachers.AddAsync(teacher);//ChangeTracking
await _schoolDBContext.SaveChangesAsync();
return(teacher); //heeft nu een id (autoidentity)
}
catch (Exception exc)
{
Debug.WriteLine(exc.InnerException.Message);
return(null);
}
}
//CREATE ------------------------
public async Task <Education> Create(Education education)
{
try
{
var result = context.Educations.AddAsync(education);
await context.SaveChangesAsync();
return(education); //heeft nu een id (autoidentity)
}
catch (Exception exc)
{
Console.WriteLine(exc.InnerException.Message);
return(null);
}
}
public async Task <Teacher> Add(Teacher teacher)
{
try
{
var result = context.AddAsync(teacher);
await context.SaveChangesAsync();
return(teacher);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
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> AddDepartment(Department department)
{
db.Add(department);
await db.SaveChangesAsync();
return(RedirectToAction("AllDepartment"));
}
public async Task <IActionResult> PutEscuela(int id, Escuela escuela)
{
using (var _context = new SchoolDBContext())
{
if (id != escuela.Id)
{
return(BadRequest());
}
_context.Entry(escuela).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EscuelaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
}
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,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));
}
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> 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 <ActionResult <Estudiante> > PostEstudiante(Estudiante estudiante)
{
using (var _context = new SchoolDBContext())
{
_context.Estudiante.Add(estudiante);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEstudiante", new { id = estudiante.Id }, estudiante));
}
}
public async Task <ActionResult <Escuela> > PostEscuela(Escuela escuela)
{
using (var _context = new SchoolDBContext())
{
_context.Escuela.Add(escuela);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEscuela", new { id = escuela.Id }, escuela));
}
}
public async Task <ActionResult <Trabajo> > PostTrabajo(Trabajo trabajo)
{
using (var _context = new SchoolDBContext())
{
_context.Trabajo.Add(trabajo);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTrabajo", new { id = trabajo.Id }, trabajo));
}
}
public async Task <ActionResult <Materia> > PostMateria(Materia materia)
{
using (var _context = new SchoolDBContext())
{
_context.Materia.Add(materia);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMateria", new { id = materia.Id }, materia));
}
}
public async Task <ActionResult <Profesor> > PostProfesor(Profesor profesor)
{
using (var _context = new SchoolDBContext())
{
_context.Profesor.Add(profesor);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetProfesor", new { id = profesor.Id }, profesor));
}
}