Example #1
0
        public async Task <IActionResult> AssignPermissionPartial(AssignPermissionInput assignPermissionInput)
        {
            WebCoreUser user = userService.GetById(new EntityId <string>()
            {
                Id = assignPermissionInput.UserId
            });

            if (user == null)
            {
                return(Ok(new { result = ConstantConfig.WebApiStatusCode.Error, message = GetLang(ConstantConfig.WebApiResultMessage.Error) }));
            }
            bool success = await userService.UpdatePermissionsAsync(assignPermissionInput);

            if (success)
            {
                return(Ok(new { result = ConstantConfig.WebApiStatusCode.Success, message = GetLang(ConstantConfig.WebApiResultMessage.UpdateSuccess) }));
            }
            else
            {
                return(Ok(new { result = ConstantConfig.WebApiStatusCode.Error, message = GetLang(ConstantConfig.WebApiResultMessage.Error) }));
            }
        }
Example #2
0
        public async Task <bool> UpdatePermissionsAsync(AssignPermissionInput assignPermissionInput)
        {
            WebCoreUser user = userRepository.GetById(assignPermissionInput.UserId);

            string[] viewRoles = assignPermissionInput.Roles;

            EntityId <string> userIdModel = new EntityId <string>()
            {
                Id = assignPermissionInput.UserId
            };

            List <RoleDto> allRoles = await GetAllRolesAsync(userIdModel);

            string[] allUserRoles = allRoles.Where(x => x.IsChecked).Select(x => x.RoleName).ToArray();


            HashSet <string> allClaims       = permissionService.GetAllPermissions();
            IList <Claim>    allClaimsOfUser = await userManager.GetClaimsAsync(user);

            string[] viewClaims = assignPermissionInput.Permissions;

            if (viewRoles.Any(vr => allRoles.Count(r => r.RoleName == vr) == 0))
            {
                return(false);
            }

            if (viewClaims.Any(vc => allClaims.Count(ac => ac == vc) == 0))
            {
                return(false);
            }

            // roles need delete
            List <string> rolesNeedDelete = allUserRoles
                                            .Where(ur => viewRoles.Count(vr => vr == ur) == 0)
                                            .ToList();

            // roles need add
            List <string> rolesNeedAdd = viewRoles
                                         .Where(vr => allUserRoles.Count(ur => ur == vr) == 0)
                                         .ToList();

            foreach (string roleName in rolesNeedDelete)
            {
                await userManager.RemoveFromRoleAsync(user, roleName);
            }

            foreach (string roleName in rolesNeedAdd)
            {
                await userManager.AddToRoleAsync(user, roleName);
            }



            // claims need delete
            IList <Claim> claimsNeedDelete = allClaimsOfUser
                                             .Where(uc => viewClaims.Count(vc => vc == uc.Value) == 0)
                                             .ToList();

            // claims need add
            List <string> claimsNeedAdd = viewClaims
                                          .Where(vc => allClaimsOfUser.Count(uc => vc == uc.Value) == 0)
                                          .ToList();


            foreach (string claim in claimsNeedAdd)
            {
                await userManager.AddClaimAsync(user, new Claim(ConstantConfig.ClaimType.Permission, claim));
            }

            foreach (var claim in claimsNeedDelete)
            {
                await userManager.RemoveClaimAsync(user, claim);
            }

            return(true);
        }