public async Task <IActionResult> Edit(int id, [Bind("Id,FirstName,LastName,Degree,AcademicRank,OfficeNumber,HireDate")] Teacher teacher)
{
if (id != teacher.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(teacher);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TeacherExists(teacher.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(teacher));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,StudentId,FirstName,LastName,EnrollmentDate,AcquiredCredits,CurrentSemester,EducationLevel")] 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,fullName,indeks,signature")] 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> FinishEnrollment(int id, [Bind("Id,CourseId,StudentId,Semester,Year,Grade,SeminalUrl,ProjectUrl,ExamPoints,SeminalPoints,ProjectPoints,AdditionalPoints,FinishDate")] Enrollment enrollment)
{
if (id != enrollment.EnrollmentID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(enrollment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnrollmentExists(enrollment.EnrollmentID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(EnrollmentList)));
}
ViewData["CourseId"] = new SelectList(_context.Courses, "Id", "Title", enrollment.CourseID);
ViewData["StudentId"] = new SelectList(_context.Students, "Id", "FullName", enrollment.StudentID);
return(View(enrollment));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,title,desc")] Labvezba labvezba)
{
if (id != labvezba.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(labvezba);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LabvezbaExists(labvezba.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(labvezba));
}
public async Task <IActionResult> EditEnrollment(int id, int tId, TeacherEnrollmentViewModel input)
{
Enrollment entry = input.Enrollment;
if (entry.Id != id)
{
return(NotFound());
}
var enrollment = await _context.Enrollments
.Include(e => e.Course)
.Include(e => e.Student)
.FirstOrDefaultAsync(m => m.Id == id &&
(m.Course.FirstTeacherId == tId || m.Course.SecondTeacherId == tId));
if (enrollment == null)
{
return(NotFound());
}
AppUser user = await userManager.GetUserAsync(User);
if (tId != user.TeacherId)
{
return(RedirectToAction("AccessDenied", "Account", null));
}
if (ModelState.IsValid)
{
try
{
enrollment.ExamPoints = entry.ExamPoints;
enrollment.SeminalPoints = entry.SeminalPoints;
enrollment.ProjectPoints = entry.ProjectPoints;
enrollment.AdditionalPoints = entry.AdditionalPoints;
enrollment.Grade = entry.Grade;
enrollment.FinishDate = entry.FinishDate;
_context.Update(enrollment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnrollmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(RedirectToAction(nameof(EditEnrollment), new { id, tId }));
}
public async Task <IActionResult> UnEnrollStudents(UnEnrollStudentsViewModel entry)
{
if (ModelState.IsValid)
{
foreach (int eId in entry.EnrollmentIds)
{
Enrollment enrollment = await _context.Enrollments
.FirstOrDefaultAsync(c => c.Id == eId);
if (enrollment != null)
{
enrollment.FinishDate = entry.FinishDate;
_context.Update(enrollment);
}
}
await _context.SaveChangesAsync();
Course course = await _context.Courses.FirstOrDefaultAsync(c => c.Id == entry.CourseId);
return(RedirectToAction(nameof(Index), new { sTitle = course.Title, sSem = entry.Semester, sYear = entry.Year }));
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> EditEnrollment(int id, EnrollmentUploadViewModel entry)
{
if (entry.Enrollment.Id != id)
{
return(NotFound());
}
var enrollment = await _context.Enrollments
.Include(e => e.Course)
.Include(e => e.Student)
.FirstOrDefaultAsync(m => m.Id == id);
if (enrollment == null)
{
return(NotFound());
}
AppUser user = await userManager.GetUserAsync(User);
if (enrollment.StudentId != user.StudentId)
{
return(RedirectToAction("AccessDenied", "Account", null));
}
if (ModelState.IsValid)
{
try
{
enrollment.ProjectUrl = entry.Enrollment.ProjectUrl;
enrollment.SeminalUrl = UploadedFile(entry);
_context.Update(enrollment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnrollmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(RedirectToAction(nameof(EditEnrollment)));
}
public async Task <IActionResult> Edit(int id, TeacherForm Vmodel)
{
if (id != Vmodel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
string uniqueFileName = UploadedFile(Vmodel);
Teacher teacher = new Teacher
{
ProfilePicture = uniqueFileName,
TeacherId = Vmodel.Id,
FirstName = Vmodel.FirstName,
LastName = Vmodel.LastName,
Degree = Vmodel.Degree,
AcademicRank = Vmodel.AcademicRank,
OfficeNumber = Vmodel.OfficeNumber,
HireDate = Vmodel.HireDate,
Course1 = Vmodel.Courses_first,
Course2 = Vmodel.Courses_second
};
_context.Update(teacher);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TeacherExists(Vmodel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(Vmodel));
}
public async Task <IActionResult> Edit(long id, StudentForm Vmodel)
{
if (id != Vmodel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
string uniqueFileName = UploadedFile(Vmodel);
Student student = new Student
{
ID = Vmodel.Id,
FirstName = Vmodel.FirstName,
LastName = Vmodel.LastName,
ProfilePicture = uniqueFileName,
EnrollmentDate = Vmodel.EnrollmentDate,
CurrentSemestar = Vmodel.CurrentSemestar,
AcquiredCredits = Vmodel.AcquiredCredits,
StudentId = Vmodel.Index,
EducationLevel = Vmodel.EducationLevel,
Enrollments = Vmodel.Courses
};
_context.Update(student);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(Vmodel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(Vmodel));
}
public async Task <IActionResult> Edit(int id, [Bind("CourseID,Title,Credits,Semestar,Programme,EducationLevel,FirstTeacherId,SecondTeacherId")] Course course)
{
String s = null;
if (TempData["test"] != null)
{
s = TempData["test"].ToString();
}
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)));
}
ViewData["FirstTeacherId"] = new SelectList(_context.Teachers, "TeacherId", "FirstName", course.FirstTeacherId);
ViewData["SecondTeacherId"] = new SelectList(_context.Teachers, "TeacherId", "FirstName", course.SecondTeacherId);
return(View(course));
}
