public async Task Test_permissions_can_be_retrieved()
{
var newRoleRequest = new RoleCreateRequest
{
Name = $"{Guid.NewGuid():N}role",
Description = $"{Guid.NewGuid():N}description",
};
var role = await _apiClient.Roles.CreateAsync(newRoleRequest);
var assignPermissionsRequest = new AssignPermissionsRequest
{
Permissions = new List <PermissionIdentity>
{
new PermissionIdentity {
Name = "dotnet:testing", Identifier = "dotnet-testing",
}
}
};
await _apiClient.Roles.AssignPermissionsAsync(role.Id, assignPermissionsRequest);
var userPermissions = await _apiClient.Roles.GetPermissionsAsync(role.Id, new PaginationInfo(0, 50, true));
Assert.Equal(1, userPermissions.Count);
await _apiClient.Roles.RemovePermissionsAsync(role.Id, assignPermissionsRequest);
await _apiClient.Roles.DeleteAsync(role.Id);
}
public async Task <IActionResult> PutRole(string id, [FromBody] RoleCreateRequest roleVm)
{
if (id != roleVm.Id)
{
return(BadRequest(new ApiBadRequestResponse(_localizer["RoleNotMatch"])));
}
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound(new ApiNotFoundResponse(_localizer["FindRoleErr"] + id)));
}
role.Name = roleVm.Name;
role.NormalizedName = roleVm.Name.ToUpper();
var result = await _roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(NoContent());
}
return(BadRequest(new ApiBadRequestResponse(result)));
}
public async Task <IActionResult> PutRole(string id, RoleCreateRequest request)
{
//// IF ID(request.ID) INPUT AND id (KEY OF ROLE WHICH NEED UPDATE) ARE DIFFERENT, RETURN STATUS 400
if (id != request.Id)
{
return(BadRequest(new ApiBadRequestResponse("Role id not match")));
}
//// GET ROLE WITH ID
var role = await _roleManger.FindByIdAsync(id);
//// IF ID IS NOT EXIST (ROLE IS NULL), RETURN STATUS 404
if (role == null)
{
return(NotFound(new ApiNotFoundResponse($"Cannot find role with id: {id}")));
}
//// GIVE INPUT DATA FOR EACH FIELD OF OBJECT WHICH NEED UPDATE INFOMATIONS
role.Name = request.Name;
role.NormalizedName = request.Name.ToUpper();
//// UPDATE ROLE AND SAVE CHANGE INTO DATATABLE OF DATABASE
var result = await _roleManger.UpdateAsync(role);
//// IF RESULT AFTER UPDATE IS SUCCEEDED, UPDATE SUCCESS AND RETURN STATUS 204, ELSE RETURN STATUS 400
if (result.Succeeded)
{
return(NoContent());
}
return(BadRequest(new ApiBadRequestResponse(result)));
}
public async Task <IActionResult> PutRole(string id, [FromBody] RoleCreateRequest request) // id lấy ở routing, còn roleVm lấy từ Body
{
if (!ModelState.IsValid)
{ // re-render the view when validation failed.
return(BadRequest(ModelState));
}
if (id != request.Id)
{
return(BadRequest());
}
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound()); //400
}
role.Name = request.Name;
role.NormalizedName = request.Name.ToUpper();
var result = await _roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(NoContent()); //204 success without no content response
}
return(BadRequest(result.Errors));
}
public async Task <IActionResult> PutRole(string id, [FromBody] RoleCreateRequest roleVm)
{
if (id != roleVm.Id)
{
return(BadRequest(new ApiBadRequestResponse("Role id not match")));
}
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound(new ApiNotFoundResponse($"Cannot find role with id: {id}")));
}
role.Name = roleVm.Name;
role.NormalizedName = roleVm.Name.ToUpper();
var result = await _roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(NoContent());
}
return(BadRequest(new ApiBadRequestResponse(result)));
}
public async Task <IActionResult> PutRole(string id, [FromBody] RoleCreateRequest request)
{
if (id != request.Id)
{
return(BadRequest());
}
var role = await _manager.FindByIdAsync(id);
if (role == null)
{
return(NotFound());
}
role.Name = request.Name;
role.NormalizedName = request.Name.ToUpper();
var result = await _manager.UpdateAsync(role);
if (result.Succeeded)
{
return(NoContent());
}
return(BadRequest(result.Errors));
}
public RoleCreateRequestValidatorTest()
{
request = new RoleCreateRequest()
{
Id = "admin",
Name = "admin"
};
validator = new RoleCreateRequestValidator();
}
public async Task Test_roles_assign_role_to_user()
{
// Add a new role
var newRoleRequest = new RoleCreateRequest
{
Name = $"{Guid.NewGuid():N}role",
Description = $"{Guid.NewGuid():N}description",
};
var role = await _apiClient.Roles.CreateAsync(newRoleRequest);
role.Should().NotBeNull();
role.Name.Should().Be(newRoleRequest.Name);
role.Description.Should().Be(newRoleRequest.Description);
// Create a user
var newUserRequest = new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
};
var user = await _apiClient.Users.CreateAsync(newUserRequest);
// Assign a user to the role
var assignRolesRequest = new AssignRolesRequest()
{
Roles = new[]
{
role.Id
}
};
await _apiClient.Users.AssignRolesAsync(user.UserId, assignRolesRequest);
// Ensure the Role is assigned to user
var assignedRoles = await _apiClient.Users.GetRolesAsync(user.UserId, new PaginationInfo());
assignedRoles.Should().NotBeNull();
assignedRoles.Should().HaveCount(1);
assignedRoles.First().Id.Should().Be(role.Id);
// Remove role from user
await _apiClient.Users.RemoveRolesAsync(user.UserId, assignRolesRequest);
// Ensure the Role has been removed from user
var removedRoles = await _apiClient.Users.GetRolesAsync(user.UserId, new PaginationInfo());
removedRoles.Should().NotBeNull();
removedRoles.Should().HaveCount(0);
// Clean Up
await _apiClient.Roles.DeleteAsync(role.Id);
await _apiClient.Users.DeleteAsync(user.UserId);
}
public async Task <IActionResult> PostRole(RoleCreateRequest request)
{
var role = _mapper.Map <AppRole>(request);
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(CreatedAtAction(nameof(GetById), new { id = role.Id }, request));
}
return(BadRequest(new ApiBadRequestResponse(result)));
}
public RoleCreateReply RoleCreate(RoleCreateRequest request)
{
try
{
RoleCreateReply response = new RoleCreateReply();
_roles.CreateRole(request.RoleName);
response.Status = ActionStatus.OK;
return(response);
}
catch (Exception ex)
{
throw ex.NewFault();
}
}
public RoleCreateRequestValidatorTest()
{
_request = new RoleCreateRequest
{
Id = "admin",
Name = "admin"
};
var mock = new Mock <IStringLocalizer <RoleCreateRequest> >();
var localizedString = new LocalizedString("", "");
mock.Setup(_ => _[""]).Returns(localizedString);
var localizer = mock.Object;
_validator = new RoleCreateRequestValidator(localizer);
}
public async Task <IActionResult> GetById(string id)
{
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound());
}
var roleVm = new RoleCreateRequest
{
Id = role.Id,
Name = role.Name
};
return(Ok(roleVm));
}
public async Task <IActionResult> PostRole(RoleCreateRequest roleVm)
{
var role = new IdentityRole
{
Id = roleVm.Id,
Name = roleVm.Name,
NormalizedName = roleVm.Name.ToUpper()
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(CreatedAtAction(nameof(GetById), new { id = role.Id }, roleVm));
}
return(BadRequest(result.Errors));
}
public async Task <UpdateStatusViewModel> Create(RoleCreateRequest request)
{
var sessions = Core.Token;
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", sessions);
var json = JsonConvert.SerializeObject(request);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await _client.PostAsync($"/api/Roles", httpContent);
var result = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <UpdateStatusViewModel>(result));
}
return(null);
}
public async Task Test_roles_assign_user_to_role()
{
// Add a new role
var newRoleRequest = new RoleCreateRequest
{
Name = $"{Guid.NewGuid():N}role",
Description = $"{Guid.NewGuid():N}description",
};
var role = await _apiClient.Roles.CreateAsync(newRoleRequest);
role.Should().NotBeNull();
role.Name.Should().Be(newRoleRequest.Name);
role.Description.Should().Be(newRoleRequest.Description);
// Create a user
var newUserRequest = new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
};
var user = await _apiClient.Users.CreateAsync(newUserRequest);
// Assign a user to the role
var assignUsersRequest = new AssignUsersRequest
{
Users = new[]
{
user.UserId
}
};
await _apiClient.Roles.AssignUsersAsync(role.Id, assignUsersRequest);
// Ensure the user is assigned to the role
var assignedUsers = await _apiClient.Roles.GetUsersAsync(role.Id);
assignedUsers.Should().NotBeNull();
assignedUsers.First().UserId.Should().Be(user.UserId);
// Clean Up
await _apiClient.Roles.DeleteAsync(role.Id);
await _apiClient.Users.DeleteAsync(user.UserId);
}
public async Task <ApiResultLite> CreateAsync(RoleCreateRequest model)
{
var role = new AppRole()
{
Name = model.Name,
Description = model.Description
};
IdentityResult result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(new ApiSuccessResultLite("Tạo mới thành công"));
}
else
{
return(new ApiErrorResultLite("Tạo mới thất bại"));
}
}
public override void CreateRole(string roleName)
{
WcfClientUtils.VerifyParameter("roleName", roleName);
//using (_log.NewTrace())
{
try
{
RoleCreateRequest request = new RoleCreateRequest();
request.RoleName = roleName;
request.ServiceSessionToken = _authenticationKey;
var response = _appService.RoleCreate(request);
}
catch (Exception ex)
{
throw WcfUtils.Extract(ex);
}
}
}
public async Task <IActionResult> PostRole(RoleCreateRequest request)
{
var role = new IdentityRole()
{
Id = request.Id,
Name = request.Name,
NormalizedName = request.Name.ToUpper()
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(CreatedAtAction(nameof(GetById), new { id = role.Id }, request));
}
else
{
return(BadRequest(new ApiBadRequestResponse(result)));
}
}
public async Task <IActionResult> CreateRole(RoleCreateRequest request)
{
//Creazione modello richiesto da admin
var model = new Role
{
Name = request.Name,
Description = request.Description
};
//Invocazione del service layer
var validations = await AuthorizationLayer.CreateRole(model, PlatformUtils.GetIdentityUserId(User));
if (validations.Count > 0)
{
return(BadRequest(validations));
}
//Return contract
return(Ok(ContractUtils.GenerateContract(model)));
}
/// <summary>
/// Post the specified request.
/// </summary>
/// <param name="request">Request.</param>
public object Post(RoleCreateRequest request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.AdminOnly);
WebRole result;
try{
context.Open();
Role role = (request.Id == 0 ? null : Role.FromId(context, request.Id));
role = request.ToEntity(context, role);
role.Store();
result = new WebRole(role);
context.LogInfo(this, string.Format("/role POST Id='{0}'", request.Id));
context.LogDebug(this, string.Format("Role {0} created by user {1}", role.Identifier, User.FromId(context, context.UserId).Username));
context.Close();
}catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(result);
}
public async Task <IActionResult> DeleteRole(string id)
{
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound());
}
var result = await _roleManager.DeleteAsync(role);
if (result.Succeeded)
{
var rolevm = new RoleCreateRequest()
{
Id = role.Id,
Name = role.Name
};
return(Ok(rolevm));
}
return(BadRequest(result.Errors));
}
public async Task <IActionResult> PostRole(RoleCreateRequest request)
{
if (!ModelState.IsValid)
{ // re-render the view when validation failed.
return(BadRequest(ModelState));
}
var role = new IdentityRole()
{
Id = request.Id,
Name = request.Name,
NormalizedName = request.Name.ToUpper()
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(CreatedAtAction(nameof(GetById), new { id = role.Id }, request));
}
else
{
return(BadRequest(result.Errors));
}
}
public async Task <IActionResult> PostRole(RoleCreateRequest request)
{
//// CREATE A INSTANCE OF ROLE WITH INFO IS INPUT DATA
var role = new IdentityRole()
{
Id = request.Id,
Name = request.Name,
NormalizedName = request.Name.ToUpper()
};
//// INSERT NEW ROLE INTO DATATABLE IN DATABASE AND SAVE CHANGE
var result = await _roleManger.CreateAsync(role);
//// IF RESULT AFTER INSERT IS SUCCEEDED, INSERT SUCCESS AND RETURN STATUS 201, ELSE RETURN STATUS IS 400.
if (result.Succeeded)
{
return(CreatedAtAction(nameof(GetById), new { id = role.Id }, request));
}
else
{
return(BadRequest(new ApiBadRequestResponse(result)));
}
}
public async Task Test_roles_crud_sequence()
{
// Add a new role
var newRoleRequest = new RoleCreateRequest
{
Name = $"{Guid.NewGuid():N}role",
Description = $"{Guid.NewGuid():N}description",
};
var newRoleResponse = await _apiClient.Roles.CreateAsync(newRoleRequest);
newRoleResponse.Should().NotBeNull();
newRoleResponse.Name.Should().Be(newRoleRequest.Name);
newRoleResponse.Description.Should().Be(newRoleRequest.Description);
// Update the role
var updateRoleRequest = new RoleUpdateRequest
{
Name = $"{Guid.NewGuid():N}role",
};
var updateRoleResponse = await _apiClient.Roles.UpdateAsync(newRoleResponse.Id, updateRoleRequest);
updateRoleResponse.Should().NotBeNull();
updateRoleResponse.Name.Should().Be(updateRoleRequest.Name);
// Get a single role
var role = await _apiClient.Roles.GetAsync(newRoleResponse.Id);
role.Should().NotBeNull();
role.Name.Should().Be(updateRoleResponse.Name);
// Create a user
var newUserRequest = new UserCreateRequest
{
Connection = _connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
};
var user = await _apiClient.Users.CreateAsync(newUserRequest);
// Assign a user to the role
var assignUsersRequest = new AssignUsersRequest
{
Users = new[]
{
user.UserId
}
};
await _apiClient.Roles.AssignUsersAsync(role.Id, assignUsersRequest);
// Ensure the user is assigned to the role
var assignedUsers = await _apiClient.Roles.GetUsersAsync(role.Id);
assignedUsers.Should().NotBeNull();
assignedUsers.First().UserId.Should().Be(user.UserId);
// Ensure the Role is assigned to user
var assignedRoles = await _apiClient.Users.GetRolesAsync(user.UserId, new PaginationInfo());
assignedRoles.Should().NotBeNull();
assignedRoles.First().Id.Should().Be(role.Id);
// Delete the role and ensure we get an exception when trying to fetch them again
await _apiClient.Roles.DeleteAsync(role.Id);
Func <Task> getFunc = async() => await _apiClient.Roles.GetAsync(role.Id);
getFunc.Should().Throw <ErrorApiException>().And.ApiError.Error.Should().Be("Not Found");
// Delete the user
await _apiClient.Users.DeleteAsync(user.UserId);
}
public async Task Test_roles_assign_unassign_permission_to_role()
{
// Add a new role
var newRoleRequest = new RoleCreateRequest
{
Name = $"{Guid.NewGuid():N}role",
Description = $"{Guid.NewGuid():N}description",
};
var role = await _apiClient.Roles.CreateAsync(newRoleRequest);
role.Should().NotBeNull();
role.Name.Should().Be(newRoleRequest.Name);
role.Description.Should().Be(newRoleRequest.Description);
// Get a resource server
var resourceServer = await _apiClient.ResourceServers.GetAsync("5cccc711773967081270a036");
var originalScopes = resourceServer.Scopes.ToList();
// Create a permission/scope
var newScope = new ResourceServerScope {
Value = $"{Guid.NewGuid():N}scope", Description = "Integration test"
};
// Update resource server with new scope
resourceServer = await _apiClient.ResourceServers.UpdateAsync(resourceServer.Id, new ResourceServerUpdateRequest
{
Scopes = originalScopes.Concat(new[] { newScope }).ToList(),
});
// Associate a permission with the role
var assignPermissionsRequest = new AssignPermissionsRequest()
{
Permissions = new[] { new PermissionIdentity {
Identifier = resourceServer.Identifier, Name = newScope.Value
} }
};
await _apiClient.Roles.AssignPermissionsAsync(role.Id, assignPermissionsRequest);
// Ensure the permission is associated with the role
var associatedPermissions = await _apiClient.Roles.GetPermissionsAsync(role.Id, new PaginationInfo());
associatedPermissions.Should().NotBeNull();
associatedPermissions.Should().HaveCount(1);
associatedPermissions.First().Identifier.Should().Be(resourceServer.Identifier);
associatedPermissions.First().Name.Should().Be(newScope.Value);
// Unassociate a permission with the role
await _apiClient.Roles.RemovePermissionsAsync(role.Id, assignPermissionsRequest);
// Ensure the permission is unassociated with the role
associatedPermissions = await _apiClient.Roles.GetPermissionsAsync(role.Id, new PaginationInfo());
associatedPermissions.Should().NotBeNull();
associatedPermissions.Should().HaveCount(0);
// Clean Up - Remove the permission from the resource server
resourceServer = await _apiClient.ResourceServers.UpdateAsync(resourceServer.Id, new ResourceServerUpdateRequest
{
Scopes = originalScopes
});
// Clean Up - Remove the role
await _apiClient.Roles.DeleteAsync(role.Id);
}
public async Task <UpdateStatusViewModel> Create(RoleCreateRequest request)
{
var result = await _apiClient.Create(request);
return(result);
}
/// <summary>
/// Creates a new role according to the request.
/// </summary>
/// <param name="request">The <see cref="RoleCreateRequest"/> containing the details of the role to create.</param>
/// <returns>The newly created <see cref="Role" />.</returns>
public Task <Role> CreateAsync(RoleCreateRequest request)
{
return(Connection.SendAsync <Role>(HttpMethod.Post, BuildUri("roles"), request, DefaultHeaders));
}
/// <summary>
/// Creates a new role according to the request.
/// </summary>
/// <param name="request">The <see cref="RoleCreateRequest"/> containing the details of the role to create.</param>
/// <returns>The newly created <see cref="Role" />.</returns>
public Task <Role> CreateAsync(RoleCreateRequest request)
{
return(Connection.PostAsync <Role>("roles", request, null, null, null, null, null));
}
public async Task <ApiResultLite> CreateAsync(RoleCreateRequest model)
{
var result = await _roleService.CreateAsync(model);
return(result);
}
public async Task <ActionResult <bool> > CreateRole(RoleCreateRequest request)
{
var response = await _roleService.CreateRole(request.RoleName);
return(response.ToActionResult(this));
}
