public async Task <IActionResult> Create([Bind("CourseCode,StudentId,Grade")] AcademicRecord academicRecord)
{
var existing = _context.AcademicRecord.Where(a => a.CourseCode.Equals(academicRecord.CourseCode) && a.StudentId.Equals(academicRecord.StudentId)).FirstOrDefault();
ViewData["Error"] = "";
if (existing != null)
{
ViewData["Error"] = "The student has already had this academic record";
}
else
{
if (ModelState.IsValid)
{
_context.Add(academicRecord);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
//ViewData["CourseCode"] = new SelectList(_context.Course, "Code", "Code", academicRecord.CourseCode);
//ViewData["StudentId"] = new SelectList(_context.Student, "Id", "Id", academicRecord.StudentId);
ViewData["CourseCode"] = new SelectList(_context.Course.Select(c => new { Code = c.Code, Course = c.Code + " - " + c.Title }), "Code", "Course");
ViewData["StudentId"] = new SelectList(_context.Student.Select(s => new { Id = s.Id, Student = s.Id + " - " + s.Name }), "Id", "Student");
return(View(academicRecord));
}
public async Task <IActionResult> Create(EmployeeRoleSelections employeeRoleSelections)
{
if (!employeeRoleSelections.roleSelections.Any(m => m.Selected))
{
ModelState.AddModelError("roleSelections", "You mast select at least one role!");
}
if (_context.Employee.Any(a => a.UserName == employeeRoleSelections.employee.UserName))
{
ModelState.AddModelError("Employee.UserName", "This user name already exists!");
}
if (ModelState.IsValid)
{
_context.Add(employeeRoleSelections.employee);
await _context.SaveChangesAsync();
foreach (RoleSelection roleSelection in employeeRoleSelections.roleSelections)
{
if (roleSelection.Selected)
{
EmployeeRole employeeRole = new EmployeeRole {
RoleId = roleSelection.role.Id, EmployeeId = employeeRoleSelections.employee.Id
};
_context.EmployeeRole.Add(employeeRole);
}
}
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
return(View(employeeRoleSelections));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,UserName,Password")] Employee employee)
{
if (id != employee.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(employee);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(employee.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(employee));
}
public async Task <IActionResult> Create([Bind("CourseCode,StudentId,Grade")] AcademicRecord academicRecord)
{
if (ModelState.IsValid)
{
var exists = (from e in _context.AcademicRecord where string.Compare(e.StudentId, academicRecord.StudentId) == 0 && string.Compare(e.CourseCode, academicRecord.CourseCode) == 0 select e).FirstOrDefault <AcademicRecord>();
if (exists == null)
{
_context.Add(academicRecord);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
ModelState.AddModelError("CourseCode", "The student has already had an academic record for this course");
}
}
var courses = (from a in _context.Course select new { Code = a.Code, Title = a.Code + " - " + a.Title }).ToList();
ViewData["CourseCode"] = new SelectList(courses, "Code", "Title");
var students = (from b in _context.Student select new { Id = b.Id, Name = b.Id + " - " + b.Name }).ToList();
ViewData["StudentId"] = new SelectList(students, "Id", "Name");
return(View(academicRecord));
}
public async Task <IActionResult> Create([Bind("Code,Title,Description,HoursPerWeek,FeeBase")] 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,Name,UserName,Password")] Employee employee)
{
if (ModelState.IsValid)
{
_context.Add(employee);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(employee));
}
public async Task <IActionResult> Create([Bind("Id,Name")] Student student)
{
if (ModelState.IsValid)
{
_context.Add(student);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task <IActionResult> Edit(EmployeeRoleSelections employeeRoleSelections)
{
if (!employeeRoleSelections.roleSelections.Any(m => m.Selected))
{ // Validate RoleSelections
ModelState.AddModelError("roleSelections", "You must select at least one role!");
}
if (_context.Employee.Any(e => e.UserName == employeeRoleSelections.employee.UserName &&
e.Id != employeeRoleSelections.employee.Id))
{ // Validate user name
ModelState.AddModelError("employee.UserName", "This user name already exists!");
}
if (ModelState.IsValid)
{ // Update DB context:
try
{
_context.Update(employeeRoleSelections.employee);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(employeeRoleSelections.employee.Id))
{
return(NotFound());
}
else
{
throw;
}
}
// Reset EmployeeRoles
var ERTable = _context.EmployeeRole
.Where(er => er.EmployeeId == employeeRoleSelections.employee.Id);
foreach (var roleRow in ERTable)
{
_context.EmployeeRole.Remove(roleRow);
}
foreach (RoleSelection roleSelection in employeeRoleSelections.roleSelections)
{ // Add EmployeeRoles
if (roleSelection.Selected)
{
EmployeeRole employeeRole = new EmployeeRole
{
RoleId = roleSelection.role.Id,
EmployeeId = employeeRoleSelections.employee.Id
};
_context.EmployeeRole.Add(employeeRole);
}
}
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
return(View(employeeRoleSelections));
}
public async Task <IActionResult> Create([Bind("CourseCode,StudentId,Grade")] AcademicRecord academicRecord)
{
if (ModelState.IsValid)
{
_context.Add(academicRecord);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseCode"] = new SelectList(_context.Course, "Code", "Code", academicRecord.CourseCode);
ViewData["StudentId"] = new SelectList(_context.Student, "Id", "Id", academicRecord.StudentId);
return(View(academicRecord));
}
public async Task <IActionResult> Index(string sort, [Bind("CourseCode[], StudentId[], Grade[]")] AcademicRecord[] academicRecord)
{
if (ModelState.IsValid)
{
for (int i = 0; i < academicRecord.Length; i++)
{
try
{
//save the student's academic record
_context.Update(academicRecord[i]);
await _context.SaveChangesAsync();
}
catch
{
//if it fails, continue onto the next student
continue;
}
}
}
ViewData["sort"] = sort; //set the last sorting used
//creating array from db to modify index view:
var StudentRecordContext = _context.AcademicRecord.Include(a => a.CourseCodeNavigation).Include(a => a.Student);
AcademicRecord[] records = StudentRecordContext.ToArray();
AcademicRecord[] sortedRecords = records;
//Re-sort the data using the last sort method the user selected (stored in the ViewData["sort"] variable)
if (sort == "course")
{
sortedRecords = records.OrderBy(r => r.CourseCodeNavigation.Title).ToArray();
}
else //from here down, updated for lab9
{
sortedRecords = records.OrderBy(r => r.Student.Name).ToArray();
}
if (HttpContext.Session.GetString("SortOrder") == null ||
HttpContext.Session.GetString("SortOrder") == "Descending")
{
HttpContext.Session.SetString("SortOrder", "Ascending");
}
else
{
HttpContext.Session.SetString("SortOrder", "Descending");
sortedRecords = sortedRecords.Reverse().ToArray();
}
return(View(sortedRecords));
}
public async Task <IActionResult> Create([Bind("CourseCode,StudentId,Grade")] AcademicRecord academicRecord)
{
var existing = _context.AcademicRecord.Where(a => a.CourseCode.Equals(academicRecord.CourseCode) && a.StudentId.Equals(academicRecord.StudentId)).FirstOrDefault();
ViewData["Error"] = "";
if (existing != null)
{
ViewData["Error"] = "The student already has an academic record for the course.";
}
else
{
if (ModelState.IsValid)
{
_context.Add(academicRecord);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
List <object> courses = new List <object>();
foreach (var course in _context.Course)
{
courses.Add(new
{
Code = course.Code,
Title = course.Code + " - " + course.Title
});
}
ViewData["CourseCode"] = new SelectList(courses, "Code", "Title");
List <object> students = new List <object>();
foreach (var student in _context.Student)
{
students.Add(new
{
Id = student.Id,
Name = student.Id + " - " + student.Name
});
}
ViewData["StudentId"] = new SelectList(students, "Id", "Name");
return(View(academicRecord));
}
public async Task <IActionResult> Create([Bind("CourseCode,StudentId,Grade")] AcademicRecord academicRecord)
{
if (ModelState.IsValid)
{
if (!AcademicRecordExists(academicRecord.StudentId, academicRecord.CourseCode))
{
_context.Add(academicRecord);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
else
{
ViewBag.ErrorStyle = "color:red; display:block";
}
}
SetCourseAndStudentViewData();
return(View(academicRecord));
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
var rolesSelected = _context.EmployeeRole.Where(e => e.EmployeeId == id).ToList();
_context.RemoveRange(rolesSelected);
var employee = await _context.Employee.FindAsync(id);
_context.Employee.Remove(employee);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create([Bind("CourseCode,StudentId,Grade")] AcademicRecord academicRecord)
{
// Check for duplicate records:
if ((from a in _context.AcademicRecord
where a.CourseCode.Equals(academicRecord.CourseCode) &&
a.StudentId.Equals(academicRecord.StudentId)
select a).FirstOrDefault() != null)
{ // Duplicate record exists
ViewData["Error"] = "Student already has an academic record for the course.";
}
else if (ModelState.IsValid)
{
_context.Add(academicRecord);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
// Include course titles and student names in drop down lists
populateCreateViewData();
return(View(academicRecord));
}
public async Task <IActionResult> Edit(int id, EmployeeRoleSelections employeeRoleSelections)
{
if (!employeeRoleSelections.roleSelections.Any(m => m.Selected))
{
ModelState.AddModelError("roleSelections", "You must select at least one role!");
}
if (ModelState.IsValid)
{
try
{
var allEmployeeRoles = _context.EmployeeRole.Where(e => e.EmployeeId == id).ToList();
if (allEmployeeRoles.Count > 0)
{
_context.RemoveRange(allEmployeeRoles);
}
foreach (RoleSelection roleSelection in employeeRoleSelections.roleSelections)
{
if (roleSelection.Selected)
{
_context.EmployeeRole.Add(new EmployeeRole {
EmployeeId = id, RoleId = roleSelection.role.Id
});
}
}
_context.Update(employeeRoleSelections.employee);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(RedirectToAction(nameof(Index)));
}
return(View(employeeRoleSelections));
}
public async Task <IActionResult> Create([Bind("CourseCode,StudentId,Grade")] AcademicRecord academicRecord)
{
var selectedAccount = (from account in _context.AcademicRecord where account.StudentId == academicRecord.StudentId && account.CourseCode == academicRecord.CourseCode select account).FirstOrDefault();
if (selectedAccount != null)
{
ModelState.AddModelError("", "The Student Already Exists Within The System.");
}
else
{
if (ModelState.IsValid)
{
_context.Add(academicRecord);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
List <object> courses = new List <object>();
foreach (Course course in _context.Course)
{
courses.Add(new { Code = course.Code, Title = course.Code + "-" + course.Title });
}
List <object> students = new List <object>();
foreach (Student student in _context.Student)
{
students.Add(new { Id = student.Id, Name = student.Id + "-" + student.Name });
}
ViewData["CourseCode"] = new SelectList(courses, "Code", "Title", academicRecord.CourseCode);
ViewData["StudentId"] = new SelectList(students, "Id", "Name", academicRecord.StudentId);
return(View(academicRecord));
}
