示例#1
0
        public ActionResult Index()
        {
            List <UsersRolesViewModel> userList = new List <UsersRolesViewModel>();

            //foreach (var user in db.Users.ToList())
            foreach (var user in (helper.UsersInRole("BugtrackerUser")))
            {
                var currentRoles = helper.ListUserRoles(user.Id);
                if (!currentRoles.Contains("Submitter"))
                {
                    helper.AddUserToRole(user.Id, "Submitter");
                    db.SaveChanges();
                }

                UsersRolesViewModel uservm = new UsersRolesViewModel();
                uservm.User      = user;
                uservm.Roles     = helper.ListUserRoles(user.Id);
                uservm.Projectsb = pHelper.ListProjectsForAUser(user.Id);
                uservm.Tickets   = new List <Ticket>();
                foreach (var project in uservm.Projectsb)
                {
                    foreach (var ticket in project.Tickets)
                    {
                        if (ticket.AssignedToUserId == user.Id)
                        {
                            uservm.Tickets.Add(ticket);
                        }
                    }
                }
                userList.Add(uservm);
            }
            return(View(userList));
        }
示例#2
0
        public ActionResult Edit([Bind(Include = "Id,FirstName,LastName,DisplayName,AvatarPath,Email,SecurityStamp,PhoneNumber,PasswordHash,UserName")] ApplicationUser applicationUser, string roles)
        {
            if (User.Identity.GetUserId() == "db9a774b-807c-4b9b-9b22-34c191872996" || User.Identity.GetUserId() == "3eaa1491-7553-40fa-b7e1-b994e05d05e0" || User.Identity.GetUserId() == "5f84068f-4213-4d02-81a4-21936ae10cdc" || User.Identity.GetUserId() == "60f316c5-536c-4f06-83d3-38a555febc29")
            {
                return(RedirectToAction("InvalidAttempt", "Home"));
            }

            if (ModelState.IsValid)
            {
                //since i might be changing the users role, i want to first remove from all roles
                var currentRoles = roleHelper.ListUserRoles(applicationUser.Id);
                foreach (var role in currentRoles)
                {
                    roleHelper.RemoveUserFromRole(applicationUser.Id, role);
                }
                if (!string.IsNullOrEmpty(roles))
                {
                    roleHelper.AddUserToRole(applicationUser.Id, roles);
                }

                applicationUser.UserName = applicationUser.Email;

                db.Entry(applicationUser).State = EntityState.Modified;

                db.SaveChanges();
                return(RedirectToAction("Index"));
            }
            return(View(applicationUser));
        }
示例#3
0
        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"));
        }
        //POST : Admin
        public ActionResult ManageRoles(List <string> userIds, string role)
        {
            if (userIds == null)
            {
                TempData["Failure"] = "Please select a user.";
                return(RedirectToAction("ManageRoles", "Admin"));
            }


            //step 1 : Unenroll all the selected users from any roles
            //the may currently occupy
            foreach (var userId in userIds)
            {
                //what is the role of this person
                var userRole = roleHelper.ListUserRoles(userId).FirstOrDefault();
                if (userRole != null)
                {
                    roleHelper.RemoveUserFromRole(userId, userRole);
                }
            }

            //Step 2 : Add them back to the selected roles
            if (!string.IsNullOrEmpty(role))
            {
                foreach (var userId in userIds)
                {
                    roleHelper.AddUserToRole(userId, role);
                }
            }

            //Redirect to dashboard
            return(RedirectToAction("ManageRoles", "Admin"));
        }
示例#5
0
        public ActionResult ManageUserRoles(string users, string roles)
        {
            foreach (var role in roleHelper.ListUserRoles(users))
            {
                roleHelper.RemoveUserFromRole(users, role);
            }

            roleHelper.AddUserToRole(users, roles);

            return(RedirectToAction("UserIndex"));
        }
示例#6
0
 public ActionResult AssignUserRole(string UserId, string RoleName)
 {
     if (helper.AddUserToRole(UserId, RoleName))
     {
         return(RedirectToAction("AssignUserRole", "Roles"));
     }
     else
     {
         return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
     }
 }
        public ActionResult ManageUserRole(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 ManageRoles(List <string> usersIds, string role)
        {
            //Uneneroll all the selected Users from ANY
            //roles they may current occupy
            foreach (var userId in usersIds)
            {
                var userRole = rolesHelper.ListUserRoles(userId).FirstOrDefault();
                if (userRole != null)
                {
                    rolesHelper.RemoveUserFromRole(userId, userRole);
                }
            }

            //Step 2:Add them back to the selected Role
            if (!string.IsNullOrEmpty(role))
            {
                foreach (var userId in usersIds)
                {
                    rolesHelper.AddUserToRole(userId, role);
                }
            }


            return(RedirectToAction("ManageRoles", "Admin"));
        }
示例#9
0
        public async Task <ActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser {
                    UserName = model.Email, Email = model.Email, FirstName = model.FName, LastName = model.LName, DisplayName = model.DName
                };
                var result = await UserManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                    // For more information on how to enable account confirmation and password reset please visit http://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>");

                    UserRolesHelper helper = new UserRolesHelper(db);
                    helper.AddUserToRole(user.Id, "Submitter");

                    return(RedirectToAction("Index", "Home"));
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
        public async Task <ActionResult> AcceptInvitation(AcceptInvitationViewModel invitationvm)
        {
            if (ModelState.IsValid)
            {
                UserRolesHelper helper = new UserRolesHelper();
                var             user   = new ApplicationUser
                {
                    FirstName   = invitationvm.FirstName,
                    LastName    = invitationvm.LastName,
                    UserName    = invitationvm.Email,
                    Email       = invitationvm.Email,
                    HouseholdId = invitationvm.HouseholdId
                };

                var result = await UserManager.CreateAsync(user, invitationvm.Password);

                if (result.Succeeded)
                {
                    InvitationExtensions.MarkAsInvalid(invitationvm.Id);
                    helper.RemoveUserFromRole(user.Id, "Guest");
                    helper.AddUserToRole(user.Id, "Household Member");

                    await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                    return(RedirectToAction("Index", "Home"));
                }
                AddErrors(result);
            }
            return(View(invitationvm));
        }
示例#11
0
        //[Authorize(Roles = "Admin")]
        public ActionResult ManageRoles(List <string> userIds, string role)
        {
            if (!userRolesHelper.IsDemoUser(User.Identity.GetUserId()))
            {
                // Unenroll selected users from any roles
                foreach (var userId in userIds)
                {
                    var userRole = userRolesHelper.ListUserRoles(userId).FirstOrDefault();
                    if (userRole != null)
                    {
                        userRolesHelper.RemoveUserFromRole(userId, userRole);
                    }
                }
                // Add user back to role
                if (!string.IsNullOrEmpty(role))
                {
                    foreach (var userId in userIds)
                    {
                        userRolesHelper.AddUserToRole(userId, role);
                    }
                }
            }

            return(RedirectToAction("ManageRoles", "Admin"));
        }
        public ActionResult ManageRoles(List <string> userIds, string roleName)
        {
            // Step 1: If anyone was selected, remove them from all of their roles
            if (userIds == null)
            {
                return(RedirectToAction("NoRoleSelected"));
            }
            else
            {
                foreach (var userId in userIds)
                {
                    // Grab all user roles and assign to userRoles
                    var userRoles = roleHelper.ListUserRoles(userId).ToList();
                    // Determine if user currently occupies a role
                    foreach (var role in userRoles)
                    {
                        roleHelper.RemoveUserFromRole(userId, role);
                    }
                    // If a role was chosen, add each person to that role
                    if (!string.IsNullOrEmpty(roleName))
                    {
                        roleHelper.AddUserToRole(userId, roleName);
                    }
                }
            }

            // Step 2: If a role was chosen, add each person to that role


            return(RedirectToAction("ManageRoles"));
        }
示例#13
0
        public ActionResult RoleAssignment(string UserId, string RoleId, bool Delete)
        {
            if (string.IsNullOrEmpty(UserId) || string.IsNullOrEmpty(RoleId))
            {
                return(View());
            }

            if (Delete)
            {
                foreach (var role in UserRolesHelper.ListUserRoles(UserId))
                {
                    UserRolesHelper.RemoveUserFromRole(UserId, role);
                }

                return(RedirectToAction("RoleAssignment"));
            }

            if (UserRolesHelper.IsUserInRole(UserId, RoleId))
            {
                return(RedirectToAction("RoleAssignment"));
            }

            UserRolesHelper.AddUserToRole(UserId, RoleId);

            return(RedirectToAction("RoleAssignment"));
        }
        public async Task <ActionResult> ManageRoles(List <string> userIds, string role)
        {
            if (userIds == null)
            {
                Session.Add("Message", "Please select one or more users to apply roles to.");
                return(RedirectToAction("ManageRoles", "Admin"));
            }
            if (User.IsInRole("Demo_Admin"))
            {
                Session.Add("Message", "For security purposes demo roles cannot save changes to the database.");
                return(RedirectToAction("ManageRoles", "Admin"));
            }
            else
            {
                foreach (var userId in userIds)
                {
                    var userRole = RoleHelper.ListUserRoles(userId).FirstOrDefault();
                    if (userRole != null)
                    {
                        RoleHelper.RemoveUserFromRole(userId, userRole);
                    }
                }
                if (!string.IsNullOrEmpty(role))
                {
                    foreach (var userId in userIds)
                    {
                        RoleHelper.AddUserToRole(userId, role);
                    }
                }
                var user = db.Users.Find(User.Identity.GetUserId());
                await HttpContext.RefreshAuthentication(user);

                return(RedirectToAction("ManageRoles", "Admin"));
            }
        }
示例#15
0
        public ActionResult ManageUserRole(string userId, string roles)
        {
            //This is where I will be using the UserRolesHelper class
            //The first thing I want to do is make sure I remove user from all roles they may occupy.
            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 selected role
            if (!string.IsNullOrEmpty(roles))
            {
                roleHelper.AddUserToRole(userId, roles);
            }
            return(RedirectToAction("UserIndex"));
        }
示例#16
0
        public ActionResult Edit([Bind(Include = "Id,FirstName,LastName,DisplayName,AvatarPath,Email,UserName,PhoneNumber")] ApplicationUser applicationUser, string roles)
        {
            if (ModelState.IsValid)
            {
                //first get a list of roles the User occupies
                var currentRoles = roleHelper.ListUserRoles(applicationUser.Id);
                //Since I might be changing a User's role I want to first remove them from all Roles
                foreach (var role in currentRoles)
                {
                    //remove the user from any they already occupy.
                    roleHelper.RemoveUserFromRole(applicationUser.Id, role);
                }

                if (!string.IsNullOrEmpty(roles))
                {
                    roleHelper.AddUserToRole(applicationUser.Id, roles);
                }


                applicationUser.UserName = applicationUser.Email;

                db.Entry(applicationUser).State = EntityState.Modified;

                db.SaveChanges();
                return(RedirectToAction("Index"));
            }
            return(View(applicationUser));
        }
        public ActionResult ManageUserRole(string userId, string userRole)
        {
            //This is where I will be using the UseRoleHelper class to make suer my user occupies
            //The first thing I want to do is to make sure I remove the user from ALL ROLES they may occupy
            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"));
        }
示例#18
0
        public ActionResult ManageUserRole(AssignUserRoleViewModel model)
        {   //My Code & not Jason's
            //This is where I will be using the UserRolesHelper class to make sure my user occupies the proper role
            //The first thing I want to do is make sure I remove the user from ALL ROLES they may occupy

            foreach (var role in roleHelper.ListUserRoles(model.UserId))
            {
                roleHelper.RemoveUserFromRole(model.UserId, role);
            }

            //If the incoming role selection is NOT NULL I want to assign the user to the selected role
            if (!string.IsNullOrEmpty(model.SelectedRole))
            {
                roleHelper.AddUserToRole(model.UserId, model.SelectedRole);
            }
            return(RedirectToAction("UserIndex"));
        }
        public async Task <ActionResult> Register(RegisterViewModel model, HttpPostedFileBase image, int hourConversion, int serverTime)
        {
            ViewBag.ServerHourRegister = System.DateTime.Now.Hour;
            var now  = System.DateTime.Now.Hour;
            var diff = Math.Abs(now - serverTime);

            if (ModelState.IsValid)
            {
                var joinChapter = db.Chapters.First(c => c.CurrentChapter == true).Id;
                var pPic        = "/assets/images/DefaultProfilePic.png";
                if (ImageUploadValidator.IsWebFriendlyImage(image))
                {
                    //Counter
                    var num = 0;
                    //Gets Filename without the extension
                    var fileName = Path.GetFileNameWithoutExtension(image.FileName);
                    pPic = Path.Combine("/ProfilePics/", fileName + Path.GetExtension(image.FileName));
                    //Checks if pPic matches any of the current attachments,
                    //if so it will loop and add a (number) to the end of the filename
                    while (db.Users.Any(u => u.ProfilePic == pPic))
                    {
                        //Sets "filename" back to the default value
                        fileName = Path.GetFileNameWithoutExtension(image.FileName);
                        //Add's parentheses after the name with a number ex. filename(4)
                        fileName = string.Format(fileName + "(" + ++num + ")");
                        //Makes sure pPic gets updated with the new filename so it could check
                        pPic = Path.Combine("/ProfilePics/", fileName + Path.GetExtension(image.FileName));
                    }
                    image.SaveAs(Path.Combine(Server.MapPath("~/ProfilePics/"), fileName + Path.GetExtension(image.FileName)));
                }

                var user = new ApplicationUser {
                    UserName = model.Email, Email = model.Email, PhoneNumber = model.PhoneNumber, ProfilePic = pPic, JoinChapterId = joinChapter, FirstName = model.FirstName, LastName = model.LastName, DisplayName = model.FirstName + ' ' + model.LastName, Company = model.Company, JobTitle = model.JobTitle, HourConversion = hourConversion - diff
                };
                var result = await UserManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    var helper = new UserRolesHelper(db);
                    helper.AddUserToRole(user.Id, "User");
                    db.SaveChanges();

                    await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                    //// For more information on how to enable account confirmation and password reset please visit http://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", "Home"));
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
示例#20
0
 public bool RemoveHouseholdMember(string userId, int householdId)
 {
     if (IsMemberOfHousehold(userId, householdId))
     {
         UserRolesHelper.RemoveUserFromRole(userId, HouseholdRoleName.MEMBER);
         UserRolesHelper.AddUserToRole(userId, HouseholdRoleName.NONE);
         db.Households.Find(householdId).Members.Remove(db.Users.Find(userId));
         db.SaveChanges();
     }
     return(!IsMemberOfHousehold(userId, householdId));
 }
示例#21
0
        public ActionResult ManageRoles(string userId, string roleName)
        {
            var user        = db.Users.Find(userId);
            var currentRole = roleHelper.ListUserRoles(userId).FirstOrDefault();

            roleHelper.RemoveUserFromRole(userId, currentRole);
            roleHelper.AddUserToRole(userId, roleName);

            TempData["roleMessage"] = user.FullName + "'s role has been updated to " + roleName + ".";
            return(RedirectToAction("ManageRoles"));
        }
        public ActionResult ManageRoles(string userId, string roles)
        {
            //I want to ensure theat the person I selected occupies one and only 1 role
            //Therefore the first thing I am going to do is remove the user from any role
            //they currently occupy



            //Step 1: Remove any roles currently occupied by the user. We can do this by
            // looping over the roles currently occupied by the user using the roleHelper
            foreach (var role in roleHelper.ListUserRoles(userId))
            {
                roleHelper.RemoveUserFromRole(userId, role);
            }

            //Step 2: Add the newly selected role to the user
            roleHelper.AddUserToRole(userId, roles);

            return(RedirectToAction("UserIndex", "Admin"));
        }
        public async Task <ActionResult> Invite(RegisterViewModel model)
        {
            //if (ModelState.IsValid)
            //{
            var _db    = new ApplicationDbContext();
            var helper = new UserRolesHelper(_db);

            var user = new ApplicationUser
            {
                UserName    = model.Email,
                Email       = model.Email,
                FirstName   = model.FirstName,
                LastName    = model.LastName,
                DisplayName = model.FirstName + " " + model.LastName
            };

            if (model.PhoneNumber != null)
            {
                user.PhoneNumber = model.PhoneNumber;
            }

            IdentityResult result = new IdentityResult();

            try
            {
                result = await UserManager.CreateAsync(user, model.Password);
            }

            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            if (result.Succeeded)
            {
                //await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);

                // For more information on how to enable account confirmation and password reset please visit http://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, "An Invitation From Char-Em United Way", "Hello " + user.DisplayName + "!  <br>  You have been invited to join Char Em United Way's Service Guide. <br> Your account has been created just click <a href=\"" + callbackUrl + "\">here</a> to claim your account.<br> Your temporary password is:" + model.Password);

                helper.AddUserToRole(user.Id, model.SelectedRole);

                return(RedirectToAction("Index", "Home"));
            }
            AddErrors(result);
            // }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
示例#24
0
        public ActionResult AddUserToRole(List <string> userIds, string roleName)
        {
            //go through each user selected and add to the selected role
            foreach (var userId in userIds)
            {
                //check if the user is currently in a role. if so, remove it and add new role.
                var currentRole = userRoleHelper.ListUserRoles(userId);
                if (currentRole.Count > 0)
                {
                    userRoleHelper.RemoveUserFromRole(userId, currentRole.FirstOrDefault());
                    userRoleHelper.AddUserToRole(userId, roleName);
                }
                else
                {
                    userRoleHelper.AddUserToRole(userId, roleName);
                }
            }

            return(RedirectToAction("ManageRoles"));
        }
示例#25
0
        public ActionResult EditUserRoles(/*[Bind(Include = "User, Roles, SelectedRoles, Id, Name")]*/ AdminUserViewModel AdminUserViewModel)
        {
            UserRolesHelper helper            = new UserRolesHelper(db);
            string          userId            = AdminUserViewModel.Id;
            var             editedUserAccount = db.Users.Find(userId);
            var             currentUser       = db.Users.Find(User.Identity.GetUserId());

            if (User.IsInRole("DemoAcc"))
            {
                string errcode = User.Identity.Name + " Permission not granted, EditUserRoles, Edited User: "******"Err403", "BT", new { errcode = errcode }));
            }
            if (ModelState.IsValid)
            {
                var      selectedRoleList = AdminUserViewModel.SelectedRoles;
                string[] currentRoleList  = helper.ListUserRoles(userId).ToArray();
                int      counter          = 0; //Counter for currentRoleList.
                                               //Spins through currentRoleList and removes roles that are nolonger selected
                foreach (var item in currentRoleList)
                {
                    bool present  = false;
                    int  counter2 = 0;   //Counter for SelectedRolesList
                    while (present == false && counter2 < selectedRoleList.Length)
                    {
                        if (currentRoleList[counter] == selectedRoleList[counter2])
                        {
                            present = true;
                        }
                        counter2++;
                        if (present == false && counter2 == selectedRoleList.Length)
                        {
                            helper.RemoveUserFromRole(userId, currentRoleList[counter]);
                        }
                    }
                    counter++;
                }
                counter = 0;
                //Adds only roles that were selected.
                foreach (var item in selectedRoleList)
                {
                    string toBeAdded = selectedRoleList[counter];
                    if (!helper.IsUserInRole(userId, toBeAdded))
                    {
                        var result = helper.AddUserToRole(userId, toBeAdded);
                    }
                    counter += 1;
                }
                return(RedirectToAction("EditUserRoles", "Admin", userId));
            }

            return(RedirectToAction("EditUserRoles", "Admin", userId));
        }
示例#26
0
        public ActionResult Create([Bind(Include = "Id,Name,Greating,Created")] Households households)
        {
            if (ModelState.IsValid)
            {
                households.Created = DateTime.Now;
                db.Households.Add(households);

                //Add User to Household
                var userId = User.Identity.GetUserId();
                var user   = db.Users.Find(userId);
                user.HouseholdId = households.Id;

                //Add User Role
                roleHelper.AddUserToRole(userId, "HouseholdHead");

                db.SaveChanges();

                return(RedirectToAction("Index"));
            }

            return(View(households));
        }
        public async Task <ActionResult> Create([Bind(Include = "Id,Name,Greeting")] Household household)
        {
            if (ModelState.IsValid)
            {
                var userId = User.Identity.GetUserId();
                foreach (var userRole in rolesHelper.ListUserRoles(userId))
                {
                    rolesHelper.RemoveUserFromRole(userId, userRole);
                }

                rolesHelper.AddUserToRole(userId, "Household Owner");
                household.Created = DateTime.Now;
                db.Households.Add(household);
                db.Users.Find(userId).HouseholdId = household.Id;
                db.SaveChanges();
                await HttpContext.RefreshAuthentication(db.Users.Find(userId));

                return(RedirectToAction("Index", "Home"));
            }

            return(View(household));
        }
 public ActionResult AssignRoles(RolesViewModel model)
 {
     if (ModelState.IsValid)
     {
         if (model.SelectedUsers != null)
         {
             foreach (string id in model.SelectedUsers)
             {
                 helper.AddUserToRole(id, model.RoleName);
             }
         }
         return(RedirectToAction("Index", "RolesManager"));
     }
     return(View(model));
 }
示例#29
0
 public bool AddHouseholdMember(string userId, int householdId, bool headOfHousehold = false)
 {
     if (!IsMemberOfHousehold(userId, householdId))
     {
         UserRolesHelper.RemoveUserFromRole(userId, HouseholdRoleName.NONE);
         UserRolesHelper.AddUserToRole(userId, HouseholdRoleName.MEMBER);
         if (headOfHousehold)
         {
             UserRolesHelper.AddUserToRole(userId, HouseholdRoleName.HEAD_OF_HOUSEHOLD);
         }
         db.Households.Find(householdId).Members.Add(db.Users.Find(userId));
         db.SaveChanges();
     }
     return(IsMemberOfHousehold(userId, householdId));
 }
示例#30
0
 public ActionResult AssignRoles(AssignRolesViewModel model)
 {
     if (ModelState.IsValid)
     {
         if (model.SelectedUsers != null)
         {
             foreach (string userId in model.SelectedUsers)
             {
                 helper.AddUserToRole(userId, model.RoleName);
             }
         }
         return(RedirectToAction("RoleAssignations", "Roles", new { id = model.RoleId }));
     }
     return(View(model));
 }
示例#31
0
        public ActionResult EditUser(string id, AdminUserViewModel model)
        {
            if (id == null) {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }

            var user = db.Users.Find(id);
            UserRolesHelper helper = new UserRolesHelper();

            foreach (var role in db.Roles.ToList()) {
                //If selected but user doesn't have, add
                if (model.SelectedRoles.Contains(role.Id)) {
                    helper.AddUserToRole(id, role.Name);
                }
                //If not selected but user *does* have, remove
                else if (!model.SelectedRoles.Contains(role.Id)) {
                    helper.RemoveUserFromRole(id, role.Name);
                }
            }

            return RedirectToAction("Index", new { id });
        }
示例#32
0
        public ActionResult ManageRoles(string role, string[] assignedUsers)
        {
            var helper = new UserRolesHelper();//a new 'UserRolesHelper' object is instantiated and named 'helper'. It has all of the methods
            //defined in the 'UserRolesHelper' class.
            var dbRole = db.Roles.FirstOrDefault(r => r.Name == role);//go to the 'Roles' table in the database and find the first role where
            //it's 'Name' property has the same value as the 'role' parameter that was passed to this action method and assign that role
            //(it's 'Name' and 'Id' properties and their values) to the variable called 'dbRole'.

            if (dbRole == null)
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);

            dbRole.Users.Clear();//remove all of the users from the 'Users' property of 'dbRole'
            db.SaveChanges();//save any changes made to the database.

            foreach (var user in assignedUsers ?? new string[0])//loop over the string array 'assignedUser', which was passed as a parameter
                //to this acton method....LOOK INTO THE SECOND PART OF THIS LOOP STATEMENT...NOT REALLY SURE WHAT THAT IS ABOUT...
                helper.AddUserToRole(user, role);//call the 'AddUserToRole' method from the 'helper' object and pass it the current user from
            //the 'assignedUsers' array and the specified 'role'.

            return RedirectToAction("ManageRoles", new { role });//redirect to the 'ManageRoles' action method with a new object of the
            //'role' that was passed to this action method.
        }