public async Task <IActionResult> Login(LoginViewModel model)
{
if (ModelState.IsValid)
{
EasyTagUser user = await userManager.FindByNameAsync(model.Name);
if (user == null)
{
user = await userManager.FindByEmailAsync(model.Name);
}
if (user != null)
{
if ((await signInManager.PasswordSignInAsync(user, model.Password, false, false)).Succeeded)
{
if (model.ReturnUrl == "/Account/AccessDenied" || String.IsNullOrEmpty(model.ReturnUrl) ||
model.ReturnUrl.Contains("Login"))
{
return(Redirect("/"));
}
return(RedirectToAction(nameof(ReturnToPage), new { returnUrl = model.ReturnUrl }));
}
}
}
ModelState.AddModelError("", "Invalid username or password");
return(View(model));
}
public async Task <IActionResult> ChangePassword(CreateUserViewModel model)
{
EasyTagUser tagUser = await userManager.FindByIdAsync(model.Id);
if (tagUser != null)
{
if (String.IsNullOrEmpty(model.OldPassword))
{
ModelState.AddModelError("OldPassword", "Please type your current password!");
return(View(nameof(Edit), model));
}
if (String.IsNullOrEmpty(model.Password))
{
ModelState.AddModelError("Password", "Please type a valid password!");
}
if (String.IsNullOrEmpty(model.RepeatPass))
{
ModelState.AddModelError("RepeatPass", "Please repeat the new password!");
}
if (model.Password != model.RepeatPass)
{
ModelState.AddModelError("", "Password does not match!!");
}
var correctPasswordResult = userManager.PasswordHasher.VerifyHashedPassword(tagUser, tagUser.PasswordHash, model.OldPassword);
if (correctPasswordResult == PasswordVerificationResult.Failed)
{
ModelState.AddModelError("", "Incorrect Password!");
}
if (ModelState.IsValid)
{
if (model.OldPassword != model.Password)
{
var changePasswordResult = await userManager.ChangePasswordAsync(tagUser, model.OldPassword, model.Password);
if (!changePasswordResult.Succeeded)
{
AddErrorsFromResult(changePasswordResult);
}
else
{
return(RedirectToAction(nameof(Edit), new { id = tagUser.Id, returnUrl = model.ReturnUrl, message = "success" }));
}
}
}
}
return(View(nameof(Edit), model));
}
public async Task <IActionResult> Edit(string id, string returnUrl, string message = "")
{
// Validate permission to edit
if (viewContext.HttpContext.IsAccessibleForUserOrAdmin(id))
{
EasyTagUser tagUser = await userManager.FindByIdAsync(id);
// Admin user cannot be changed
if (tagUser.UserName != UserRoles.Admin.ToString())
{
if (tagUser != null)
{
CreateUserViewModel user = new CreateUserViewModel
{
Email = tagUser.Email,
UserName = tagUser.UserName,
PhoneNumber = tagUser.PhoneNumber,
Role = tagUser.Role,
Id = tagUser.Id,
FirstName = tagUser.FirstName,
LastName = tagUser.LastName,
Editing = true
};
if (!String.IsNullOrEmpty(returnUrl))
{
user.ReturnUrl = HttpUtility.UrlDecode(returnUrl);
}
if (message == "success")
{
TempData["PasswordChanged"] = $"Password changed successfully!";
}
return(View(user));
}
else
{
ModelState.AddModelError("", "User not found!!");
}
// return a list of users except Admin
return(View(nameof(ManageUsers), await userManager.Users.Where(u => u.UserName != UserRoles.Admin.ToString()).ToListAsync()));
}
}
return(Redirect("/"));
}
public async Task <IActionResult> AddAppointment(string code, DateTime selectedTime)
{
// Protection to avoid add appointments out of the time range
if (selectedTime.Date.Date > DateTime.Today ||
(selectedTime.Date == DateTime.Today.Date &&
DateTime.Now.TimeOfDay < (DateTime.Today + 22.5.Hours()).TimeOfDay))
{
Room room = await roomRepository.Rooms.FirstOrDefaultAsync(r => r.RoomCode == code);
if (room != null)
{
// Find logged user and add the name as default for an appointmnt
EasyTagUser tagUser = await userManager.FindByNameAsync(HttpContext.GetLoggedUserName());
return(View(new Appointment {
UserName = tagUser.FullName, RoomCode = code, RoomId = room.Id, ScheduleId = room.Schedule.Id, Start = selectedTime, End = selectedTime + 30.Minutes()
}));
}
}
return(Redirect("/"));
}
public async Task <IActionResult> ChangePasswordAdmin(CreateUserViewModel model)
{
EasyTagUser tagUser = await userManager.FindByIdAsync(model.Id);
if (tagUser != null)
{
if (String.IsNullOrEmpty(model.Password))
{
ModelState.AddModelError("Password", "Please type a valid password!");
}
if (String.IsNullOrEmpty(model.RepeatPass))
{
ModelState.AddModelError("RepeatPass", "Please repeat the new password!");
}
if (model.Password != model.RepeatPass)
{
ModelState.AddModelError("", "Password does not match!!");
}
if (ModelState.IsValid)
{
TempData["PasswordFlagSuccess"] = "Success";
var token = await userManager.GeneratePasswordResetTokenAsync(tagUser);
var changePasswordResult = await userManager.ResetPasswordAsync(tagUser, token, model.Password);
if (!changePasswordResult.Succeeded)
{
TempData["PasswordFlagSuccess"] = null;
AddErrorsFromResult(changePasswordResult);
}
else
{
return(RedirectToAction(nameof(Edit), new { id = tagUser.Id, returnUrl = model.ReturnUrl, message = "success" }));
}
}
}
return(View(nameof(Edit), model));
}
public async Task <IActionResult> Delete(string id)
{
EasyTagUser user = await userManager.FindByNameAsync(id);
if (user != null)
{
IdentityResult result = await userManager.DeleteAsync(user);
if (result.Succeeded)
{
return(RedirectToAction(nameof(ManageUsers)));
}
else
{
AddErrorsFromResult(result);
}
}
else
{
ModelState.AddModelError("", "User not found!");
}
return(RedirectToAction(nameof(ManageUsers)));
}
public async Task <IActionResult> Create(CreateUserViewModel model)
{
if (model.Password != model.RepeatPass)
{
ModelState.AddModelError("", "Password does not match!!");
}
ValidateFields(model);
if (ModelState.IsValid)
{
EasyTagUser user = new EasyTagUser
{
UserName = model.UserName,
Email = model.Email.ToLower(),
PhoneNumber = model.PhoneNumber,
Role = model.Role,
FirstName = model.FirstName,
LastName = model.LastName
};
IdentityResult result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, model.Role.ToString());
return(RedirectToAction(nameof(ManageUsers)));
}
else
{
AddErrorsFromResult(result);
}
}
return(View(model));
}
public static async void EnsurePopulated(IApplicationBuilder app)
{
// Get context object for Identity Database and run the migrations scripts
ETIdentityDbContext context = app.ApplicationServices.GetRequiredService <ETIdentityDbContext>();
context.Database.Migrate();
// Executed is the identity database is empty
if (!(context.UserRoles.Any() && context.Users.Any()))
{
//Admin Data
string adminUser = "******";
string adminPass = "******";
string adminRoleName = nameof(UserRoles.Admin);
//Manager Data
string professorUser = "******";
string profPass = "******";
string professorRoleName = nameof(UserRoles.Professor);
//RoleManager declaration
RoleManager <IdentityRole> roleManager = app.ApplicationServices
.GetRequiredService <RoleManager <IdentityRole> >();
//Admin Role
IdentityRole adminRole = await roleManager.FindByNameAsync(adminRoleName);
if (adminRole == null)
{
adminRole = new IdentityRole(adminRoleName);
await roleManager.CreateAsync(adminRole);
}
//Professor Role
IdentityRole professorRole = await roleManager.FindByNameAsync(professorRoleName);
if (professorRole == null)
{
professorRole = new IdentityRole(professorRoleName);
await roleManager.CreateAsync(professorRole);
}
//UserManager Declaration
UserManager <EasyTagUser> userManager = app.ApplicationServices
.GetRequiredService <UserManager <EasyTagUser> >();
//Admin User
EasyTagUser admin = await userManager.FindByIdAsync(adminUser);
if (admin == null)
{
admin = new EasyTagUser(adminUser)
{
Role = UserRoles.Admin,
Email = "*****@*****.**",
PhoneNumber = "1111111111",
FirstName = "Admin",
LastName = "Root"
};
await userManager.CreateAsync(admin, adminPass);
await userManager.AddToRoleAsync(admin, adminRoleName);
}
else
{
if (!(await userManager.IsInRoleAsync(admin, adminRoleName)))
{
await userManager.AddToRoleAsync(admin, adminRoleName);
}
}
//Manager User
EasyTagUser professor = await userManager.FindByIdAsync(professorUser);
if (professor == null)
{
professor = new EasyTagUser(professorUser)
{
Role = UserRoles.Professor,
Email = "*****@*****.**",
PhoneNumber = "123456790",
FirstName = "Eduardo",
LastName = "Sanchez"
};
await userManager.CreateAsync(professor, profPass);
await userManager.AddToRoleAsync(professor, professorRoleName);
}
else
{
if (!(await userManager.IsInRoleAsync(professor, professorRoleName)))
{
await userManager.AddToRoleAsync(professor, professorRoleName);
}
}
}
}
public async Task <IActionResult> Edit(CreateUserViewModel model)
{
ValidateFields(model);
if (ModelState.IsValid)
{
// Edit only if user exists
EasyTagUser tagUser = await userManager.FindByIdAsync(model.Id);
if (tagUser != null)
{
// Only admin can change roles
if (viewContext.HttpContext.User.IsInRole(UserRoles.Admin.ToString()))
{
// Update only if role changes
if (tagUser.Role != model.Role)
{
// Identify old role
UserRoles?oldRole = tagUser.Role;
// Remove from old role
await userManager.RemoveFromRoleAsync(tagUser, oldRole.ToString());
// Assign new role
tagUser.Role = model.Role;
var changeRoleResult = await userManager.AddToRoleAsync(tagUser, model.Role.ToString());
if (!changeRoleResult.Succeeded)
{
// recover old role if new assignment fails
tagUser.Role = oldRole;
ModelState.AddModelError("", $"Unexpected error occurred setting role for user with ID {tagUser.Id}");
AddErrorsFromResult(changeRoleResult);
}
}
}
// Update only if email changes
if (tagUser.Email != model.Email)
{
var changeEmailResult = await userManager.SetEmailAsync(tagUser, model.Email.ToLower());
if (!changeEmailResult.Succeeded)
{
ModelState.AddModelError("", $"Unexpected error occurred setting email for user with ID {tagUser.Id}");
AddErrorsFromResult(changeEmailResult);
}
}
// Update only if phone number changes
if (tagUser.PhoneNumber != model.PhoneNumber)
{
var changePhoneNumberResult = await userManager.SetPhoneNumberAsync(tagUser, model.PhoneNumber);
if (!changePhoneNumberResult.Succeeded)
{
ModelState.AddModelError("", $"Unexpected error occurred setting phone number for user with ID {tagUser.Id}");
AddErrorsFromResult(changePhoneNumberResult);
}
}
// Update only if user name changes
if (tagUser.UserName != model.UserName)
{
var changeUserNameResult = await userManager.SetUserNameAsync(tagUser, model.UserName);
if (!changeUserNameResult.Succeeded)
{
ModelState.AddModelError("", $"Unexpected error occurred setting user name for user with ID {tagUser.Id}");
AddErrorsFromResult(changeUserNameResult);
}
}
// Update only if first name changes
if (tagUser.FirstName != model.FirstName)
{
tagUser.FirstName = model.FirstName;
}
// Update only if last name changes
if (tagUser.LastName != model.LastName)
{
tagUser.LastName = model.LastName;
}
// Update user values
var updateResult = await userManager.UpdateAsync(tagUser);
if (!updateResult.Succeeded)
{
ModelState.AddModelError("", $"Unexpected error occurred updating user with ID {tagUser.Id}");
AddErrorsFromResult(updateResult);
}
}
else
{
ModelState.AddModelError("", "User not found!");
return(View(model));
}
if (ModelState.IsValid)
{
if (!String.IsNullOrEmpty(model.ReturnUrl))
{
return(Redirect(HttpUtility.UrlDecode(model.ReturnUrl)));
}
return(RedirectToAction(nameof(ManageUsers)));
}
}
return(View(model));
}
