public ActionResult Edit([Bind(Include = "Id,Name,Grade,CourseId,StudentId,EnrollmentDate")] Enrollment enrollment)
{
if (ModelState.IsValid)
{
db.Entry(enrollment).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CourseId = new SelectList(db.Courses, "CourseId", "Name", enrollment.CourseId);
ViewBag.StudentId = new SelectList(db.Students, "Id", "FirstName", enrollment.StudentId);
return(View(enrollment));
}
public ActionResult Edit([Bind(Include = "EnrollmentID,CourseID,StudentID,Grade")] Enrollment enrollment)
{
if (ModelState.IsValid)
{
db.Entry(enrollment).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CourseID = new SelectList(db.Courses, "CourseID", "Title", enrollment.CourseID);
ViewBag.StudentID = new SelectList(db.Students, "ID", "LastName", enrollment.StudentID);
return(View(enrollment));
}
public ActionResult Edit([Bind(Include = "CourseID,Title,Capacity,DepartmentID,InstructorID")] Course course)
{
if (ModelState.IsValid)
{
db.Entry(course).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.DepartmentID = new SelectList(db.Departments, "DepartmentID", "Title", course.DepartmentID);
ViewBag.InstructorID = new SelectList(db.Instructors, "InstructorID", "FullName", course.InstructorID);
return(View(course));
}
public ActionResult DeleteLecturer(int lecturerId)
{
using (UniversityContext db = new UniversityContext())
{
Lecturer lecturer = db.Lecturers.Find(lecturerId);
db.Entry(lecturer).Collection(c => c.Students).Load();
lecturer.Students.Clear();
db.Entry(lecturer).Collection(c => c.Subjects).Load();
//List<Subject> colOfSubjects = lecturer.Subjects.ToList();
//db.Subjects.RemoveRange(colOfSubjects);
lecturer.Subjects.Clear();
db.Lecturers.Remove(lecturer);
db.SaveChanges();
}
return(RedirectToAction("Manage"));
}
public ActionResult Edit(Course course, int StudentId)
{
if (StudentId != 0)
{
_db.CourseStudent.Add(new CourseStudent()
{
StudentId = StudentId, CourseId = course.CourseId
});
}
_db.Entry(course).State = EntityState.Modified;
_db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit(Student student, int CourseId)
{
if (CourseId != 0)
{
_db.Enrollment.Add(new Enrollment()
{
CourseId = CourseId, StudentId = student.StudentId
});
}
_db.Entry(student).State = EntityState.Modified;
_db.SaveChanges();
return(RedirectToAction("Index"));
}
public static void ExplicitLoadingCollectionAggregation(UniversityContext context)
{
context.Configuration.LazyLoadingEnabled = false;
var course = context.Courses.FirstOrDefault(c => c.Name.Contains("Magic"));
var entry = context.Entry(course);
var query = entry.Collection(c => c.Students).Query();
var count = query.Count();
ForegroundColor = ConsoleColor.Green;
Write($"Course name: {course.Name.ToUpper()}");
ForegroundColor = ConsoleColor.Yellow;
WriteLine($" ({count} students enrolled)");
}
public ActionResult Edit([Bind(Include = "ID,CedulaProfesor,CodigoCurso,Matricula,Nota")] Inscripcion inscripcion)
{
if (ModelState.IsValid)
{
db.Entry(inscripcion).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CodigoCurso = new SelectList(db.Curso, "Codigo", "Nombre", inscripcion.CodigoCurso);
ViewBag.Matricula = new SelectList(db.Estudiante, "Matricula", "Nombre", inscripcion.Matricula);
ViewBag.CedulaProfesor = new SelectList(db.Profesor, "cedula", "Nombre", inscripcion.CedulaProfesor);
return(View(inscripcion));
}
// GET: Instructors
public async Task <IActionResult> Index(int?id, int?courseId)
{
var instructorsData = new InstructorIndexData();
instructorsData.Instructors = await _context.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.CourseAssignments)
.ThenInclude(i => i.Course)
.ThenInclude(i => i.Department)
.OrderBy(i => i.FirstName)
.ToListAsync();
if (id != null)
{
ViewData["InstructorId"] = id.Value;
var instructor = instructorsData.Instructors.Single(
i => i.Id == id.Value);
instructorsData.Courses = instructor.CourseAssignments.Select(
s => s.Course);
}
if (courseId != null)
{
ViewData["CourseId"] = courseId.Value;
var selectedCourse = instructorsData.Courses
.Single(x => x.Id == courseId);
await _context.Entry(selectedCourse).Collection(
x => x.Enrollments).LoadAsync();
foreach (var enrollment in selectedCourse.Enrollments)
{
await _context.Entry(enrollment).Reference(
x => x.Student).LoadAsync();
}
instructorsData.Enrollments = selectedCourse.Enrollments;
}
return(View(instructorsData));
}
public List <Student> GetStudents(int lecturerId)
{
List <Student> colOfStudents = new List <Student>();
using (UniversityContext db = new UniversityContext())
{
Lecturer lecturer = db.Lecturers.Find(lecturerId);
db.Entry(lecturer).Collection(c => c.Students).Load();
colOfStudents.AddRange(lecturer.Students.ToList());
}
return(colOfStudents);
}
public List <Subject> GetSubjects(int studentId)
{
List <Subject> colOfSubjects = new List <Subject>();
using (UniversityContext db = new UniversityContext())
{
Student student = db.Students.Find(studentId);
db.Entry(student).Collection(c => c.Subjects).Load();
colOfSubjects.AddRange(student.Subjects.ToList());
}
return(colOfSubjects);
}
public ActionResult DeleteStudent(int studentId)
{
using (UniversityContext db = new UniversityContext())
{
Student student = db.Students.Find(studentId);
db.Entry(student).Collection(c => c.Lecturers).Load();
student.Lecturers.Clear();
db.Entry(student).Collection(c => c.Marks).Load();
List <Mark> colOfMarks = student.Marks.ToList();
student.Marks.Clear();
db.Marks.RemoveRange(colOfMarks);
db.Entry(student).Collection(c => c.Subjects).Load();
student.Subjects.Clear();
db.Students.Remove(student);
db.SaveChanges();
}
return(RedirectToAction("Manage"));
}
public async Task <ActionResult> Edit([Bind(Include = "StudentId,Name,Faculty,Year,Stipend")] Student student)
{
var faculties = GetAllFaculties();
student.Faculties = GetSelectListItems(faculties);
if (ModelState.IsValid)
{
db.Entry(student).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(student));
}
public async Task <ActionResult> Edit([Bind(Include = "TeacherId,Name,Subject,Salary")] Teacher teacher)
{
var subjects = GetAllSubjects();
teacher.Subjects = GetSelectListItems(subjects);
if (ModelState.IsValid)
{
db.Entry(teacher).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(teacher));
}
public ActionResult ShowStudentsOfLecturer(int lecturerId)
{
List <Student> colOfStudents = new List <Student>();
using (UniversityContext db = new UniversityContext())
{
Lecturer lecturer = db.Lecturers.Find(lecturerId);
db.Entry(lecturer).Collection(c => c.Students).Load();
colOfStudents.AddRange(lecturer.Students.ToList());
}
//ViewBag.colOfStudents = colOfStudents;
//return colOfStudents;
return(PartialView(colOfStudents));
}
public ActionResult DeleteSubject(string subjectName)
{
using (UniversityContext db = new UniversityContext())
{
List <Subject> colOfSubjects = db.Subjects.Where(s => s.Name == subjectName).ToList();
foreach (Subject subject in colOfSubjects)
{
db.Entry(subject).Collection(c => c.Students).Load();
subject.Students.Clear();
subject.Lecturer = null;
db.Entry(subject).Collection(c => c.Marks).Load();
List <Mark> colOfMarks = subject.Marks.ToList();
subject.Marks.Clear();
db.Marks.RemoveRange(colOfMarks);
}
db.Subjects.RemoveRange(colOfSubjects);
db.SaveChanges();
}
return(RedirectToAction("Manage"));
}
// GET: Instructor
public ActionResult Index(int?id, int?courseID)
{
var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);
if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(
i => i.ID == id.Value).Single().Courses;
}
if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
//Lazy loading
//viewModel.Enrollments = viewModel.Courses.Where(
//x => x.CourseID == courseID).Single().Enrollments;
//Explicit loading
var selectedCourse = viewModel.Courses.Where(x => x.CourseID == courseID)
.Single(); db.Entry(selectedCourse)
.Collection(x => x.Enrollments)
.Load();
foreach (Enrollment enrollment in selectedCourse.Enrollments)
{
db.Entry(enrollment).Reference(x => x.Student).Load();
}
viewModel.Enrollments = selectedCourse.Enrollments;
}
return(View(viewModel));
}
public async Task <IActionResult> PutCourse(int id, EnrollmentsViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != model.course.ID)
{
return(BadRequest());
}
//Ne se sekjavam sto sum pravel...
_context.Entry(model.course).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
IEnumerable <long> listStudents = model.selectedStudents;
IQueryable <Enrollment> toBeRemoved = _context.Enrollment.Where(s => !listStudents.Contains(s.studentID) && s.courseID == id);
_context.Enrollment.RemoveRange(toBeRemoved);
IEnumerable <long> existStudents = _context.Enrollment.Where(s => listStudents.Contains(s.studentID) && s.courseID == id).Select(s => s.studentID);
IEnumerable <long> newStudents = listStudents.Where(s => !existStudents.Contains(s));
foreach (int studentId in newStudents)
{
_context.Enrollment.Add(new Enrollment {
studentID = studentId, courseID = id
});
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Courses Update(Courses courses)
{
using (UniversityContext universityContext = new UniversityContext())
{
var courseInDB = universityContext.Courses.Find(courses.CourseID);
courseInDB.Credits = courses.Credits;
courseInDB.Title = courses.Title;
universityContext.Entry(courseInDB).State = EntityState.Modified;
universityContext.SaveChanges();
}
return(courses);
}
public ActionResult DeleteConfirmed(int id)
{
try
{
var studentToDelete = new Student {
ID = id
};
_universityContext.Entry(studentToDelete).State = EntityState.Deleted;
_universityContext.SaveChanges();
}
catch (RetryLimitExceededException)
{
return(RedirectToAction("Delete", new { id, saveChangesError = true }));
}
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "ID,LastName,FirstMidName,EnrollmentDate")] Student student)
{
try
{
if (ModelState.IsValid)
{
db.Entry(student).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (DataException /* dex */)
{
ModelState.AddModelError("", "Unable to save changes.");
}
return(View(student));
}
public ActionResult Edit([Bind(Include = "CourseID,Title,Credits,DepartmentID")] Course course)
{
try
{
if (ModelState.IsValid)
{
db.Entry(course).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (RetryLimitExceededException /* dex */)
{
ModelState.AddModelError("", "Unable to save changes. Try again and if problem " + "persists, see your administrator.");
}
PopulateDepartmentsDropDownList(course.DepartmentID);
return(View(course));
}
public ActionResult Edit([Bind(Include = "ID,LastName,FirstMidName,EnrollmentDate")] Student student)
{
try
{
if (ModelState.IsValid)
{
db.Entry(student).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (DataException)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(student));
}
public ActionResult Delete(int id)
{
try
{
Student studentToDelete = new Student()
{
ID = id
};
db.Entry(studentToDelete).State = EntityState.Deleted;
//Student student = db.Students.Find(id);
//db.Students.Remove(student);
db.SaveChanges();
}
catch (RetryLimitExceededException)
{
//log the Error
return(RedirectToAction("Delete", new { id = id, saveChangesError = true }));
}
return(RedirectToAction("Index"));
}
public ActionResult EditLecturer(int lecturerId)
{
Lecturer lecturer = new Lecturer();
List <Subject> colOfSubjects = new List <Subject>();
List <Student> colOfStudents = new List <Student>();
using (UniversityContext db = new UniversityContext())
{
lecturer = db.Lecturers.Find(lecturerId);
db.Entry(lecturer).Collection(c => c.Subjects).Load();
colOfSubjects = db.Subjects.Where(s => s.Lecturer == null).ToList().Distinct().ToList();
}
ViewBag.lecturer = lecturer;
ViewBag.colOfSubjects = colOfSubjects;
return(View());
}
//Truy vấn collection navigation property với Explicit loading
public static void ExplicitLoadingCollectionQuery(UniversityContext context)
{
context.Configuration.LazyLoadingEnabled = false;
var course = context.Courses.FirstOrDefault(c => c.Name.Contains("Magic"));
var entry = context.Entry(course);
var query = entry.Collection(c => c.Students).Query();
var gryffindor = query.Where(s => s.Group == "Gryffindor");
gryffindor.Load();
ForegroundColor = ConsoleColor.Green;
WriteLine($"Course name: {course.Name.ToUpper()}");
ForegroundColor = ConsoleColor.Cyan;
WriteLine("# Gryffindor students enrolled in this course:");
ResetColor();
foreach (var s in gryffindor)
{
WriteLine($" -> {s.FirstName} {s.LastName}");
}
}
public Courses Add(Courses courses)
{
using (UniversityContext universityContext = new UniversityContext())
{
var courseInDB = universityContext.Courses.Find(courses.CourseID);
if (courseInDB == null)
{
var itemToAdd = new Course();
itemToAdd.Credits = courses.Credits;
itemToAdd.Title = courses.Title;
itemToAdd.DepartmentID = 4;
universityContext.Entry(itemToAdd).State = EntityState.Added;
universityContext.SaveChanges();
courses.CourseID = itemToAdd.CourseID;
}
}
return(courses);
}
public void Create(T item)
{
_context.Entry(item).State = EntityState.Added;
}
public IActionResult Get(string discipline, string student, string group)
{
if (student != null)
{
List <Student> students = context.Students.Where(x => x.Name.Contains(student)).ToList();
if (students == null || students.Count == 0)
{
return(View("~/Views/Values/Error.cshtml", "Такого студента немає"));
}
if (students.Count == 1)
{
Student stud = students.First(x => x.Name.Contains(student));
context.Entry(stud).Collection("Subjects").Load();
context.Entry(stud).Reference("Group").Load();
return(View("~/Views/Values/byName.cshtml", stud));
}
else
{
if (group != null)
{
foreach (Student st in students)
{
context.Entry(st).Reference("Group").Load();
}
try
{
Student first = students.First(x => x.Group.NameGroup == group);
context.Entry(first).Collection("Subjects").Load();
return(View("~/Views/Values/byName.cshtml", first));
}
catch
{
}
}
else
{
Student stud = context.Students.First(x => x.Name.Contains(student));
context.Entry(stud).Collection("Subjects").Load();
context.Entry(stud).Reference("Group").Load();
return(View("~/Views/Values/byName.cshtml", stud));
}
}
}
if (group != null)
{
Group grou = null;
try
{
grou = context.Groups.First(x => x.NameGroup == group);
}
catch
{
return(View("~/Views/Values/Error.cshtml", "Такої групи немає"));
}
context.Entry(grou).Collection("Students").Load();
foreach (Student st in grou.Students)
{
context.Entry(st).Collection("Subjects").Load();
}
grou.Students = grou.Students.OrderBy(x => x.Name).ToList();
return(View("~/Views/Values/byGroup.cshtml", grou));
}
if (discipline != null)
{
Subject subject = null;
try
{
subject = context.Subjects.First(x => x.Name.Contains(discipline));
}
catch
{
return(View("~/Views/Values/Error.cshtml", "Такого предмету немає"));
}
List <Subject> subjects = context.Subjects.Where(s => s.Name == subject.Name).ToList();
foreach (Subject sb in subjects)
{
context.Entry(sb).Reference("Student").Load();
context.Entry(sb.Student).Reference("Group").Load();
}
return(View("~/Views/Values/byDiscipline.cshtml", subjects));
}
return(null);
}
public ActionResult Edit(Course course)
{
_db.Entry(course).State = EntityState.Modified;
_db.SaveChanges();
return(RedirectToAction("Index"));
}
