public async Task <ActionResult> Create([Bind(Include = "Id,Name,Greeting,Created")] Household household)
{
if (ModelState.IsValid)
{
var userId = User.Identity.GetUserId();
var user = db.Users.Find(userId);
//unassign
foreach (var userRole in roleHelper.ListUserRole(userId))
{
roleHelper.RemoveUserFromRole(userId, userRole);
}
//assign
roleHelper.AddUserToRole(userId, "HouseholdOwner");
household.Created = DateTime.Now;
db.Households.Add(household);
//gives new household ID
user.HouseholdId = household.Id;
db.SaveChanges();
//log out and back in to update
await HttpContext.RefreshAuthentication(user);
return(RedirectToAction("Index", "Home"));
}
return(View(household));
}
public ActionResult UserIndex(string userId, string roleName)
{
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
if (!string.IsNullOrEmpty(roleName))
{
roleHelper.AddUserToRole(userId, roleName);
}
return(RedirectToAction("UserIndex"));
}
public ActionResult ManageSingleRole(string userId, string userRole)
{
//remove user from any role they have assigned already
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
//if userRole is not null, assign them the role selected
if (!string.IsNullOrEmpty(userRole))
{
roleHelper.AddUserToRole(userId, userRole);
}
return(RedirectToAction("UserIndex"));
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserRoleHelper.AddUserToRole(user.Id, model.Role);
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return RedirectToAction("Index", "Manage");
}
AddErrors(result);
}
ViewBag.Role = new SelectList(db.Roles, "Name", "Name");
// If we got this far, something failed, redisplay form
return View(model);
}
public ActionResult ManageRoles(List <string> userIds, string roleName)
{
// Use our RoleHelper to actually assign the role to the person or persons selected
if (userIds != null)
{
foreach (var userId in userIds)
{
// First I need to determine what Role if any the user is in
var userRole = userRoleHelper.ListUserRoles(userId).FirstOrDefault();
if (!string.IsNullOrEmpty(userRole))
{
// Second I have to remove each of the selected users from their current Role
userRoleHelper.RemoveUserFromRole(userId, userRole);
}
if (!string.IsNullOrEmpty(roleName))
{
// Then I will add each selected user to the selected Role
userRoleHelper.AddUserToRole(userId, roleName);
}
}
}
return(RedirectToAction("ManageRoles"));
}
// Leave Household
public async Task <ActionResult> LeaveAsync()
{
var userId = User.Identity.GetUserId();
var myRole = roleHelper.ListUserRoles(userId).FirstOrDefault();
var user = db.Users.Find(userId);
switch (myRole)
{
case "Owner":
var members = db.Users.Where(u => u.HouseholdId == user.HouseholdId).Count() - 1;
if (members >= 1)
{
TempData["Message"] = $"You are unable to leave the Household! There are still <b>{members}</b> other members in the house, you must select one of them to assume your role.";
return(RedirectToAction("ExitDenied"));
}
user.Household.IsDeleted = true;
user.HouseholdId = null;
db.Users.Remove(user);
db.SaveChanges();
roleHelper.RemoveUserFromRole(userId, "Owner");
roleHelper.AddUserToRole(userId, "NewUser");
await HttpContextBaseExtension.RefreshAuthentication(HttpContext, user);
return(RedirectToAction("Dashboard", "Households"));
case "Member":
default:
// Removing all user's data from the database
// This method doesn't allow for the user to maintain their data
//db.Users.Remove(user);
//db.SaveChanges();
roleHelper.RemoveUserFromRole(userId, "Member");
roleHelper.AddUserToRole(userId, "NewUser");
await HttpContextBaseExtension.RefreshAuthentication(HttpContext, user);
return(RedirectToAction("Login", "Account"));
}
}
public ActionResult ManageUserRole(string id, string roleName)
{
foreach (var role in roleHelper.ListUserRoles(id))
{
roleHelper.RemoveUserFromRole(id, role);
}
if (!string.IsNullOrEmpty(roleName))
{
roleHelper.AddUserToRole(id, roleName);
}
return(RedirectToAction("Index", new { id }));
}
public ActionResult EditUser([Bind(Include = "User, Roles, SelectedRoles")] AdminUserViewModel model)
{
var userId = model.User.Id;
UserRoleHelper helper = new UserRoleHelper();
foreach (var rolermv in db.Roles.Select(r => r.Name).ToList())
{
helper.RemoveUserFromRole(userId, rolermv);
}
foreach (var roleadd in model.SelectedRoles)
{
helper.AddUserToRole(userId, roleadd);
}
return(RedirectToAction("Index"));
}
public ActionResult Create([Bind(Include = "Name")] Household household)
{
if (ModelState.IsValid)
{
db.Households.Add(household);
db.SaveChanges();
var headOfHouseHold = User.Identity.GetUserId();
HouseholdsHelper.AddUserToHousehold(headOfHouseHold, household.Id);
UserRoleHelper.AddUserToRole(headOfHouseHold, "HeadOfHouseHold");
household.HouseholdCreatorId = headOfHouseHold;
household.Created = DateTimeOffset.Now;
return(RedirectToAction("Details", "Households"));
}
return(View(household));
}
public ActionResult ManageRoles(List <string> userIds, string roleName)
{
if (userIds == null)
{
return(RedirectToAction("RolesIndex"));
}
foreach (var userId in userIds)
{
foreach (var roleList in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, roleList);
}
if (!string.IsNullOrEmpty(roleName))
{
roleHelper.AddUserToRole(userId, roleName);
}
}
return(RedirectToAction("ManageRoles"));
}
public ActionResult ManageUser(ManageUserVM userVM, string roleName, string projects)
{
List <Project> oldProjects = projectHelper.ListUserProjects(userVM.UserId).ToList();
var oldUser = db.Users.AsNoTracking().FirstOrDefault(u => u.Id == userVM.UserId);
var user = db.Users.Find(userVM.UserId);
user.Email = userVM.Email;
user.UserName = userVM.Email;
user.FirstName = userVM.FirstName;
user.LastName = userVM.LastName;
user.PhoneNumber = userVM.PhoneNumber;
user.AvatarPath = userVM.AvatarPath;
if (FileUploadValidator.IsWebFriendlyImage(userVM.Avatar))
{
var fileName = FileStamp.MakeUnique(userVM.Avatar.FileName);
var serverFolder = WebConfigurationManager.AppSettings["DefaultAvatarFolder"];
userVM.Avatar.SaveAs(Path.Combine(Server.MapPath(serverFolder), fileName));
user.AvatarPath = $"{serverFolder}{fileName}";
}
db.SaveChanges();
projectHelper.updateUserProjects(userVM.UserId, userVM.ProjectIds);
if (roleName != null)
{
foreach (var role in roleHelper.ListUserRoles(user.Id))
{
roleHelper.RemoveUserFromRole(user.Id, role);
}
if (!string.IsNullOrEmpty(roleName))
{
roleHelper.AddUserToRole(user.Id, roleName);
}
}
var newUser = db.Users.AsNoTracking().FirstOrDefault(u => u.Id == userVM.UserId);
historyHelper.CheckUserEdits(oldUser, newUser, oldProjects);
return(RedirectToAction("Index"));
}
public ActionResult EditUserRoles(AdminUserViewModel model)
{
var user = db.Users.Find(model.User.Id);
UserRoleHelper helper = new UserRoleHelper();
foreach (var role in db.Roles.Select(r => r.Name).ToList())
{
helper.RemoveUserFromRole(user.Id, role);
}
if (model.SelectedRoles != null)
{
foreach (var role in model.SelectedRoles)
{
helper.AddUserToRole(user.Id, role);
}
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index"));
}
public ActionResult ManageRoles(List <string> userIds, string roleName)
{
//Step:1 If anyone was selected, remove them from all of their roles.
//If people were selected, Spin through them and strip them of their roles
foreach (var userId in userIds)
{
//Determine if this user occupies a role.
foreach (var role in roleHelper.ListUserRoles(userId).ToList())
{
roleHelper.RemoveUserFromRole(userId, role);
}
//If a role was seleceted add the user back to it.
//Step 2: If a role was chosen, Add each person to that role.
if (!string.IsNullOrEmpty(roleName))
{
roleHelper.AddUserToRole(userId, roleName);
}
}
return(RedirectToAction("ManageRoles"));
}
public ActionResult LeaveHousehold()
{
var userId = User.Identity.GetUserId();
if (User.IsInRole("HeadOfHouseHold"))
{
var householdId = db.Users.Find(userId).HouseholdId;
UserRoleHelper.RemoveUserFromRole(userId, "HeadOfHousehold");
HouseholdsHelper.RemoveUserFromHousehold(userId);
var members = db.Users.Where(u => u.HouseholdId == householdId).ToList();
var roleHelper = new UserRoleHelper();
foreach (var member in members)
{
if (roleHelper.IsUserInRole(member.Id, "Member"))
{
UserRoleHelper.RemoveUserFromRole(member.Id, "Member");
UserRoleHelper.AddUserToRole(member.Id, "HeadOfHousehold");
break;
}
}
return(RedirectToAction("ProfileView", "Account"));
}
else
{
UserRoleHelper.RemoveUserFromRole(userId, "Member");
HouseholdsHelper.RemoveUserFromHousehold(userId);
Household household = db.Households.Find(userId);
if (household.Users.Count == 0)
{
household.Deleted = true;
}
return(RedirectToAction("ProfileView", "Account"));
}
}
public async Task <ActionResult> RegisterFromInvite(RegisterFromInviteViewModel model, HttpPostedFileBase image, Guid Code)
{
if (ModelState.IsValid)
{
var errorMsg = new StringBuilder();
var invite = db.Invitations.FirstOrDefault(i => i.Code == model.Code);
if (invite == null)
{
errorMsg.Append("You have not been invited.");
}
else
{
if (DateTime.Now > invite.Expires)
{
errorMsg.Append("Invitation Expired.");
}
if (model.Code != invite.Code)
{
errorMsg.Append("InvalidCode.");
}
if (invite.Accepted)
{
errorMsg.Append("Invitation already accepted");
}
}
var result = new IdentityResult();
if (errorMsg.ToString() == string.Empty)
{
var user = new ApplicationUser
{
FirstName = model.FirstName,
LastName = model.LastName,
UserName = model.Email,
Email = model.Email,
HouseholdId = invite.HouseholdId
};
if (UserHelper.IsWebFriendlyImage(image))
{
var fileName = Path.GetFileName(image.FileName);
image.SaveAs(Path.Combine(Server.MapPath("~/Uploads/"), fileName));
user.ProfileImagePath = "/Uploads/" + fileName;
}
result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
db.Invitations.Attach(invite);
invite.Accepted = true;
invite.AcceptedTime = DateTime.Now;
invite.IsValid = false;
db.SaveChanges();
UserRoleHelper.AddUserToRole(user.Id, "Member");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("ProfileView", "Account"));
}
}
else
{
TempData["ErrorMsg"] = errorMsg.ToString();
return(RedirectToAction("Details", "Households", new { id = invite.HouseholdId }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> CreateNewUser(CreateNewUserViewModel model, List <int> AllProjects, string RoleName)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
AvatarPath = WebConfigurationManager.AppSettings["DefaultAvatarPath"],
PhoneNumber = model.PhoneNumber
};
if (model.Avatar != null)
{
if (FileUploadValidator.IsWebFriendlyImage(model.Avatar))
{
var fileName = FileStamp.MakeUnique(model.Avatar.FileName);
var serverFolder = WebConfigurationManager.AppSettings["DefaultAvatarFolder"];
model.Avatar.SaveAs(Path.Combine(Server.MapPath(serverFolder), fileName));
user.AvatarPath = $"{serverFolder}{fileName}";
}
}
var result = await UserManager.CreateAsync(user, Membership.GeneratePassword(12, 1));
if (result.Succeeded)
{
roleHelper.AddUserToRole(user.Id, RoleName);
foreach (var projectId in AllProjects)
{
projectHelper.AddUserToProject(user.Id, projectId);
}
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
try
{
var from = "BugTracker Admin<*****@*****.**>";
var email = new MailMessage(from, model.Email)
{
Subject = "Confirm Your Account",
Body = "Please confirm your account by Clicking here <a href=\"" + callbackUrl + "\">here</a> ",
IsBodyHtml = true
};
var svc = new EmailService();
await svc.SendAsync(email);
//return View(new EmailModel());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
await Task.FromResult(0);
}
//await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Login", "Account"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
ViewBag.AllProjects = new MultiSelectList(db.Projects.ToList(), "Id", "Name");
ViewBag.RoleName = new SelectList(db.Roles, "Name", "Name", "Default");
return(View(model));
}
public ActionResult AssignRole(string id, AssignRoleViewModel formData)
{
var admin = "Admin";
var dev = "Developer";
var pjm = "Project Manager";
var sub = "Submitter";
var checkIfAdmin = UserRoleHelper.IsUserInRole(id, admin);
var checkIfDev = UserRoleHelper.IsUserInRole(id, dev);
var checkIfPm = UserRoleHelper.IsUserInRole(id, pjm);
var checkIfSub = UserRoleHelper.IsUserInRole(id, sub);
if (formData.User.IsAdmin)
{
if (!checkIfAdmin)
{
UserRoleHelper.AddUserToRole(id, admin);
}
}
else
{
if (checkIfAdmin)
{
UserRoleHelper.RemoveUserFromRole(id, admin);
}
}
if (formData.User.IsDev)
{
if (!checkIfDev)
{
UserRoleHelper.AddUserToRole(id, dev);
}
}
else
{
if (checkIfDev)
{
UserRoleHelper.RemoveUserFromRole(id, dev);
}
}
if (formData.User.IsPm)
{
if (!checkIfPm)
{
UserRoleHelper.AddUserToRole(id, pjm);
}
}
else
{
if (checkIfPm)
{
UserRoleHelper.RemoveUserFromRole(id, pjm);
}
}
if (formData.User.IsSub)
{
if (!checkIfSub)
{
UserRoleHelper.AddUserToRole(id, sub);
}
}
else
{
if (checkIfSub)
{
UserRoleHelper.RemoveUserFromRole(id, sub);
}
}
var allUsers = DbContext.Users.Select(n => new UserForAssignRoleViewModel
{
Id = n.Id,
UserName = n.UserName
}).ToList();
var roles = DbContext.Roles.Select(n => n.Name).ToList();
foreach (var p in allUsers)
{
p.IsAdmin = UserRoleHelper.IsUserInRole(p.Id, admin);
p.IsDev = UserRoleHelper.IsUserInRole(p.Id, dev);
p.IsPm = UserRoleHelper.IsUserInRole(p.Id, pjm);
p.IsSub = UserRoleHelper.IsUserInRole(p.Id, sub);
p.DisplayIsAdmin = (p.IsAdmin) ? "fas fa-check" : "fas fa-times";
p.DisplayIsDev = (p.IsDev) ? "fas fa-check" : "fas fa-times";
p.DisplayIsPm = (p.IsPm) ? "fas fa-check" : "fas fa-times";
p.DisplayIsSub = (p.IsSub) ? "fas fa-check" : "fas fa-times";
}
var model = new AssignRoleManagementViewModel();
model.Users.AddRange(allUsers);
model.Roles.AddRange(roles);
return(View("AssignRoleManagement", model));
}
