public ActionResult UserIndex(string userId, string CurrentRole, List <int> CurrentProjects)
{
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
if (!string.IsNullOrEmpty(CurrentRole))
{
roleHelper.AddUserToRole(userId, CurrentRole);
}
foreach (var proj in projectHelper.ListUserProjects(userId))
{
projectHelper.RemoveUserFromProject(userId, proj.Id);
}
if (CurrentProjects != null)
{
foreach (var projectId in CurrentProjects)
{
projectHelper.AddUserToProject(userId, projectId);
}
}
////return RedirectToAction("EditProfile","Members", new { userId = userId });
return(RedirectToAction("Manage", "Members", new { userId = userId }));
}
public ActionResult Edit([Bind(Include = "UserId,RolesToSelect")] AdminUserViewModel admModel)
{
var user = db.Users.Find(admModel.UserId);
var id = admModel.UserId;
var allRoles = new List <string>();
UserRolesHelper helper = new UserRolesHelper();
allRoles.Add("Submitter");
allRoles.Add("Developer");
allRoles.Add("Project Manager");
allRoles.Add("Admin");
//build a list of selected roles based on the array in the model that was returned
var selectedRoles = new List <string>();
for (int i = 0; i < admModel.RolesToSelect.Length; i++)
{
if (admModel.RolesToSelect[i].Checked == true)
{
selectedRoles.Add(admModel.RolesToSelect[i].RoleName);
}
}
//if no roles have been selected, remove user from all roles
if (selectedRoles == null)
{
foreach (var rRole in allRoles)
{
if (helper.IsUserInRole(admModel.UserId, rRole))
{
helper.RemoveUserFromRole(admModel.UserId, rRole);
}
}
return(RedirectToAction("Index"));
}
else
{
foreach (var sRole in selectedRoles)
{
if (!helper.IsUserInRole(admModel.UserId, sRole))
{
helper.AddUserToRole(admModel.UserId, sRole);
}
}
var rolesToRemove = allRoles.Except(selectedRoles);
foreach (var rRole in rolesToRemove)
{
if (helper.IsUserInRole(admModel.UserId, rRole))
{
helper.RemoveUserFromRole(admModel.UserId, rRole);
}
}
return(RedirectToAction("Index"));
}
}
public ActionResult ManageUserRoles(string userId, string userRole)
{
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
if (!string.IsNullOrEmpty(userRole))
{
roleHelper.AddUserToRole(userId, userRole);
}
return(RedirectToAction("UserIndex"));
}
public ActionResult ManageUserRole(string userId, string userRole)
{
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
//if the incoming role selection is NOT NULL I want to assign the user to the selected role
if (!string.IsNullOrEmpty(userRole))
{
roleHelper.AddUserToRole(userId, userRole);
}
return(RedirectToAction("UserIndex"));
}
public ActionResult Details([Bind(Include = "SelectedRoles,RolesList")] UserRolesViewModel model)
{
if (ModelState.IsValid)
{
var user = (ApplicationUser)TempData["CurrentUser"];
var userRoles = helper.ListUserRoles(user.Id);
//DELETE current Roles)
foreach (var roleName in userRoles)
{
helper.RemoveUserFromRole(user.Id, roleName);
}
//ADD the whole list of new Roles)
if (model.SelectedRoles != null)
{
foreach (var roleName in model.SelectedRoles)
{
helper.AddUserToRole(user.Id, roleName);
}
}
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
public ActionResult ManageUserRole(string userId, string UserRole)
{
//user UserRolesHelper class
//remove user from all roles
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
//if incoming role is not null, assign to role
if (!string.IsNullOrEmpty(UserRole))
{
roleHelper.AddUserToRole(userId, UserRole);
}
return(RedirectToAction("UserIndex"));
}
public ActionResult AssignRoles(string id, List <string> userRoles)
{
//Unassign the user from all roles
var user = db.Users.Find(id);
if (user.Protected == true)
{
ViewBag.AdminError = "Can't change protected user.";
return(View(user));
}
else
{
foreach (var role in userHelper.ListUserRoles(id))
{
if (role != "Admin")
{
userHelper.RemoveUserFromRole(id, role);
}
else if ((role == "Admin" && userHelper.UsersInRole("Admin").Count > 1) || (userRoles != null && userRoles.Contains("Admin")))
{
userHelper.RemoveUserFromRole(id, role);
}
else
{
ViewBag.AdminError = "Can't remove Admin without adding another first.";
return(View(user));
}
}
if (userRoles != null)
{
//Assign user to selected roles
foreach (var role in userRoles)
{
userHelper.AddUserToRole(id, role);
}
}
}
return(RedirectToAction("Index"));
}
public ActionResult ManageRoles(List <string> users, string roleName)
{
if (users != null)
{
//Lets iterate over the incoming list of users that were selected from the form
// and remove each of them from whatever role they occupy
foreach (var userId in users)
{
//Remove them from any role they occupy
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
if (!string.IsNullOrEmpty(roleName))
{
roleHelper.AddUserToRole(userId, roleName); //call the 'AddUserToRole' method from the 'helper' object and pass it the userid
//and the specified 'role'.
}
}
}
return(RedirectToAction("ManageRoles"));
}
public ActionResult Details([Bind(Include = "SelectedProjects,ProjectsList,SelectedRoles,RolesList")] UserAssignmentsViewModel model) // Work on Both Assignments
{
if (ModelState.IsValid)
{
var user = (ApplicationUser)TempData["CurrentUser"];
// Work on Project Assignments
var userProjects = projecthelper.ListProjectsForUser(user.Id);
//DELETE current Projects)
foreach (var project in userProjects)
{
projecthelper.RemoveUserFromProject(user.Id, project.Id);
}
//ADD the whole list of new Projects)
if (model.SelectedProjects != null)
{
foreach (var projectid in model.SelectedProjects)
{
int projectId = Convert.ToInt32(projectid);
projecthelper.AddUserToProject(user.Id, projectId);
}
}
// Work on Role Assignments
// Only Admin Role can edit Role Assignments
if (User.IsInRole("Admin"))
{
var userRoles = rolehelper.ListUserRoles(user.Id);
//DELETE current Roles)
foreach (var roleName in userRoles)
{
rolehelper.RemoveUserFromRole(user.Id, roleName);
}
//ADD the whole list of new Roles)
if (model.SelectedRoles != null)
{
foreach (var roleName in model.SelectedRoles)
{
rolehelper.AddUserToRole(user.Id, roleName);
}
}
}
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,FirstName, LastName, Email, DisplayName,AvatarPath,EmailConfirmed,PhoneNumber,PhoneNumberConfirmed")] ApplicationUser applicationUser, string roles)
{
if (ModelState.IsValid)
{
//1st get list of roles user occupies
var currentRoles = roleHelper.ListUserRoles(applicationUser.Id);
foreach (var role in currentRoles)
{
//Removes users from all and any role they occupy
roleHelper.RemoveUserFromRole(applicationUser.Id, role);
}
if (!string.IsNullOrEmpty(roles))
{
roleHelper.AddUserToRole(applicationUser.Id, roles);
}
//db.Entry(applicationUser).State = EntityState.Modified;
db.Users.Attach(applicationUser);
applicationUser.UserName = applicationUser.Email;
// times 7 for the properties that are subject to change, this allows for only for the ones to be changed instead of losing the information
db.Entry(applicationUser).Property(x => x.FirstName).IsModified = true;
db.Entry(applicationUser).Property(x => x.LastName).IsModified = true;
db.Entry(applicationUser).Property(x => x.AvatarPath).IsModified = true;
db.Entry(applicationUser).Property(x => x.Email).IsModified = true;
db.Entry(applicationUser).Property(x => x.PhoneNumber).IsModified = true;
db.Entry(applicationUser).Property(x => x.UserName).IsModified = true;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(applicationUser));
}
public ActionResult Edit([Bind(Include = "Id,FirstName,LastName,DisplayName,Email")] ApplicationUser applicationUser, string Roles, List <int> Projects)
{
if (ModelState.IsValid)
{
applicationUser.UserName = applicationUser.Email;
//Assign the user to the selected role
//Determine if the user currently occupies a role and if so remove them from it
if (User.IsInRole("Admin"))
{
foreach (var role in rolesHelper.ListUserRoles(applicationUser.Id))
{
rolesHelper.RemoveUserFromRole(applicationUser.Id, role);
}
//Add them to the selected role
if (Roles != null)
{
rolesHelper.AddUserToRole(applicationUser.Id, Roles);
}
}
//Remove user from all projects
foreach (var project in projHelper.ListUserProjects(applicationUser.Id))
{
projHelper.RemoveUserFromProject(applicationUser.Id, project.Id);
}
//Add them to the selected projects
if (Projects != null)
{
foreach (var projectId in Projects)
{
projHelper.AddUserToProject(applicationUser.Id, projectId);
}
}
//Because we have removed several fields from the User Edit Form, we have to tell the SQL that only a few specific properties are eligible for modification
//db.Entry(applicationUser).State = EntityState.Modified; <-- This tells SQL that ALL properties are eligible for modification
db.Users.Attach(applicationUser);
db.Entry(applicationUser).Property(x => x.FirstName).IsModified = true;
db.Entry(applicationUser).Property(x => x.LastName).IsModified = true;
db.Entry(applicationUser).Property(x => x.DisplayName).IsModified = true;
db.Entry(applicationUser).Property(x => x.Email).IsModified = true;
db.Entry(applicationUser).Property(x => x.UserName).IsModified = true;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(applicationUser));
}
public ActionResult ManageRoles(AdminRoleModel model)
{
var y = db.Users.Find(model.Id);
foreach (var item in db.Roles.Select(r => r.Name).ToList())
{
roleHelper.RemoveUserFromRole(y.Id, item);
}
foreach (var item in model.selectedRoles)
{
roleHelper.AddUserToRole(y.Id, item);
}
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,FirstName,LastName,Email,PhoneNumber,Picture,DisplayName")] ApplicationUser applicationUser, HttpPostedFileBase image, string Roles, List <int> Projects)
{
if (ModelState.IsValid)
{
if (ImageUploadValidator.IsWebFriendlyImage(image))
{
var fileName = Path.GetFileName(image.FileName);
image.SaveAs(Path.Combine(Server.MapPath("~/Images/"), fileName));
applicationUser.Picture = "/Images/" + fileName;
}
applicationUser.UserName = applicationUser.Email;
//Assign the user to the selected role
//Determine if the user currently occupies a role, and if so remove them form it
foreach (var role in rolesHelper.ListUserRoles(applicationUser.Id))
{
rolesHelper.RemoveUserFromRole(applicationUser.Id, role);
}
if (Roles != null)
{
rolesHelper.AddUserToRole(applicationUser.Id, Roles);
}
//Add user to the new selected role
foreach (var proj in projectHelper.ListUserProjects(applicationUser.Id))
{
projectHelper.RemoveUserFromProject(applicationUser.Id, proj.Id);
}
if (Projects != null)
{
foreach (var projectId in Projects)
{
projectHelper.AddUserToProject(applicationUser.Id, projectId);
}
}
//db.Entry(applicationUser).State = EntityState.Unchanged;
db.Users.Attach(applicationUser);
db.Entry(applicationUser).Property(p => p.FirstName).IsModified = true;
db.Entry(applicationUser).Property(p => p.LastName).IsModified = true;
db.Entry(applicationUser).Property(p => p.Email).IsModified = true;
db.Entry(applicationUser).Property(p => p.PhoneNumber).IsModified = true;
db.Entry(applicationUser).Property(p => p.DisplayName).IsModified = true;
db.Entry(applicationUser).Property(p => p.UserName).IsModified = true;
db.Entry(applicationUser).Property(p => p.Picture).IsModified = true;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(applicationUser));
}
public ActionResult RolesAssigned(string userId, List <string> Roles)
{
var roleHelp = new UserRolesHelper();
foreach (var role in db.Roles)
{
var name = role.Name;
roleHelp.RemoveUserFromRole(userId, name);
}
foreach (var role in Roles)
{
var list = roleHelp.AddUserToRole(userId, role);
}
return(RedirectToAction("ListRoles", "Admin"));
}
public ActionResult ManageRoles(UserRolesViewModel model)
{
var user = db.Users.Find(model.Id);
foreach (var rolemv in db.Roles.Select(r => r.Name).ToList())
{
helper.RemoveUserFromRole(user.Id, rolemv);
}
foreach (var rolemv in model.SelectedRoles)
{
helper.AddUserToRole(user.Id, rolemv);
}
ViewBag.confirm = "User's role has been modified";
return(RedirectToAction("Index"));
}
public ActionResult Edit(AdminViewRolesModel model)
{
var user = db.Users.Find(model.User.Id);
UserRolesHelper helper = new UserRolesHelper();
foreach (var rolermv in db.Roles.Select(r => r.Name).ToList())
{
helper.RemoveUserFromRole(user.Id, rolermv);
}
foreach (var roleadd in model.SelectedRoles)
{
helper.AddUserToRole(user.Id, roleadd);
}
return(RedirectToAction("Index"));
}
public ActionResult DRemoveFromRole(ListViewModel selectedUser, string RoleName)
{
var nHelper = new UserNotificationsHelper();
ViewBag.Notifications = nHelper.filterNotifications(User.Identity.GetUserId());
var Helper = new UserRolesHelper();
foreach (var id in selectedUser.SelectedroleUsers)
{
if (id != null)
{
Helper.RemoveUserFromRole(id, RoleName);
}
}
List <SelectListItem> listadminUsers = new List <SelectListItem>();
List <SelectListItem> listnonadminUsers = new List <SelectListItem>();
var result1 = Helper.UsersInRole(RoleName);
foreach (var user in result1)
{
SelectListItem selectList = new SelectListItem()
{
Text = user.DispalyName,
Value = user.Id
};
listadminUsers.Add(selectList);
}
var result2 = Helper.UsersNotInRole(RoleName);
foreach (var user in result2)
{
SelectListItem selectList = new SelectListItem()
{
Text = user.DispalyName,
Value = user.Id
};
listnonadminUsers.Add(selectList);
}
ListViewModel adminLViewModel = new ListViewModel()
{
zUsers = listadminUsers,
otherUsers = listnonadminUsers
};
return(View("Developer", adminLViewModel));
}
public ActionResult RemoveRole(string RemoveId, List <string> SelectedCurrentRoles)
{
if (ModelState.IsValid)
{
UserRolesHelper helper = new UserRolesHelper(db);
var user = db.Users.Find(RemoveId);
foreach (var role in SelectedCurrentRoles)
{
helper.RemoveUserFromRole(RemoveId, role);
}
db.Entry(user).State = EntityState.Modified;
db.Users.Attach(user);
db.SaveChanges();
return(RedirectToAction("ListUsers"));
}
return(View(RemoveId));
}
public ActionResult AssignRole(string users, string roles)
{
if (ModelState.IsValid)
{
var currentUser = db.Users.Find(users).Id;
var currentRoles = roleHelper.ListUserRoles(users);
foreach (var role in currentRoles)
{
//Removes users from all and any role they occupy
roleHelper.RemoveUserFromRole(currentUser, role);
}
if (!string.IsNullOrEmpty(roles))
{
roleHelper.AddUserToRole(currentUser, roles);
}
}
return(RedirectToAction("Index", "Users"));
}
public ActionResult EditUserRoles(AdminUserViewModels model)
{
var user = db.Users.Find(model.User.Id);
UserRolesHelper helper = new UserRolesHelper();
foreach (var role in db.Roles.Select(r => r.Name).ToList())
{
helper.RemoveUserFromRole(user.Id, role);
}
if (model.AssignedRoles != null)
{
foreach (var role in model.AssignedRoles)
{
helper.AddUserToRole(user.Id, role);
}
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index"));
}
public ActionResult EditUser([Bind(Include = "User,Roles,SelectedRoles")] AdminUserViewModel model)
{
var user = db.Users.Find(model.User.Id);
UserRolesHelper helper = new UserRolesHelper();
foreach (var role in db.Roles.Select(r => r.Name).ToList())
{
if (helper.IsUserInRole(user.Id, role))
{
helper.RemoveUserFromRole(user.Id, role);
}
}
foreach (var roleadd in model.SelectedRoles)
{
if (!helper.IsUserInRole(user.Id, roleadd))
{
helper.AddUserToRole(user.Id, roleadd);
}
}
return(RedirectToAction("AdminIndex"));
}
public ActionResult EditUser(AdminUserViewModel model, string id)
{
UserRolesHelper helper = new UserRolesHelper(db);
foreach (var role in model.SelectedRoles)
{
if (!helper.IsUserInRole(model.Id, role))
{
helper.AddUserToRole(model.Id, role);
}
}
foreach (var role in db.Roles.ToList())
{
if (!model.SelectedRoles.Contains(role.Name))
{
helper.RemoveUserFromRole(model.Id, role.Name);
}
}
db.SaveChanges();
return(RedirectToAction("UserIndex", "Admin", model));
}
public ActionResult ManageRoles(List <string> usersIds, string role)
{
if (usersIds != null)
{
foreach (var userId in usersIds)
{
var userRole = roleHelper.ListUserRoles(userId).FirstOrDefault();
if (userRole != null)
{
roleHelper.RemoveUserFromRole(userId, userRole);
}
}
if (!string.IsNullOrEmpty(role))
{
foreach (var userId in usersIds)
{
roleHelper.AddUserToRole(userId, role);
}
}
}
return(RedirectToAction("ManageRoles", "Admin"));
}
public ActionResult ManageRoles(List <string> userIds, string roleName)
{
//Useing roleHElper to assign their role
if (userIds != null)
{
//remove role from users
foreach (var userId in userIds)
{
var userRole = rolesHelper.ListUserRoles(userId).FirstOrDefault();
if (!string.IsNullOrEmpty(userRole))
{
rolesHelper.RemoveUserFromRole(userId, userRole);
}
//add new role to user
if (!string.IsNullOrEmpty(roleName))
{
rolesHelper.AddUserToRole(userId, roleName);
}
}
}
return(RedirectToAction("ManageRoles"));
}
