public async Task <IActionResult> Delete(string id)
{
CourseHelperUser user = await userManager.FindByIdAsync(id);
if (user != null)
{
//Deletes Student class linked to account
Student student = studentDB.Students.First(s => s.StudentNumber == user.StudentNumber);
if (student != null)
{
studentDB.DeleteStudent(student.StudentId);
}
//Deletes Account
IdentityResult result = await userManager.DeleteAsync(user);
if (result.Succeeded)
{
TempData["successMessage"] = $"Account {user.UserName} successfully deleted.";
return(RedirectToAction(nameof(List)));
}
else
{
AddErrorsFromResult(result);
}
}
else
{
TempData["errorMessage"] = $"Account not found.";
}
return(View("List", userManager.Users));
}
public async Task <IActionResult> Login(LoginModel model, string returnURL)
{
if (ModelState.IsValid)
{
CourseHelperUser user = await userManager.FindByNameAsync(model.UserName);
if (user != null)
{
await signInManager.SignOutAsync();
Microsoft.AspNetCore.Identity.SignInResult result = await signInManager.PasswordSignInAsync(user, model.Password, false, false);
if (result.Succeeded)
{
TempData["successMessage"] = $"Successfully logged in.";
string indexUrl = "/";
if (await userManager.IsInRoleAsync(user, "Admin"))
{
indexUrl = "/Admin";
}
else if (await userManager.IsInRoleAsync(user, "Faculty"))
{
indexUrl = "/Faculty";
}
else if (await userManager.IsInRoleAsync(user, "Student"))
{
indexUrl = "/Student";
}
return(Redirect(returnURL ?? indexUrl));
}
}
TempData["errorMessage"] = $"Invalid user or password.";
}
return(View(model));
}
public async Task <IActionResult> ChangePassword(string id, string oldPassword, string newPassword)
{
CourseHelperUser user = await userManager.FindByIdAsync(id);
if (user != null)
{
IdentityResult changePass = await userManager.ChangePasswordAsync(user, oldPassword, newPassword);
if (changePass.Succeeded)
{
TempData["successMessage"] = $"Password successfully changed.";
if (HttpContext.User.IsInRole("Admin"))
{
return(RedirectToAction("Index", "Account"));
}
else if (HttpContext.User.IsInRole("Faculty"))
{
return(RedirectToAction("Index", "Faculty"));
}
else
{
return(RedirectToAction("Index", "Student"));
}
}
else
{
AddErrorsFromResult(changePass);
}
}
else
{
TempData["errorMessage"] = $"Account not found.";
}
return(View("ChangePassword", id));
}
public async Task <IActionResult> ChangePassword(string id)
{
CourseHelperUser user = await userManager.FindByIdAsync(id);
if (user != null)
{
return(View("ChangePassword", id));
}
else
{
TempData["errorMessage"] = $"Account not found.";
if (HttpContext.User.IsInRole("Admin"))
{
return(RedirectToAction("Index", "Account"));
}
else if (HttpContext.User.IsInRole("Faculty"))
{
return(RedirectToAction("Index", "Faculty"));
}
else
{
return(RedirectToAction("Index", "Student"));
}
}
}
public async Task <IActionResult> Edit(string id, string firstName, string lastName,
string password)
{
CourseHelperUser user = await userManager.FindByIdAsync(id);
if (user != null)
{
IdentityResult validPass = null;
if (!string.IsNullOrEmpty(password))
{
validPass = await passwordValidator.ValidateAsync(userManager,
user, password);
if (validPass.Succeeded)
{
user.PasswordHash = passwordHasher.HashPassword(user,
password);
}
else
{
AddErrorsFromResult(validPass);
}
}
if (!string.IsNullOrEmpty(firstName))
{
user.FirstName = firstName;
user.LastName = lastName;
}
if (validPass == null || (password != string.Empty && validPass.Succeeded))
{
IdentityResult result = await userManager.UpdateAsync(user);
if (result.Succeeded)
{
Student student = studentDB.Students.First(s => s.StudentNumber == user.StudentNumber);
if (student != null)
{
student.FirstName = user.FirstName;
student.LastName = user.LastName;
studentDB.SaveStudent(student);
}
TempData["successMessage"] = $"Account {user.UserName} successfully updated.";
return(RedirectToAction("List"));
}
else
{
AddErrorsFromResult(result);
}
}
}
else
{
TempData["errorMessage"] = $"Account not found.";
}
return(View(user));
}
public static async void Populate(IApplicationBuilder app)
{
AppIdentityDBContext context = app.ApplicationServices.GetRequiredService <AppIdentityDBContext>();
context.Database.EnsureCreated();
UserManager <CourseHelperUser> userManager = app.ApplicationServices.GetRequiredService <UserManager <CourseHelperUser> >();
RoleManager <IdentityRole> roleManager = app.ApplicationServices.GetRequiredService <RoleManager <IdentityRole> >();
IdentityRole adminRole = await roleManager.FindByNameAsync("Admin");
IdentityRole facultyRole = await roleManager.FindByNameAsync("Faculty");
IdentityRole studentRole = await roleManager.FindByNameAsync("Student");
if (adminRole == null)
{
await roleManager.CreateAsync(new IdentityRole("Admin"));
}
if (facultyRole == null)
{
await roleManager.CreateAsync(new IdentityRole("Faculty"));
}
if (studentRole == null)
{
await roleManager.CreateAsync(new IdentityRole("Student"));
}
CourseHelperUser userAdmin = await userManager.FindByNameAsync("admin");
if (userAdmin == null)
{
userAdmin = new CourseHelperUser()
{
UserName = "******"
};
await userManager.CreateAsync(userAdmin, "password");
await userManager.AddToRoleAsync(userAdmin, "Admin");
await userManager.AddToRoleAsync(userAdmin, "Faculty");
}
CourseHelperUser userFaculty = await userManager.FindByNameAsync("faculty");
if (userFaculty == null)
{
userFaculty = new CourseHelperUser()
{
UserName = "******"
};
await userManager.CreateAsync(userFaculty, "password");
await userManager.AddToRoleAsync(userFaculty, "Faculty");
}
}
public async Task <IActionResult> ChangePassword(string id)
{
CourseHelperUser user = await userManager.FindByIdAsync(id);
if (user != null)
{
return(View(user));
}
else
{
TempData["errorMessage"] = $"Account not found.";
return(RedirectToAction("List"));
}
}
public async Task <IActionResult> Create(UserModel userModel)
{
if (ModelState.IsValid)
{
if (HttpContext.User.IsInRole("Admin") && userModel.Role == 1)
{
CourseHelperUser facultyUser = new CourseHelperUser
{
FirstName = userModel.FirstName,
LastName = userModel.LastName,
UserName = userModel.UserName
};
IdentityResult facultyResult = await userManager.CreateAsync(facultyUser, userModel.Password);
if (facultyResult.Succeeded)
{
await userManager.AddToRoleAsync(facultyUser, "Faculty");
TempData["successMessage"] = $"Faculty {facultyUser.UserName} successfully created.";
return(RedirectToAction(nameof(List)));
}
else
{
foreach (IdentityError error in facultyResult.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
else
{
//gets the largest(last) student number in database, and adds 1 (generates unique studentnumber)
long studentNumber = studentDB.Students.OrderBy(s => s.StudentNumber).Last().StudentNumber + 1;
CourseHelperUser studentUser = new CourseHelperUser
{
FirstName = userModel.FirstName,
LastName = userModel.LastName,
UserName = userModel.UserName,
StudentNumber = studentNumber
};
IdentityResult studentResult = await userManager.CreateAsync(studentUser, userModel.Password);
if (studentResult.Succeeded)
{
Student student = new Student()
{
StudentId = 0,
FirstName = userModel.FirstName,
LastName = userModel.LastName,
StudentNumber = studentNumber,
Semester = 1,
Status = STUDENT_STATUS.UNPAID,
IsRegistered = false
};
studentDB.SaveStudent(student);
await userManager.AddToRoleAsync(studentUser, "Student");
TempData["successMessage"] = $"Student {studentUser.UserName} successfully created.";
return(RedirectToAction(nameof(Login)));
}
else
{
foreach (IdentityError error in studentResult.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
}
return(View(userModel));
}
public async Task <IActionResult> Settings()
{
CourseHelperUser user = await userManager.GetUserAsync(HttpContext.User);
return(View("Settings", user.Id));
}
private async Task <Student> getLoggedInStudent()
{
CourseHelperUser loggedInUser = await userManager.GetUserAsync(HttpContext.User);
return(studentDB.Students.First(s => s.StudentNumber == loggedInUser.StudentNumber));
}
