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)); } }