public IActionResult AddUserToRole([FromBody] AddUserToRoleRequest request)
{
var client = GetRoleClient();
client.AddUserToRole(request.UserId, request.RoleId);
return(AjaxOkResponse());
}
public async Task AddUserToRole_ShouldAlreadyExists()
{
// Arrange
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var host = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
host.Server.CleanupDbContext();
await host.Server.UsingScopeAsync(
async scope =>
{
var userService = scope.GetRequiredService <IUserService>();
var result = await userService.CreateAsync(user, "Pass@word1");
result.Succeeded.Should().BeTrue();
});
await host.Server.UsingScopeAsync(
async scope =>
{
var roleService = scope.GetRequiredService <IRoleService>();
var result = await roleService.CreateAsync(
new Role
{
Name = AppRoles.Admin
});
result.Succeeded.Should().BeTrue();
});
await host.Server.UsingScopeAsync(
async scope =>
{
var userService = scope.GetRequiredService <IUserService>();
var result = await userService.AddToRoleAsync(await userService.FindByIdAsync(user.Id.ToString()), AppRoles.Admin);
result.Succeeded.Should().BeTrue();
});
var request = new AddUserToRoleRequest
{
UserId = user.Id.ToString(),
RoleName = AppRoles.Admin
};
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
// Act
var func = new Func <Task>(async() => await client.AddUserToRoleAsync(request));
// Assert
func.Should().Throw <RpcException>();
}
public ActionResult AddUserToRole(AddUserToRoleRequest req)
{
try
{
string roleName = req.roleName;
int userId = req.userId;
var cookie = HttpContext.Current.Request.Cookies["sid"];
if (cookie == null)
{
throw new WrongOrExpiredToken();
}
string token = HttpContext.Current.Request.Cookies["sid"].Value;
if (String.IsNullOrWhiteSpace(token))
{
throw new WrongOrExpiredToken();
}
UserInfoExtended info = _authProvider.AuthenticateByToken(token);
if (!info.Roles.Contains("ADMIN"))
{
throw new UnauthorizedAccessException("User has to be admin to perform this action.");
}
_mngr.AddUserToRole(roleName, userId);
_ctx.OutgoingResponse.StatusCode = HttpStatusCode.OK;
return(new ActionResult
{
Message = "User is added to specified role."
});
}
catch (UnauthorizedAccessException e)
{
var myf = new MyFault {
Details = e.Message
};
throw new WebFaultException <MyFault>(myf, HttpStatusCode.Unauthorized);
}
catch (SSOBaseException e)
{
var myf = new MyFault {
Details = e.Message
};
throw new WebFaultException <MyFault>(myf, e.StatusCode);
}
catch (Exception e)
{
var myf = new MyFault {
Details = "There has been an error while performing AddUserToRole action."
};
throw new WebFaultException <MyFault>(myf, HttpStatusCode.InternalServerError);
}
}
public override async Task <AddUserToRoleResponse> AddUserToRole(AddUserToRoleRequest request, ServerCallContext context)
{
var user = await _userService.FindByIdAsync(request.UserId);
if (user == null)
{
throw context.NotFoundRpcException($"The user '{request.UserId}' wasn't found.");
}
if (await _userService.IsInRoleAsync(user, request.RoleName))
{
var existingRole = await _roleService.FindByNameAsync(request.RoleName);
var detail = $"The role '{existingRole.Name}' already exists. (roleId=${existingRole.Id})";
var response = new AddUserToRoleResponse
{
Role = new RoleDto
{
Id = existingRole.Id.ToString(),
Name = existingRole.Name
}
};
return(context.AlreadyExists(response, detail));
}
var result = await _userService.AddToRoleAsync(user, request.RoleName);
if (result.Succeeded)
{
var role = await _roleService.FindByNameAsync(request.RoleName);
var detail = $"The role '{role.Name}' as been created. (roleId=${role.Id})";
var response = new AddUserToRoleResponse
{
Role = new RoleDto
{
Id = role.Id.ToString(),
Name = role.Name
}
};
return(context.Ok(response, detail));
}
throw context.FailedPreconditionRpcException(result, string.Empty);
}
public async Task <IActionResult> AddUserToRole([FromBody] AddUserToRoleRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByNameAsync(request.UserName);
var role = await _roleManager.FindByNameAsync(request.Role);
if (user != null && role != null)
{
await _userManager.AddToRoleAsync(user, request.Role);
}
else
{
return(Ok("Eitehr user or role does not exist!"));
}
return(Ok("Added successfully!"));
}
public void AddUserToRole_ShouldThrowNotFoundRpcException()
{
// Arrange
var userId = new UserId();
const string email = "*****@*****.**";
var claims = new[] { new Claim(JwtClaimTypes.Subject, userId.ToString()), new Claim(JwtClaimTypes.Email, email) };
var host = TestHost.WithClaimsFromBearerAuthentication(claims);
host.Server.CleanupDbContext();
var request = new AddUserToRoleRequest
{
UserId = userId,
RoleName = "test"
};
var client = new IdentityService.IdentityServiceClient(host.CreateChannel());
// Act Assert
var func = new Func <Task>(async() => await client.AddUserToRoleAsync(request));
func.Should().Throw <RpcException>();
}
public Task <BaseResponse> AddUserToRole(AddUserToRoleRequest request, int UserID)
{
throw new NotImplementedException();
}
public async Task <IActionResult> AddUserToRole(AddUserToRoleRequest request, CancellationToken ct)
{
return(Ok(await Mediator.Send(request, ct).ConfigureAwait(false)));
}
