コード例 #1
0
        // PUT api/gateway/removeuserfromrole
        public async Task <IActionResult> RemoveUserFromRole(RemoveUserfromRoleViewModel model, [FromHeader] string authorization)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            HttpParameters httpParameters = HttpParametersService
                                            .GetHttpParameters(
                model,
                ConfigHelper.AppSetting(Constants.ServerUrls, Constants.RemoveUserFromRole),
                HttpMethod.Put,
                string.Empty,
                authorization
                );

            RemoveUserfromRoleResponse removeUserFromRoleResult =
                await _gWService.PostTo <RemoveUserfromRoleResponse>(httpParameters);

            if (removeUserFromRoleResult.StatusCode == 404)
            {
                return(await
                       ResponseService.GetResponse <NotFoundObjectResult, RemoveUserfromRoleResponse>(removeUserFromRoleResult, ModelState));
            }
            else if (removeUserFromRoleResult.StatusCode == 422)
            {
                return(await ResponseService.GetResponse <UnprocessableEntityObjectResult, RemoveUserfromRoleResponse>(removeUserFromRoleResult, ModelState));
            }
            else if (removeUserFromRoleResult.StatusCode == 401)
            {
                return(await ResponseService.GetResponse <UnauthorizedObjectResult, RemoveUserfromRoleResponse>(removeUserFromRoleResult, ModelState));
            }
            else if (removeUserFromRoleResult.StatusCode != 200)
            {
                return(await ResponseService.GetResponse <BadRequestObjectResult, RemoveUserfromRoleResponse>(removeUserFromRoleResult, ModelState));
            }

            return(new OkObjectResult(removeUserFromRoleResult));
        }
コード例 #2
0
        //PUT api/accounts/removeuserfromrole
        public async Task <IActionResult> RemoveUserFromRole([FromBody] RemoveUserfromRoleViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var userId = model.UserId.Trim();
            var role   = model.Role.Trim();

            if (String.IsNullOrEmpty(userId) || String.IsNullOrEmpty(role))
            {
                return(new JsonResult(await Errors
                                      .GetGenericErrorResponse(
                                          new AddUserToRoleResponse()
                {
                    UserId = userId,
                    Email = "no_email",
                    Role = role,
                    StatusCode = 400,
                    Error = "User id  or role can not be empty",
                    Description = "User id or role is empty.",
                    Code = "user_id_or_ role_is_empty"
                })));
            }

            var userExists = await _accountsService.UserExists(userId);

            var roleExists = await _accountsService.RoleExists(role);

            if (!userExists || !roleExists)
            {
                return(new JsonResult(await Errors
                                      .GetGenericErrorResponse(
                                          new AddUserToRoleResponse()
                {
                    UserId = userId,
                    Email = "no_email",
                    Role = role,
                    StatusCode = 404,
                    Error = "User or role is not found",
                    Description = "The user id or the role name does not match a user or a role.",
                    Code = "user_or_role__is_not_found"
                })));
            }

            User userIdentity = await _accountsService.GetUser(userId);

            IdentityRole userRole = await _accountsService.GetRoleByName(role);

            if (await _accountsService.UserHasRole(userIdentity, userRole.Name))
            {
                IdentityResult removeRoleResult = await _accountsService.RemoveRolefromUser(userIdentity, userRole.Name);

                if (!removeRoleResult.Succeeded)
                {
                    return(new JsonResult(await Errors
                                          .GetGenericErrorResponse(
                                              new AddUserToRoleResponse()
                    {
                        UserId = userIdentity.Id,
                        Email = userIdentity.Email,
                        Role = userRole.Name,
                        StatusCode = 400,
                        Error = "Faild to add role to user.",
                        Description = "Faild to add role to user.",
                        Code = "faild_to_remove_role_to_user",
                    })));
                }
            }
            else
            {
                return(new JsonResult(await Errors
                                      .GetGenericErrorResponse(
                                          new AddUserToRoleResponse()
                {
                    UserId = userIdentity.Id,
                    Email = userIdentity.Email,
                    Role = userRole.Name,
                    StatusCode = 400,
                    Error = "User does not have role assigned",
                    Description = "User does not have role assigned.",
                    Code = "user_does_not_have_role_assigned"
                })));
            }

            await _context.SaveChangesAsync();

            return(new JsonResult(
                       Wrappyfier
                       .WrapRemoveUserFromRole(
                           userIdentity.Id,
                           userIdentity.Email,
                           role,
                           200)));
        }