コード例 #1
0
        public async Task<ActionResult> Create(UserRoleViewModel viewModel)
        {
            try
            {
	            if (!ModelState.IsValid)
		            return View(viewModel);

	            var role = Mapper.Map<UserRole>(viewModel);
                var exists = _roleService.Roles.Any(x => x.Name == role.Name);
                if (!exists)
	            {
					await _roleService.CreateAsync(role);

					return RedirectToAction("Index");
				}

				ModelState.AddModelError("", "A role with name already exists.");
				return View(viewModel);
            }
            catch
            {
				ModelState.AddModelError("", "An error has occured. This role was not created.");
                return View(viewModel);
            }
        }
コード例 #2
0
ファイル: AccountController.cs プロジェクト: ptorrezao/Phobos
        public ActionResult CreateRole(UserRoleViewModel role)
        {
            var error = "";
            if (this.userManagementService.CreateRole(role.Name, out error))
            {
                return Json(new { url = Url.Action("ListGroups") });
            }
            else
            {
                ModelState.AddModelError(string.Empty, error);

                return View("_CreateRole", role);
            }
        }
コード例 #3
0
        public async Task <IActionResult> Roles(UserRoleViewModel editUserRole, params string[] selectedRole)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var user = await _userManager.FindByIdAsync(editUserRole.Id);

                    if (user == null)
                    {
                        return(BadRequest("no record found"));
                    }


                    var userRoles = await _userManager.GetRolesAsync(user);

                    selectedRole = selectedRole ?? new string[] { };

                    var result = await _userManager.AddToRolesAsync(user, selectedRole.Except(userRoles).ToArray());

                    if (!result.Succeeded)
                    {
                        ModelState.AddModelError("", result.Errors.First().ToString());
                        return(View());
                    }
                    result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRole).ToArray());

                    if (!result.Succeeded)
                    {
                        ModelState.AddModelError("", result.Errors.First().ToString());
                        return(View());
                    }
                    return(RedirectToAction("Index", "Account"));
                }
                ModelState.AddModelError("", "Something failed.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message + " " + ex.InnerException);
            }
            return(Content("Internal server error please contact the system administrator"));
        }
コード例 #4
0
        public async Task <IActionResult> AddUserToRole(UserRoleViewModel userRoleViewModel)
        {
            var role = await _roleManager.FindByIdAsync(userRoleViewModel.RoleId);

            if (await AzureService.FindUserId(userRoleViewModel.Email) == null)
            {
                ModelState.AddModelError(string.Empty, "Email not exist!  Please confirm your email.");
                return(View(userRoleViewModel));
            }
            var authBlob = AzureService.GetBlob(null, "index", WebUIConfig.AppInfoConfigFile);
            var json     = await authBlob.DownloadGenericObjectAsync();

            var addAuth    = JsonUtils.GetJToken(Constants.JsontagAuthorization, json);
            var addAuthObj = addAuth == null ? null : addAuth as JObject;

            foreach (var pair in addAuthObj)
            {
                if (pair.Key == role.Name)
                {
                    var peopleArray = pair.Value as JArray;
                    foreach (var onepeople in peopleArray)
                    {
                        if (String.Compare(onepeople.ToString(), userRoleViewModel.Email, true) == 0)
                        {
                            return(RedirectToAction("EditRole", new { id = role.Id }));
                        }
                    }
                    var user = await _userManager.FindByEmailAsync(userRoleViewModel.Email);

                    if (user != null)
                    {
                        await _userManager.AddToRoleAsync(user, role.Name);
                    }
                    peopleArray.Add(userRoleViewModel.Email);
                    SessionOps.AddSession <string>($"role_{userRoleViewModel.RoleId}_user_list", userRoleViewModel.Email,
                                                   HttpContext.Session.Get($"role_{userRoleViewModel.RoleId}_user_list"),
                                                   HttpContext.Session);
                    await authBlob.UploadGenericObjectAsync(json);
                }
            }
            return(RedirectToAction("EditRole", new { id = role.Id }));
        }
コード例 #5
0
        public async Task <IActionResult> UpdateRole(long userId)
        {
            var user  = PollContext.Users.Find(userId);
            var roles = await Auth.GetRolesAsStringAsync(userId);

            if (roles != null)
            {
                var vm = new UserRoleViewModel
                {
                    UserId    = userId,
                    UserName  = user.UserName,
                    UserRoles = roles.ToList()
                };
                return(View(vm));
            }
            else
            {
                throw new EntityNotFoundException($"The user with id '{userId}' does not have roles!");
            }
        }
コード例 #6
0
        public async Task <IActionResult> DeleteUserFromRole(UserRoleViewModel userRoleViewModel)
        {
            var user = await _userManager.FindByIdAsync(userRoleViewModel.UserId);

            var role = await _roleManager.FindByIdAsync(userRoleViewModel.RoleId);

            var result = await _userManager.RemoveFromRoleAsync(user, role.Name);

            if (result.Succeeded)
            {
                return(RedirectToAction("EditRole", "Admin", new { id = role.Id }));
            }

            foreach (var error in result.Errors)
            {
                ModelState.AddModelError("", error.Description);
            }

            return(View(userRoleViewModel));
        }
コード例 #7
0
        public async Task <UserRoleViewModel> ViewUserRoleAsync(string userId)
        {
            var user = await _userManager.FindByIdAsync(userId);

            var userRoleViewModel = new UserRoleViewModel()
            {
                RoleId = user.CBARoleId,
                User   = user
            };

            foreach (var role in _roleManager.Roles)
            {
                userRoleViewModel.Roles.Add(new SelectListItem()
                {
                    Text  = role.Name,
                    Value = role.Id
                });
            }
            return(userRoleViewModel);
        }
コード例 #8
0
        public async Task <IActionResult> DeleteUserFromRole(UserRoleViewModel vm)
        {
            var user = await _userManager.FindByIdAsync(vm.UserId);

            var role = await _roleManager.FindByIdAsync(vm.RoleId);

            var result = await _userManager.RemoveFromRoleAsync(user, role.Name);

            if (result.Succeeded)
            {
                return(RedirectToAction("RoleManagement", _roleManager.Roles));
            }

            foreach (IdentityError error in result.Errors)
            {
                ModelState.AddModelError("", error.Description);
            }

            return(View(vm));
        }
コード例 #9
0
        public async Task <ActionResult> ListUsers()
        {
            var users = await _userManager.Users.ToListAsync();

            var userRolesViewModel = new List <UserRoleViewModel>();

            foreach (User user in users)
            {
                var thisViewModel = new UserRoleViewModel
                {
                    UserId   = user.Id,
                    Name     = user.FullName,
                    UserName = user.Email,
                    Roles    = await GetUserRoles(user)
                };
                userRolesViewModel.Add(thisViewModel);
            }

            return(View(userRolesViewModel));
        }
コード例 #10
0
        public async Task <IActionResult> SetRole(UserRoleViewModel model)
        {
            var user = await this.userManager.FindByIdAsync(model.Id);

            if (user == null)
            {
                return(NotFound());
            }

            var isRoleExist = await this.roleManager.RoleExistsAsync(model.ChosedRole);

            if (!isRoleExist)
            {
                return(NotFound());
            }

            await this.userManager.AddToRoleAsync(user, model.ChosedRole);

            return(RedirectToAction(nameof(AllUsers)));
        }
コード例 #11
0
        public async Task <IActionResult> DeleteUserFromRole(string roleId)
        {
            var role = await _roleManager.FindByIdAsync(roleId);

            if (role == null)
            {
                return(RedirectToAction("RoleManagement", _roleManager.Roles));
            }

            var users = await _userManager.GetUsersInRoleAsync(role.Name);

            var userRoleViewModel = new UserRoleViewModel
            {
                RoleId = role.Id,
                Users  = users.ToList()
            };


            return(View(userRoleViewModel));
        }
コード例 #12
0
        public async Task <ActionResult> DeleteUserFromRole(UserRoleViewModel userRoleViewModel)
        {
            var user = await UserManager.FindByIdAsync(userRoleViewModel.UserId);

            var role = await RoleManager.FindByIdAsync(userRoleViewModel.RoleId);

            var result = await UserManager.RemoveFromRoleAsync(user.Id, role.Name);

            if (result.Succeeded)
            {
                return(RedirectToAction("RoleManagement", RoleManager.Roles));
            }

            foreach (var error in result.Errors)
            {
                ModelState.AddModelError("", error);
            }

            return(View(userRoleViewModel));
        }
コード例 #13
0
        public async Task <IActionResult> AddUserToRole(UserRoleViewModel userRoleViewModel)
        {
            var user = await _userManager.FindByIdAsync(userRoleViewModel.UserId);

            var role = await _roleManager.FindByIdAsync(userRoleViewModel.RoleId);

            var result = await _userManager.AddToRoleAsync(user, role.Name);

            if (result.Succeeded)
            {
                return(RedirectToAction("RoleManagement"));
            }

            foreach (IdentityError error in result.Errors)
            {
                ModelState.AddModelError("", error.Description);
            }

            return(View(userRoleViewModel));
        }
コード例 #14
0
        public async Task <IActionResult> RemoveRole(UserRoleViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var role = await _roleManager.FindByNameAsync(model.Role);

            if (role != null)
            {
                var user = await _userManager.FindByNameAsync(model.User.ToLower());

                var result = await _userManager.RemoveFromRoleAsync(user, role.Name);
            }

            StatusMessage = string.Concat(model.Role, " removed from ", model.User);

            return(RedirectToAction(nameof(UserRoles)));
        }
コード例 #15
0
        public ActionResult AddUserToRole(string id)
        {
            UserRoleViewModel urvm = new UserRoleViewModel();

            urvm.AllRoles     = db.Roles.OrderBy(r => r.Name).Select(r => r.Name).ToList();
            urvm.userid       = id;
            urvm.CheckedRoles = new bool[urvm.AllRoles.Count];
            for (int i = 0; i < urvm.AllRoles.Count; i++)
            {
                if (IdentityManager.IsUserInRoleById(id, urvm.AllRoles[i]))
                {
                    urvm.CheckedRoles[i] = true;
                }
                else
                {
                    urvm.CheckedRoles [i] = false;
                }
            }
            return(View(urvm));
        }
コード例 #16
0
        public ActionResult ChangeRole(UserRoleViewModel model)
        {
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
            //STEP 1: Find the user
            var user = userManager.FindById(model.Id);
            //STEP 2: Get UserRoles:
            var userRoles = userManager.GetRoles(user.Id);

            //STEP 3: Remove the roles from the user
            foreach (var role in userRoles)
            {
                userManager.RemoveFromRole(user.Id, role);
            }
            //STEP 4: Add roles to the user
            foreach (var role in model.SelectedRoles)
            {
                userManager.AddToRole(user.Id, role);
            }
            return(RedirectToAction("Index"));
        }
コード例 #17
0
        public ActionResult AddRole()
        {
            var user = User.Identity.GetUserId();

            if (userManager.IsInRole(user, "Admin"))
            {
                //var userId = User.Identity.GetUserId();
                //var profile = db.Users.FirstOrDefault(p => p.Id == userId);
                //model.apUser = profile;
                var model    = new UserRoleViewModel();
                var allRoles = db.Roles;
                model.rol = allRoles.Select(a => new SelectListItem {
                    Text = a.Name, Value = a.Id
                });

                return(View(model));
            }

            return(RedirectToAction("Index", "Home", null));
        }
コード例 #18
0
        // DeleteUserFromRole
        public async Task <IActionResult> DeleteUserFromRole(string roleId)
        {
            var role = await _roleManager.FindByIdAsync(roleId);

            var vm = new UserRoleViewModel
            {
                RoleId = role.Id.ToString()
            };

            if (role != null)
            {
                var users = await _userManager.GetUsersInRoleAsync(role.Name.ToString());

                foreach (var user in users)
                {
                    vm.Users.Add(user);
                }
            }
            return(View(vm));
        }
コード例 #19
0
        public ActionResult EditRole(string id)
        {
            ApplicationUser   user = ctx.Users.SingleOrDefault(x => x.Id == id);
            UserRoleViewModel urvm = new UserRoleViewModel
            {
                roles = ctx.Roles.Select(r => new SelectListItem
                {
                    Value = r.Name,
                    Text  = r.Name
                }
                                         ).ToList(),
                User = user
                       //assign user
            };

            //ViewBag.rolesList = urvm.roles;

            return(PartialView("Modal_Partial", urvm));
            //return Json(urvm, JsonRequestBehavior.AllowGet);
        }
コード例 #20
0
        //改变用户的角色
        public ActionResult EditUserRole(string userId, string roleId)
        {
            //如果没有角色则添加
            if (roleId == null)
            {
                var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
                var userName    = userManager.FindById(userId).UserName;
                var userModel   = new UserRoleViewModel(userName);
                return(View(userModel));
            }
            var userRole = db.UserRoles.Where(u => u.UserId == userId && u.RoleId == roleId).FirstOrDefault();

            if (userRole == null)
            {
                return(HttpNotFound());
            }
            var model = new UserRoleViewModel(userRole);

            return(View(model));
        }
コード例 #21
0
        public ActionResult MembersInfo(string id)
        {
            var user = _Context.Users.Single(x => x.Id == id);

            var roles = new List <string>();

            foreach (var item in user.Roles)
            {
                roles.Add(_Context.Roles.Single(x => x.Id == item.RoleId).Name);
            }
            var userViewModel = new UserRoleViewModel
            {
                Roles    = roles,
                UserName = user.UserName
            };



            return(View(userViewModel));
        }
コード例 #22
0
        public async Task <IActionResult> EditUsersInRole(UserRoleViewModel userRoleViewModel)
        {
            var role = await roleManager.FindByIdAsync(userRoleViewModel.RoleId);

            if (role == null)
            {
                ViewBag.ErrorMessage = $"Role with Id = {userRoleViewModel.RoleId} cannot be found";
                return(View("NotFound"));
            }

            for (int i = 0; i < userRoleViewModel.UserRoleList.Count; i++)
            {
                var user = await userManager.FindByIdAsync(userRoleViewModel.UserRoleList[i].UserId);

                IdentityResult identityResult = null;
                if (userRoleViewModel.UserRoleList[i].IsSelected && !(await userManager.IsInRoleAsync(user, role.Name)))
                {
                    identityResult = await userManager.AddToRoleAsync(user, role.Name);
                }
                else if (!userRoleViewModel.UserRoleList[i].IsSelected && await userManager.IsInRoleAsync(user, role.Name))
                {
                    identityResult = await userManager.RemoveFromRoleAsync(user, role.Name);
                }
                else
                {
                    continue;
                }
                if (identityResult.Succeeded)
                {
                    if (i < (userRoleViewModel.UserRoleList.Count - 1))
                    {
                        continue;
                    }
                    else
                    {
                        return(RedirectToAction("Details", new { id = userRoleViewModel.RoleId }));
                    }
                }
            }
            return(RedirectToAction("Details", new { id = userRoleViewModel.RoleId }));
        }
コード例 #23
0
        public IActionResult AddUsersToRoles(UserRoleViewModel postModel)
        {
            if (ModelState.IsValid)
            {
                var roleManager = _services.GetRequiredService <RoleManager <IdentityRole> >();
                var userManager = _services.GetRequiredService <UserManager <ApplicationUser> >();

                // find the user
                var user = userManager.FindByIdAsync(postModel.Id).Result;
                // find the role
                var role = roleManager.FindByIdAsync(postModel.RoleId).Result;

                if (user != null && role != null) // if the user exists and role exists
                {
                    var isInRole = userManager.IsInRoleAsync(user, role.Name).Result;
                    if (isInRole) // if the user has already been in the role
                    {
                        ValidationHelper.codeForUserRole = 2;
                        ValidationHelper.user            = user.UserName;
                        ValidationHelper.role            = role.Name;
                        return(RedirectToAction("AddUsersToRoles"));
                    }
                    // add user to the role
                    var result = userManager.AddToRoleAsync(user, role.Name).Result;
                    if (result.Succeeded)
                    {
                        ValidationHelper.codeForUserRole = 1;
                        ValidationHelper.user            = user.UserName;
                        ValidationHelper.role            = role.Name;
                        return(RedirectToAction("AddUsersToRoles"));
                    }
                }
                else
                {
                    // user or role does not exist
                    return(RedirectToAction("AddUsersToRoles"));
                }
            }

            return(RedirectToAction("AddUsersToRoles"));
        }
コード例 #24
0
        public async Task <IActionResult> EditUsersInRole(string roleId)
        {
            ViewBag.roleId = roleId;
            var role = RoleMangerService.FindByIdAsync(roleId);

            if (role == null)
            {
                ViewBag.ErrorMessage = $"The role with id : {roleId} cannot be found";
                return(View("NotFound"));
            }

            /*
             * var usersInRole = await UserManager.GetUsersInRoleAsync(role.Name);
             * if (usersInRole == null)
             * {
             *  ViewBag.ErrorMessage = $"No users for this role id {roleId}.";
             * }
             */

            var model          = new List <UserRoleViewModel>();
            var allUsers       = UserManager.Users;
            var UserInThisRole = await UserManager.GetUsersInRoleAsync(role.Result.Name);

            foreach (var user in allUsers)
            {
                var userRoleViewModel = new UserRoleViewModel
                {
                    UserId     = user.Id,
                    UserName   = user.UserName,
                    IsSelected = false
                };

                if (UserInThisRole.Any(x => x.Id == userRoleViewModel.UserId))
                {
                    userRoleViewModel.IsSelected = true;
                }

                model.Add(userRoleViewModel);
            }
            return(View(model));
        }
コード例 #25
0
        public async Task <IActionResult> EditUsersInRole(string roleId)
        {
            ViewBag.roleId = roleId;

            var role = await roleManager.FindByIdAsync(roleId);

            if (role == null)
            {
                ViewBag.ErrorMessage = $"Role with Id = {roleId} cannot be found";
                return(View("NotFound"));
            }

            var model         = new List <UserRoleViewModel>();
            var currentUserId = userManager.GetUserId(HttpContext.User);


            foreach (var user in userManager.Users)
            {
                if (currentUserId != user.Id)
                {
                    var userRoleViewModel = new UserRoleViewModel
                    {
                        userId   = user.Id,
                        UserName = user.UserName
                    };

                    if (await userManager.IsInRoleAsync(user, role.Name))
                    {
                        userRoleViewModel.IsSelected = true;
                    }
                    else
                    {
                        userRoleViewModel.IsSelected = false;
                    }

                    model.Add(userRoleViewModel);
                }
            }

            return(View(model));
        }
コード例 #26
0
        public async Task <IActionResult> EditUserInRole(string roleId)
        {
            try
            {
                ViewBag.roleId = roleId;

                var role = await _roleManager.FindByIdAsync(roleId);

                if (role == null)
                {
                    ViewBag.ErrorMessage = $"Role with Id = {roleId} cannot be found!";
                    return(View("NotFound"));
                }

                var model = new List <UserRoleViewModel>();

                var listUser = _userManager.Users.ToList();

                foreach (var user in listUser)
                {
                    var userRoleViewModel = new UserRoleViewModel()
                    {
                        UserId   = user.Id,
                        UserName = user.UserName,
                    };

                    var isInRole = await _userManager.IsInRoleAsync(user, role.Name);

                    userRoleViewModel.IsSelected = isInRole;

                    model.Add(userRoleViewModel);
                }

                return(View(model));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"When trying to update an user");
                throw;
            }
        }
        public async Task <IActionResult> EditUsersInRole(string roleId)
        {
            ViewBag.roleId = roleId;

            var role = await roleManager.FindByIdAsync(roleId);

            if (role == null)
            {
                ViewBag.ErrorMessage = $"Role with Id= {roleId} cannot be found";
                return(View("NotFound"));
            }

            var model = new List <UserRoleViewModel>();

            // fetch all users
            foreach (var user in userManager.Users)
            {
                var userRoleViewModel = new UserRoleViewModel
                {
                    UserId   = user.Id,
                    UserName = user.UserName
                };


                //check if user has a role
                if (await userManager.IsInRoleAsync(user, role.Name))
                {
                    // set sellected to true
                    userRoleViewModel.IsSelected = true;
                }
                else
                {
                    userRoleViewModel.IsSelected = false;
                }

                model.Add(userRoleViewModel);
            }


            return(View(model));
        }
コード例 #28
0
        public async Task <IActionResult> EditUserInRole(string userid)
        {
            ViewBag.roleid = userid;

            var role = await _rolemanager.FindByIdAsync(userid);

            if (role is null)
            {
                ViewBag.ErrorMessage = $"role with id {userid} cannot be found";
                return(View("NotFound"));
            }

            else
            {
                var model = new List <UserRoleViewModel>();
                foreach (var item in _userManager.Users)
                {
                    var userRoleViewModel = new UserRoleViewModel
                    {
                        UserId   = item.Id,
                        UserName = item.UserName,
                    };


                    if (await _userManager.IsInRoleAsync(item, role.Name))
                    {
                        userRoleViewModel.IsSelected = true;
                    }

                    else
                    {
                        userRoleViewModel.IsSelected = false;
                    }

                    model.Add(userRoleViewModel);
                }


                return(View(model));
            }
        }
コード例 #29
0
        public async Task <IActionResult> Modify(string id)
        {
            // Store the ID from GET request
            ViewBag.id = id;

            // Find associated role ID with GET id
            var role = await _roleManager.FindByIdAsync(id);

            if (role == null)
            {
                return(NotFound());
            }

            // Create a list of the user roles
            var model = new List <UserRoleViewModel>();

            // Loop through database
            foreach (var user in _userManager.Users)
            {
                // Create an instance of the Users
                var userRoleViewModel = new UserRoleViewModel
                {
                    Id       = user.Id,
                    UserName = user.UserName
                };

                // Check if user matches current role
                if (await _userManager.IsInRoleAsync(user, role.Name))
                {
                    userRoleViewModel.IsSelected = true;
                }
                else
                {
                    userRoleViewModel.IsSelected = false;
                }

                // Add to current view model
                model.Add(userRoleViewModel);
            }
            return(View(model));
        }
コード例 #30
0
        public ActionResult Edit(UserRoleViewModel model)
        {
            try
            {
                //change role
                Roles.RemoveUserFromRole(model.UserName, Roles.GetRolesForUser(model.UserName)[0]);
                Roles.AddUserToRole(model.UserName, model.Role);

                //change approvement
                var user = Membership.GetUser(model.UserName);
                user.IsApproved = model.IsApproved;
                if (model.newUserName != model.UserName)
                {
                    var newUser = Membership.CreateUser(model.newUserName, user.GetPassword());
                    newUser.IsApproved = user.IsApproved;
                    newUser.Email      = user.Email;
                    Roles.RemoveUserFromRole(model.UserName, Roles.GetRolesForUser(model.UserName)[0]);
                    Roles.AddUserToRole(model.newUserName, model.Role);
                    Membership.DeleteUser(user.UserName);
                    user = newUser;
                }
                Membership.UpdateUser(user);


                if (Request.IsAjaxRequest())
                {
                    return(Content("Success"));
                }
                else
                {
                    return(Redirect(Request.UrlReferrer.ToString()));
                }
            }
            catch (Exception)
            {
                ModelState.AddModelError("", "Edit Failure, see inner exception");
            }

            //return View(model);
            return(RedirectToAction("Index"));
        }
コード例 #31
0
        public async Task <IActionResult> EditUsersInRole(string roleId)
        {
            ViewBag.roleId = roleId;


            var role = await roleManager.FindByIdAsync(roleId);

            if (role == null)
            {
                ViewBag.ErrorMessage = $"角色id为{roleId}的信息不存在,请重试。";
                return(View("NotFound"));
            }

            var model = new List <UserRoleViewModel>();


            foreach (var user in userManager.Users)
            {
                var userRoleViewmodel = new UserRoleViewModel
                {
                    UserId   = user.Id,
                    UserName = user.UserName
                };

                if (await userManager.IsInRoleAsync(user, role.Name))
                {
                    userRoleViewmodel.IsSelected = true;
                }
                else
                {
                    userRoleViewmodel.IsSelected = false;
                }


                model.Add(userRoleViewmodel);
            }



            return(View(model));
        }
コード例 #32
0
ファイル: UserService.cs プロジェクト: Kiesum/hets
        /// <summary>
        /// Get roles associates with a user
        /// </summary>
        /// <remarks>Returns the roles for a user</remarks>
        /// <param name="id">id of User to fetch</param>
        /// <response code="200">OK</response>
        /// <response code="404">User not found</response>
        public virtual IActionResult UsersIdRolesGetAsync(int id)
        {
            User user = _context.Users
                        .Include(x => x.UserRoles)
                        .ThenInclude(y => y.Role)
                        .First(x => x.Id == id);

            // reord not found
            if (user == null)
            {
                return(new ObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
            }

            List <UserRoleViewModel> result = new List <UserRoleViewModel>();

            List <UserRole> data = user.UserRoles;

            foreach (UserRole item in data)
            {
                if (item != null)
                {
                    int userRoleId = item.Id;

                    bool exists = _context.UserRoles.Any(x => x.Id == userRoleId);

                    if (exists)
                    {
                        UserRole userRole = _context.UserRoles
                                            .Include(x => x.Role)
                                            .First(x => x.Id == userRoleId);

                        UserRoleViewModel record = userRole.ToViewModel();

                        record.UserId = user.Id;
                        result.Add(record);
                    }
                }
            }

            return(new ObjectResult(new HetsResponse(result)));
        }
コード例 #33
0
        public async Task<ActionResult> Delete(int id, UserRoleViewModel viewModel)
        {
            try
            {
	            var role = await _roleService.FindByIdAsync(id);

	            if (role.Users.Any())
	            {
		            ModelState.AddModelError("", "This role cannot be deleted. It has " + role.Users.Count() + " user(s) associated to it.");
		            return View(viewModel);
	            }

	            await _roleService.DeleteAsync(role);

                return RedirectToAction("Index");
            }
            catch
            {
				ModelState.AddModelError("", "An error has occured. This role was not deleted.");
                return View();
            }
        }