Пример #1
0
        public ActionResult GroupRoles(int id)
        {
            var group = db.Groups.Find(id);
            var model = new SelectGroupRolesViewModel(group);

            return(View(model));
        }
Пример #2
0
        public async Task <ActionResult> GroupRoles(SelectGroupRolesViewModel model)
        {
            if (ModelState.IsValid)
            {
                //var idManager = new IdentityManager();
                //var Db = new ApplicationDbContext();
                await _identityManager.ClearGroupRoles(model.GroupId);

                var group = await _context.Groups.FindAsync(model.GroupId);

                //_identityManager.ClearGroupRoles(model.GroupId);
                // Add each selected role to this group:
                foreach (var role in model.Roles)
                {
                    if (role.Selected)
                    {
                        await _identityManager.AddRoleToGroup(group.Id, role.RoleName);
                    }
                    //else
                    //{
                    //    _identityManager.RemoveRoleFromGroup(group.Id, role.RoleName);
                    //}
                }
                return(RedirectToAction("index"));
            }
            return(View());
        }
Пример #3
0
        //[Authorize(Roles = "Admin, CanEditGroup")]
        public async Task <ActionResult> GroupRoles(int id)
        {
            var group = await _context.Groups.Include(x => x.Roles).Where(x => x.Id == id).FirstOrDefaultAsync();

            var model = new SelectGroupRolesViewModel(group, _context);

            return(View(model));
            //return Content(group.Name);
        }
Пример #4
0
        public async Task <ActionResult> GroupRoles(string groupId)
        {
            if (string.IsNullOrWhiteSpace(groupId))
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var appRoles   = RoleManager.Roles;
            var groupRoles = await GroupManager.GetGroupRoles(groupId);

            var group = await GroupManager.FindByIdAsync(groupId);

            var mapped = appRoles.Where(role => groupRoles.Any(groupRole => groupRole.RoleId == role.RoleId))
                         .Select(r => new SelectRoleViewModel()
            {
                RoleId          = r.RoleId,
                RoleName        = r.RoleName,
                RoleDescription = r.RoleDescription,
                IsSelected      = true
            });

            var notMapped = appRoles.Where(role => !groupRoles.Any(groupRole => groupRole.RoleId == role.RoleId))
                            .Select(r => new SelectRoleViewModel()
            {
                RoleId          = r.RoleId,
                RoleName        = r.RoleName,
                RoleDescription = r.RoleDescription,
                IsSelected      = false
            });

            var allRoles = new List <SelectRoleViewModel>();

            allRoles.AddRange(mapped);
            allRoles.AddRange(notMapped);

            var selectRole = new SelectGroupRolesViewModel()
            {
                GroupId          = group.GroupId,
                GroupName        = group.GroupName,
                GroupDescription = group.GroupDescription,
                Roles            = allRoles.OrderBy(r => r.RoleName).ToList()
            };

            return(View(selectRole));
        }
Пример #5
0
        public async Task <ActionResult> GroupRoles(SelectGroupRolesViewModel selRoles)
        {
            if (ModelState.IsValid)
            {
                var groupRoles = await GroupManager.GetGroupRoles(selRoles.GroupId);

                var deletedRolesIds = selRoles.Roles.Where(role => groupRoles.Any(groupRole => groupRole.RoleId == role.RoleId && !role.IsSelected))
                                      .Select(role => role.RoleId);
                var newRolesIds = selRoles.Roles.Where(role => !groupRoles.Any(groupRole => groupRole.RoleId == role.RoleId)).Where(role => role.IsSelected)
                                  .Select(role => role.RoleId);

                await GroupManager.RemoveRolesFromGroupAsync(selRoles.GroupId, deletedRolesIds);

                await GroupManager.AddRoleToGroup(selRoles.GroupId, newRolesIds);

                return(RedirectToAction("GroupList"));
            }
            return(View());
        }
        public ActionResult GroupRoles(SelectGroupRolesViewModel model)
        {
            if (ModelState.IsValid)
            {
                var group = _db.Groups.Find(model.GroupId);
                _imanager.RemoveGroupRolesByGroupId(model.GroupId);

                // Add each selected role to this group:
                foreach (var role in model.Roles)
                {
                    if (role.Selected)
                    {
                        _imanager.CreateApplicationRoleGroup(group.Id, role.RoleName);
                    }
                }
                return(RedirectToAction("index"));
            }
            return(View());
        }
 public ActionResult GroupRoles(SelectGroupRolesViewModel model)
 {
     if (ModelState.IsValid)
     {
         var idManager = new IdentityManager();
         var Db        = new ApplicationDbContext();
         var group     = Db.Group.Find(model.GroupId);
         idManager.ClearGroupRoles(model.GroupId);
         // Add each selected role to this group:
         foreach (var role in model.Roles)
         {
             if (role.Selected)
             {
                 idManager.AddRoleToGroup(group.Id, role.RoleName);
             }
         }
         return(RedirectToAction("index"));
     }
     return(View());
 }
        public ActionResult GroupRoles(int id)
        {
            var group     = _db.Groups.Find(id);
            var groupList = group.ApplicationRoleGroups.ToList();

            var roleList = (_db.Roles.ToList()
                            .Select(u => new SelectRoleEditorViewModel()
            {
                Description = u.Description,
                RoleName = u.Name,
                Selected = groupList.Any(x => x.Role.Name == u.Name)
            })).ToList();

            var model = new SelectGroupRolesViewModel()
            {
                GroupId   = group.Id,
                GroupName = group.Name,
                Roles     = roleList
            };

            return(View(model));
        }