public ActionResult UserIndex(string userId, string CurrentRole, List <int> CurrentProjects)
{
// Remove user from whatever role they currently occupy
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
if (!string.IsNullOrEmpty(CurrentRole))
{
// Then add them back to the selected role
roleHelper.AddUserToRole(userId, CurrentRole);
}
if (CurrentProjects != null)
{
// Remove user from whatever projects they currently occupy
foreach (var project in projectHelper.ListUserProjects(userId))
{
projectHelper.RemoveUserFromProject(userId, project.Id);
}
// Then add them back to the selected role
foreach (var project in CurrentProjects)
{
projectHelper.AddUserToProject(userId, project);
}
}
return(RedirectToAction("UserIndex"));
}
public ActionResult ManageUserProjects(List <int> projects, string userId)
{
//First let's remove the user from all projects
foreach (var project in projectHelper.ListUserProjects(userId).ToList())
{
projectHelper.RemoveUserFromProject(userId, project.Id);
foreach (var ticket in project.Tickets)
{
if (ticket.AssignedToUserId == userId)
{
ticket.AssignedToUserId = null;
ticket.TicketStatusId = db.TicketStatuses.FirstOrDefault(s => s.Name == "New/Unassigned")?.Id ?? 1;
}
}
}
//Then if the incoming list is not null we will reassign them.
if (projects != null)
{
foreach (var projectId in projects)
{
projectHelper.AddUserToProject(userId, projectId);
}
}
return(RedirectToAction("Index", "Projects"));
}
public ActionResult ManageProjectAssignments(List <string> userIds, List <int> projectIds, bool addUser)
{
if (userIds != null || projectIds != null)
{
if (addUser)
{
foreach (var userId in userIds)
{
foreach (var projectId in projectIds)
{
projHelper.RemoveUserFromProject(userId, projectId);
}
}
foreach (var userId in userIds)
{
foreach (var projectId in projectIds)
{
projHelper.AddUserToProject(userId, projectId);
}
}
}
else
{
foreach (var userId in userIds)
{
foreach (var projectId in projectIds)
{
projHelper.RemoveUserFromProject(userId, projectId);
}
}
}
}
return(RedirectToAction("ManageProjectAssignments"));
}
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 AssignUsers(int projectId, string projectManagerId, List <string> submitterIds, List <string> developerIds)
{
if (User.IsInRole("Admin"))
{
//Dealing with Project Managers
//Remove the current PM and then add the selected PM
var project = db.Projects.Find(projectId);
project.ProjectManagerId = projectManagerId;
db.SaveChanges();
}
else
{
#region Handle Submitters Project association
//Remove all Submitters on the Project
foreach (var user in assignHelper.UsersOnProjectInRole(projectId, "Submitter"))
{
projHelper.RemoveUserFromProject(user.Id, projectId);
}
//Add back all the selected Submitters
if (submitterIds != null)
{
foreach (var submitterid in submitterIds)
{
projHelper.AddUserToProject(submitterid, projectId);
}
}
#endregion
#region Handle Developer Project association
//Add back all the selected Developers
foreach (var user in assignHelper.UsersOnProjectInRole(projectId, "Developer"))
{
projHelper.RemoveUserFromProject(user.Id, projectId);
}
//Add back all the selected Submitters
if (developerIds != null)
{
foreach (var developerId in developerIds)
{
projHelper.AddUserToProject(developerId, projectId);
}
}
#endregion
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult ManageUserProjects(List <int> projects, string userId)
{
foreach (var project in projectHelper.ListUserProjects(userId).ToList())
{
projectHelper.RemoveUserFromProject(userId, project.Id);
}
if (projects != null)
{
foreach (var projectId in projects)
{
projectHelper.AddUserToProject(userId, projectId);
}
}
return(RedirectToAction("UserIndex"));
}
public ActionResult UnassignProjectManager(ProjectUsersView model)
{
if (ModelState.IsValid)
{
if (model.SelectedUsers != null)
{
foreach (string userId in model.SelectedUsers)
{
helper.RemoveUserFromProject(userId, model.ProjectId);
}
return(RedirectToAction("Index", "ProjectManager"));
}
}
return(View(model));
}
public ActionResult ManageUsers(int projectId, string projectManagerId, List <string> developers, List <string> submitters)
{
foreach (var user in projHelper.UsersOnProject(projectId).ToList())
{
projHelper.RemoveUserFromProject(user.Id, projectId);
}
//In order to ensure that I always have the correct and current set of assign users
//I will first remove all users from the project and then I will add back the selected users
if (!string.IsNullOrEmpty(projectManagerId))
{
projHelper.AddUserToProject(projectManagerId, projectId);
}
if (developers != null)
{
foreach (var developerId in developers)
{
projHelper.AddUserToProject(developerId, projectId);
}
}
if (submitters != null)
{
foreach (var submitterId in submitters)
{
projHelper.AddUserToProject(submitterId, projectId);
}
}
return(RedirectToAction("ManageUsers", new { id = projectId }));
}
public ActionResult ManageUsers(int projectId, string projectManagerId, List <string> developers, List <string> submitters)
{
foreach (var user in projectHelper.UsersOnProject(projectId).ToList())
{
projectHelper.RemoveUserFromProject(user.Id, projectId);
}
if (!string.IsNullOrEmpty(projectManagerId))
{
projectHelper.AddUserToProject(projectManagerId, projectId);
}
if (developers != null)
{
foreach (var developerId in developers)
{
projectHelper.AddUserToProject(developerId, projectId);
}
}
if (submitters != null)
{
foreach (var submitterId in submitters)
{
projectHelper.AddUserToProject(submitterId, projectId);
}
}
return(RedirectToAction("ManageUsers", new { id = projectId }));
}
public ActionResult ManageProjects(string userId, int Userproject)
{
foreach (var project in projectHelper.ListUserProjects(userId))
{
projectHelper.RemoveUserFromProject(userId, project.Id);
}
if (Userproject > 0)
{
projectHelper.AddUserToProject(userId, Userproject);
}
return(RedirectToAction("UserIndex"));
}
public ActionResult RemoveUser(string id, int projectID)
{
projectHelper.RemoveUserFromProject(id, projectID);
ViewBag.ProjecstIds = new MultiSelectList(db.Projects, "Id", "Name");
var usersInfo = new List <IndexUsersViewModel>();
var allUsers = db.Users.ToList();
foreach (var user in allUsers)
{
var userInfo = new IndexUsersViewModel();
userInfo.User = user;
userInfo.Projects = projectHelper.ListUserProjects(user.Id);
userInfo.role = roleHelper.ListUserRoles(user.Id);
usersInfo.Add(userInfo);
}
return(View("ManageUsersAndProjects", usersInfo.ToList()));
}
public ActionResult ManageProjectUsers(List <int> projects, string projectManagerId, List <string> developers, List <string> submitters, string demoProjectManagerId, List <string> demoDevelopers, List <string> demoSubmitters)
{
// remove users from selected projects
if (projects != null && !userRolesHelper.IsDemoUser(User.Identity.GetUserId()))
{
foreach (var projectId in projects)
{
// remove from this project
foreach (var user in projectsHelper.UsersOnProject(projectId).ToList())
{
projectsHelper.RemoveUserFromProject(user.Id, projectId);
}
// add a PM back to projects if possible
if (!string.IsNullOrEmpty(projectManagerId))
{
projectsHelper.AddPMToProject(projectManagerId, projectId);
}
if (developers != null)
{
foreach (var developerId in developers)
{
projectsHelper.AddUserToProject(developerId, projectId);
}
}
if (submitters != null)
{
foreach (var submitterId in submitters)
{
projectsHelper.AddUserToProject(submitterId, projectId);
}
}
// demo users
if (!string.IsNullOrEmpty(demoProjectManagerId))
{
projectsHelper.AddUserToProject(demoProjectManagerId, projectId);
}
if (demoDevelopers != null)
{
foreach (var demoDeveloperId in demoDevelopers)
{
projectsHelper.AddUserToProject(demoDeveloperId, projectId);
}
}
if (demoSubmitters != null)
{
foreach (var demoSubmitterId in demoSubmitters)
{
projectsHelper.AddUserToProject(demoSubmitterId, projectId);
}
}
}
}
return(RedirectToAction("ManageProjectUsers"));
}
public ActionResult ManageUserProjects(List <int> projects, string userId)
{
//First lets remove the user from all projects
foreach (var project in projectHelper.ListUserProjects(userId).ToList())
{
projectHelper.RemoveUserFromProject(userId, project.Id);
}
//Then if the incoming list is not null we will reassign them to all that are selected
if (projects != null)
{
foreach (var projectId in projects)
{
projectHelper.AddUserToProject(userId, projectId);
}
}
return(RedirectToAction("UserIndex"));
}
public ActionResult RemoveUserFromProject(string userId, int projectId)
{
//checks if user is in appropriate role.
if (User.IsInRole("Admin") || User.IsInRole("ProjectManager"))
{
projHelper.RemoveUserFromProject(userId, projectId);
return(RedirectToAction("ManageProjectAssignments"));
}
TempData["Alert"] = "You are not authorized to change user assignments";
return(RedirectToAction("Index", "Projects"));
}
public ActionResult Edit([Bind(Include = "Id,Name,Description,Created")] Project project, List <string> users)
{
if (ModelState.IsValid)
{
foreach (var user in db.Users)
{
projHelper.RemoveUserFromProject(user.Id, project.Id);
}
// Then add them back to the selected role
foreach (var user in users)
{
projHelper.AddUserToProject(user, project.Id);
}
project.Updated = DateTimeOffset.Now;
db.Entry(project).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(project));
}
public ActionResult RemoveProject(string userId, int projectId)
{
if (helper.RemoveUserFromProject(userId, projectId))
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
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 ManageProjectAssignments(string userId, int projectId, bool addUser)
{
if (userId != null && projectId > 0)
{
if (addUser)
{
projectsHelper.AddUserToProject(userId, projectId);
}
else
{
projectsHelper.RemoveUserFromProject(userId, projectId);
}
}
return(RedirectToAction("ManageProjectAssignments"));
}
public ActionResult RemoveProjectUsers(List <string> userIds, List <int> projectIds)
{
if (userIds != null && projectIds != null)
{
foreach (var userId in userIds)
{
foreach (var projectId in projectIds)
{
notificationHelper.RemovedProjectNotification(projectId, userId);
projHelper.RemoveUserFromProject(userId, projectId);
}
}
}
return(RedirectToAction("AssignProjectUsers"));
}
public ActionResult Details(string userId, List <int> UserProject)
{
foreach (var project in projectHelper.ListUserProjects(userId))
{
projectHelper.RemoveUserFromProject(userId, project.Id);
}
if (UserProject != null)
{
foreach (var projectId in UserProject)
{
projectHelper.AddUserToProject(userId, projectId);
}
}
return(RedirectToAction("UserIndex", "Admin"));
}
public ActionResult ManageProjects(List <string> userIds, int project, string projectManager)
{
foreach (var user in db.Users)
{
projectsHelper.RemoveUserFromProject(user.Id, project);
}
foreach (var userId in userIds)
{
projectsHelper.AddUserToProject(userId, project);
}
projectsHelper.AddPMToProject(projectManager, project);
return(RedirectToAction("ManageProjects", "Admin"));
}
public ActionResult Edit([Bind(Include = "Id,Name,Description")] Project project, List <string> projectManagers, List <string> projectDevelopers, List <string> projectSubmitters)
{
//var pUsers = projectManagers.Union(projectDevelopers);
//var addProjectUsersIds = pUsers.Union(projectSubmitters);
var oldProjectUsers = projectsHelper.UsersOnProject(project.Id).ToList();
//var projectUsers = project.ProjectUsers.ToList();
if (ModelState.IsValid)
{
foreach (var user in oldProjectUsers)
{
projectsHelper.RemoveUserFromProject(user.Id, project.Id);
}
if (projectManagers != null && projectManagers.Count > 0)
{
foreach (var userId in projectManagers)
{
projectsHelper.AddUserToProject(userId, project.Id);
}
}
if (projectDevelopers != null && projectDevelopers.Count > 0)
{
foreach (var userId in projectDevelopers)
{
projectsHelper.AddUserToProject(userId, project.Id);
}
}
if (projectSubmitters != null && projectSubmitters.Count > 0)
{
foreach (var userId in projectSubmitters)
{
projectsHelper.AddUserToProject(userId, project.Id);
}
}
db.Entry(project).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(project));
}
public ActionResult ProjectAssign(string UserId, List <int> AllProjects)
{
//First use the Project helper to remove this user from all Project
foreach (var project in projectHelper.ListUserProjects(UserId))
{
projectHelper.RemoveUserFromProject(UserId, project.Id);
}
//Next add the user to the selected Projects (AllProject)
if (AllProjects != null)
{
foreach (var projectId in AllProjects)
{
projectHelper.AddUserToProject(UserId, projectId);
}
}
return(RedirectToAction("UserIndex"));
}
public ActionResult ProjectAssignment(int projects, List <string> users)
{
//Remove any and all current role assignment
var projectUsers = projectsHelper.ListUsersOnProject(projects);
if (projectUsers.Count > 0)
{
foreach (var user in projectUsers.ToList())
{
projectsHelper.RemoveUserFromProject(user.Id, projects);
}
}
foreach (var userId in users)
{
projectsHelper.AddUserToProject(userId, projects);
}
return(RedirectToAction("Index", "Projects"));
}
public ActionResult ProjectAssign(string userId, List <int> AllProjects)
{
//Remove user from all projects
foreach (var proj in projHelper.ListUserProjects(userId))
{
projHelper.RemoveUserFromProject(userId, proj.Id);//need to specify Id here because passing in entire project in foreach loop
}
//Add user to projects
if (AllProjects != null)
{
foreach (var projId in AllProjects) //already using Id's here for variable projId so don't need to denote proj.Id below
{
projHelper.AddUserToProject(userId, projId);
}
}
return(RedirectToAction("UserIndex"));
}
public ActionResult ManageProjectLevelUsers(List <string> userIds, int projectId)
{
var projMemberIds = projHelper.UsersOnProject(projectId).Select(u => u.Id).ToList();
foreach (var memberId in projMemberIds)
{
projHelper.RemoveUserFromProject(memberId, projectId);
}
if (userIds != null)
{
foreach (var userId in userIds)
{
projHelper.AddUserToProject(userId, projectId);
}
}
return(RedirectToAction("ManageProjectLevelUsers", new { id = projectId }));
}
public ActionResult ManageProjectUsers(List <int> projects, string adminId, string projectManagerId, List <string> developers, List <string> submitters)
{
if (projects != null)
{
foreach (var projectId in projects)
{
foreach (var user in projHelper.UsersOnProject(projectId).ToList())
{
projHelper.RemoveUserFromProject(user.Id, projectId);
}
if (!string.IsNullOrEmpty(adminId))
{
projHelper.AddUserToProject(adminId, projectId);
}
if (!string.IsNullOrEmpty(projectManagerId))
{
projHelper.AddUserToProject(projectManagerId, projectId);
}
if (developers != null)
{
foreach (var developerId in developers)
{
projHelper.AddUserToProject(developerId, projectId);
}
}
if (submitters != null)
{
foreach (var submitterId in submitters)
{
projHelper.AddUserToProject(submitterId, projectId);
}
}
}
}
return(RedirectToAction("ManageProjectUsers"));
}
public ActionResult Edit([Bind(Include = "Id,FirstName,LastName,Email,PhoneNumber")] ApplicationUser applicationUser, string Roles, List <int> Projects)
{
if (ModelState.IsValid)
{
applicationUser.UserName = applicationUser.Email;
foreach (var role in roleHelp.ListUserRoles(applicationUser.Id))
{
roleHelp.RemoveUserFromRole(applicationUser.Id, role);
}
if (Roles != null)
{
roleHelp.AddUserToRole(applicationUser.Id, Roles);
}
foreach (var project in proj.ListUserProjects(applicationUser.Id))
{
proj.RemoveUserFromProject(applicationUser.Id, project.ID);
}
if (Projects != null)
{
foreach (var projectID in Projects)
{
proj.AddUserToProject(applicationUser.Id, projectID);
}
}
db.Users.Attach(applicationUser);
db.Entry(applicationUser).Property(a => a.FirstName).IsModified = true;
db.Entry(applicationUser).Property(a => a.LastName).IsModified = true;
db.Entry(applicationUser).Property(a => a.PhoneNumber).IsModified = true;
db.Entry(applicationUser).Property(a => a.Email).IsModified = true;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(applicationUser));
}
public ActionResult Edit([Bind(Include = "Id,Name,Description,Created,Updated")] Project project, List <string> AllUsers)
{
if (ModelState.IsValid)
{
foreach (var user in projectHelper.UsersOnProject(project.Id).ToList())
{
projectHelper.RemoveUserFromProject(user.Id, project.Id);
}
foreach (var userId in AllUsers)
{
projectHelper.AddUserToProject(userId, project.Id);
}
db.Entry(project).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(project));
}
public PartialViewResult AddUsers(int id, List <string> SelectedUsers)
{
ProjectsHelper helper = new ProjectsHelper();
var prj = db.Projects.Find(id);
foreach (var usr in prj.Users)
{
helper.RemoveUserFromProject(usr.Id, id);
}
foreach (var dev in SelectedUsers)
{
helper.AddUserToProject(dev, prj.Id);
}
ProjectsHelper phelper = new ProjectsHelper();
ProjectDetailViewModel model = new ProjectDetailViewModel();
model.Developers = phelper.ProjectUsersByRole(id, "Submitter");
model.Submitters = phelper.ProjectUsersByRole(id, "Developer");
return(PartialView("_TeamMembers", model));
}
