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)
{
// 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 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 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 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 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 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 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 Create([Bind(Include = "Id,Name,Description,Created,Updated")] Project project)
{
if (ModelState.IsValid)
{
project.Created = DateTime.Now;
db.Projects.Add(project);
db.SaveChanges();
projectHelper.AddUserToProject(User.Identity.GetUserId(), project.Id);
return(RedirectToAction("Index"));
}
return(View(project));
}
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 Create([Bind(Include = "Id,Title,Description,Created,Updated,ProjectId,TicketStatusId,TicketPriorityId,TicketTypeId,OwnerUserId,AssignedToUserId")] Ticket ticket)
{
if (ModelState.IsValid)
{
//add user to project when they create a ticket
ProjectsHelper phelper = new ProjectsHelper();
if (!phelper.IsUserOnProject(User.Identity.GetUserId(), ticket.ProjectId))
{
phelper.AddUserToProject(User.Identity.GetUserId(), ticket.ProjectId);
}
ticket.OwnerUserId = User.Identity.GetUserId();
ticket.TicketPriorityId = db.TicketPrioritys.FirstOrDefault(n => n.Name == "Low").Id;
//Give ticket initial status of "new"
ticket.TicketStatusId = 2;
ticket.Created = DateTimeOffset.Now;
db.Tickets.Add(ticket);
db.SaveChanges();
return(RedirectToAction("Details", "Projects", new { id = ticket.ProjectId }));
}
//Identity framework chooses the name of the database, which is "Users", but the actual class name is "ApplicationUser"
ViewBag.AssignedToUserId = new SelectList(db.Users, "Id", "FirstName", ticket.AssignedToUserId);
ViewBag.OwnerUserId = new SelectList(db.Users, "Id", "FirstName", ticket.OwnerUserId);
ViewBag.ProjectId = new SelectList(db.Projects, "Id", "Name", ticket.ProjectId);
ViewBag.TicketPriorityId = new SelectList(db.TicketPrioritys, "Id", "Name", ticket.TicketPriorityId);
ViewBag.TicketStatusId = new SelectList(db.TicketStatus, "Id", "Name", ticket.TicketStatusId);
ViewBag.TicketTypeId = new SelectList(db.TicketTypes, "Id", "Name", ticket.TicketTypeId);
return(View(ticket));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Description,TicketTypeId,TicketPriorityId,TicketStatusId,AssignedToUserId")] Ticket ticket, string developer)
{
var allDevelopers = rolesHelper.UsersInRole("Developer");
if (ModelState.IsValid)
{
var oldTicket = db.Tickets.AsNoTracking().FirstOrDefault(t => t.Id == ticket.Id);
var newTicket = db.Tickets.Find(ticket.Id);
newTicket.AssignedToUserId = developer;
newTicket.TicketTypeId = ticket.TicketTypeId;
newTicket.TicketPriorityId = ticket.TicketPriorityId;
newTicket.TicketStatusId = ticket.TicketStatusId;
newTicket.Description = ticket.Description;
newTicket.Updated = DateTime.Now;
db.SaveChanges();
projectHelper.AddUserToProject(newTicket.AssignedToUserId, newTicket.ProjectId);
ticketHelper.CreateChangeNotification(oldTicket, newTicket);
ticketHelper.CreateHistoryRecord(oldTicket, newTicket);
await ticketHelper.CreateAssignmentNotification(oldTicket, newTicket);
return(RedirectToAction("Details", "Tickets", new { Id = ticket.Id }));
}
ViewBag.Developers = new SelectList(allDevelopers, "Id", "FullName", ticket.AssignedToUserId);
ViewBag.TicketPriorityId = new SelectList(db.TicketPriorities, "Id", "Name", ticket.TicketPriorityId);
ViewBag.TicketStatusId = new SelectList(db.TicketStatuses, "Id", "Name", ticket.TicketStatusId);
ViewBag.TicketTypeId = new SelectList(db.TicketTypes, "Id", "Name", ticket.TicketTypeId);
return(View(ticket));
}
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 ManageProjectAssignments(List <string> developerSelectList, List <string> submitterSelectList, List <int> projectSelectList)
{
//Check to see if at least one user and one project have been selected
if ((developerSelectList == null && submitterSelectList == null) || projectSelectList == null)
{
TempData["Alert"] = "Please select at least one user and project";
return(RedirectToAction("ManageProjectAssignments"));
}
//Container variable to combine the two selectlists of users
var userIds = new List <string>();
//Check to see if developers were selected. If so, add to container variable.
if (developerSelectList != null)
{
userIds.AddRange(developerSelectList);
}
//Check to see if submitters were selected. If so, add to container variable.
if (submitterSelectList != null)
{
userIds.AddRange(submitterSelectList);
}
//Go through each users selected and add them to each project selected
foreach (var userId in userIds)
{
foreach (var projectId in projectSelectList)
{
projHelper.AddUserToProject(userId, projectId);
}
}
return(RedirectToAction("ManageProjectAssignments"));
}
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 ManageProjectAssignments(List <string> userIds, List <int> projectIds)
{
//if and only if I have chosen at least one person will I do the dollowing operations
if (userIds == null || projectIds == null)
{
return(RedirectToAction("ManageProjectAssignments"));
}
// I can simply add each ot the selected users to each of the selected projects
foreach (var userId in userIds)
{
foreach (var projectId in projectIds)
{
projHelper.AddUserToProject(userId, projectId);
}
}
return(RedirectToAction("ManageProjectAssignments"));
}
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 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 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 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 AssignProject(string UserId, int ProjectId)
{
if (helper.AddUserToProject(UserId, ProjectId))
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
public ActionResult AssignUserProject(string userId, int projectID)
{
projectHelper.AddUserToProject(userId, 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);
}
var project = db.Projects.Find(projectID);
//return RedirectToAction("ManageUsersAndProjects", usersInfo.ToList());
return(Json(new { Name = project.Name, Description = project.Description, Created = project.Created.ToString("MMM dd,yyyy"), projectID, userId }));
}
public ActionResult ManageProjectUsers(List <int> projects, string projectManagerId, List <string> developers, List <string> submitters)
{
//Remove users from every project I have selected
if (projects != null)
{
foreach (var projectId in projects)
{
//Remove everyone from This project
foreach (var user in projHelper.UsersOnProject(projectId).ToList())
{
projHelper.RemoveUserFromProject(user.Id, projectId);
}
//Add back a Pm if I can
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 ManageProjectLevelUsers(List <string> userIds, int projectId)
{
if (userIds != null)
{
//var projMembersIds = projHelper.UsersOnProject(projectId).Select(u => u.Id).ToList();
//foreach(var memberId in projMembersIds)
//{
// projHelper.RemoveUserFromProject(memberId, projectId);
//}
foreach (var userId in userIds)
{
if (!projHelper.IsUserOnProject(userId, projectId))
{
projHelper.AddUserToProject(userId, projectId);
if (rolesHelper.IsUserInRole(userId, "ProjectManager"))
{
var proj = db.Projects.Find(projectId);
proj.ProjectManagerId = userId;
db.SaveChanges();
}
}
else
{
projHelper.RemoveUserFromProject(userId, projectId);
if (rolesHelper.IsUserInRole(userId, "ProjectManager"))
{
var proj = db.Projects.Find(projectId);
proj.ProjectManagerId = null;
db.SaveChanges();
}
}
}
}
return(RedirectToAction("ManageProjectLevelUsers", new { id = projectId }));
}
public ActionResult ManageProjectUsers(int projectId, List <string> ProjectManagers, List <string> Developers, List <string> Submitters)
{
//Step 1. Remove all users from the incoming project
foreach (var user in projectHelper.UsersOnProject(projectId).ToList())
{
projectHelper.RemoveUserFromProject(user.Id, projectId);
}
//Step 2: Adds Back all the selected PM's
if (ProjectManagers != null)
{
foreach (var projectManagerId in ProjectManagers)
{
projectHelper.AddUserToProject(projectManagerId, projectId);
}
}
//Step 3: Adds back all the selected Developers
if (Developers != null)
{
foreach (var developerId in Developers)
{
projectHelper.AddUserToProject(developerId, projectId);
}
}
//Step4: Adds back all the selected Submitters
if (Submitters != null)
{
foreach (var submitterId in Submitters)
{
projectHelper.AddUserToProject(submitterId, projectId);
}
}
//Step 5: Redirect the user somewhere
return(RedirectToAction("Details", "Projects", new { id = projectId }));
}
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 ManageProjects(List <int> projects, string UserIds)
{
if (projects != null)
{
foreach (var projectId in projects)
{
if (!string.IsNullOrEmpty(UserIds))
{
projectsHelper.AddUserToProject(UserIds, projectId);
}
}
}
return(RedirectToAction("ManageProjects", "Admin"));
}
public ActionResult Edit([Bind(Include = "Id,Name")] Project project, List <string> Developers, List <string> Submitters, string ProjectManager)
{
if (ModelState.IsValid)
{
foreach (var user in projectHelper.UsersOnProject(project.Id).ToList())
{
projectHelper.RemoveUserFromProject(user.Id, project.Id);
}
if (Developers != null)
{
foreach (var userId in Developers)
{
projectHelper.AddUserToProject(userId, project.Id);
}
}
if (Submitters != null)
{
foreach (var userId in Submitters)
{
projectHelper.AddUserToProject(userId, project.Id);
}
}
if (ProjectManager != null)
{
projectHelper.AddUserToProject(ProjectManager, project.Id);
}
db.Entry(project).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(project));
}
public ActionResult AssignProjectUsers(List <string> userIds, List <int> projectIds)
{
if (userIds != null && projectIds != null)
{
foreach (var userId in userIds)
{
foreach (var projectId in projectIds)
{
notificationHelper.ProjectAssignmentNotification(projectId, userId);
projHelper.AddUserToProject(userId, projectId);
}
}
}
return(RedirectToAction("AssignProjectUsers"));
}
