public async Task <GetRoleResponse> GetRole(GetRoleRequest request)
{
var response = new GetRoleResponse();
var roles = await _cache.Roles();
var permissions = await _cache.Permissions();
var rolePermissions = await _cache.RolePermissions();
var role = roles.FirstOrDefault(r => r.Id == request.RoleId);
if (role == null)
{
response.Notifications.AddError($"Could not find role with Id {request.RoleId}");
return(response);
}
var rolesPermissions = rolePermissions.Where(rc => rc.Role_Id == request.RoleId).Select(rc => rc.Permission_Id);
response.Role = role;
response.Permissions = permissions.Where(c => rolesPermissions.Contains(c.Id)).ToList();
response.Role = role;
return(response);
}
public async Task <IActionResult> GetRole([FromQuery] String roleName,
CancellationToken cancellationToken)
{
GetRoleResponse result = await this.Manager.GetRoleByName(roleName, cancellationToken);
return(this.Ok(result));
}
public async Task CreateRoleAsync_Should_Return_CreatedAtRouteResult_With_GetRoleResponse()
{
var createRoleRequest = new CreateRoleRequest {
Name = DefaultRoleEnumeration.Administrator.DisplayName
};
var createRoleCommand = new CreateRoleCommand(Guid.NewGuid(), createRoleRequest.Name);
var roleOutputQuery = new RoleOutputQuery(createRoleCommand.RoleId, Array.Empty <byte>(), createRoleCommand.Name);
var getRoleResponse = new GetRoleResponse(roleOutputQuery.Id, roleOutputQuery.RowVersion, roleOutputQuery.Name);
_mapperMock.Setup(x => x.Map <CreateRoleRequest, CreateRoleCommand>(It.IsAny <CreateRoleRequest>())).Returns(createRoleCommand);
_communicationBusMock.Setup(x => x.SendCommandAsync(It.IsAny <CreateRoleCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
_getRoleQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetRoleInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(roleOutputQuery);
_mapperMock.Setup(x => x.Map <RoleOutputQuery, GetRoleResponse>(It.IsAny <RoleOutputQuery>())).Returns(getRoleResponse);
var result = await _controller.CreateRoleAsync(createRoleRequest);
var createdAtRouteResult = result.As <CreatedAtRouteResult>();
createdAtRouteResult.Value.Should().BeEquivalentTo(getRoleResponse);
createdAtRouteResult.RouteName.Should().BeEquivalentTo("GetRole");
createdAtRouteResult.RouteValues.Should().BeEquivalentTo(new Microsoft.AspNetCore.Routing.RouteValueDictionary(new { id = roleOutputQuery.Id }));
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
GetRoleResponse response = new GetRoleResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.IsStartElement)
{
if (context.TestExpression("GetRoleResult", 2))
{
UnmarshallResult(context, response);
continue;
}
if (context.TestExpression("ResponseMetadata", 2))
{
response.ResponseMetadata = ResponseMetadataUnmarshaller.Instance.Unmarshall(context);
}
}
}
return(response);
}
public async Task UpdateRoleAsync_Should_Return_OkObjectResult_With_GetRoleResponse()
{
var rowVersion = new byte[] { 1, 2, 4, 8, 16, 32 };
var roleId = Guid.NewGuid();
var updateRoleRequest = new UpdateRoleRequest
{
Id = roleId,
Name = DefaultRoleEnumeration.Administrator.DisplayName
};
var updateRoleCommand = new UpdateRoleCommand(updateRoleRequest.Id, rowVersion, updateRoleRequest.Name);
var roleOutputQuery = new RoleOutputQuery(updateRoleRequest.Id, new byte[] { 1, 2, 4, 8, 16, 64 }, updateRoleRequest.Name);
var getRoleResponse = new GetRoleResponse(roleOutputQuery.Id, roleOutputQuery.RowVersion, roleOutputQuery.Name);
_mapperMock.Setup(x => x.Map <UpdateRoleRequest, UpdateRoleCommand>(It.IsAny <UpdateRoleRequest>())).Returns(updateRoleCommand);
_communicationBusMock.Setup(x => x.SendCommandAsync(It.IsAny <UpdateRoleCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
_getRoleQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetRoleInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(roleOutputQuery);
_mapperMock.Setup(x => x.Map <RoleOutputQuery, GetRoleResponse>(It.IsAny <RoleOutputQuery>())).Returns(getRoleResponse);
var result = await _controller.UpdateRoleAsync(roleId, updateRoleRequest, rowVersion);
var okObjectResult = result.As <OkObjectResult>();
okObjectResult.Value.Should().BeEquivalentTo(getRoleResponse);
}
private static void UnmarshallResult(XmlUnmarshallerContext context, GetRoleResponse response)
{
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth += 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("Role", targetDepth))
{
var unmarshaller = RoleUnmarshaller.Instance;
response.Role = unmarshaller.Unmarshall(context);
continue;
}
}
}
return;
}
public GetRoleResponse GetRole(Guid id)
{
IRoleService roleService = IoC.Container.Resolve <IRoleService>();
GetRoleResponse role = roleService.Get(id);
return(role);
}
public JsonResult GetRoles()
{
Logger.Current.Verbose("Request for getting roles");
GetRoleResponse response = userService.GetRoles(new GetRoleRequest()
{
AccountId = this.Identity.ToAccountID()
});
if (!this.Identity.IsSTAdmin())
{
if (response.SubscriptionId == 2)
{
response.Roles = response.Roles.Where(s => s.RoleName != "Account Administrator");
}
else
{
response.Roles = response.Roles.Where(s => s.RoleName != "Account Administrator" && s.RoleName != "Marketing Administrator" && s.RoleName != "Sales Administrator" && s.RoleName != "Marketing");
}
}
return(Json(new
{
success = true,
response = response.Roles
}, JsonRequestBehavior.AllowGet));
}
public GetRoleResponse GetTeamRole(string OperationTeamDataId, string operationNumber)
{
var Response = new GetRoleResponse();
Response = _missionService.GetTeamRole(OperationTeamDataId, operationNumber);
return(Response);
}
public static PutRoleRequest ToPutRequest(this GetRoleResponse response)
{
var model = MapModel(response);
return(new PutRoleRequest {
Data = model, Id = response.Data.Id
});
}
public static PostRoleRequest ToPostRequest(this GetRoleResponse response)
{
var model = MapModel(response);
return(new PostRoleRequest {
Data = model
});
}
public async Task ThenTheRoleDetailsShouldBeReturned()
{
HttpResponseMessage httpResponse = this.ScenarioContext.Get <HttpResponseMessage>("GetRoleHttpResponse");
httpResponse.StatusCode.ShouldBe(HttpStatusCode.OK);
GetRoleResponse responseData = JsonConvert.DeserializeObject <GetRoleResponse>(await httpResponse.Content.ReadAsStringAsync());
}
private static SaveRoleModel MapModel(GetRoleResponse response)
{
var model = new SaveRoleModel
{
Version = response.Data.Version,
Name = response.Data.Name,
Description = response.Data.Description,
};
return(model);
}
public GetRoleResponse GetRoleById(GetRoleRequest request)
{
GetRoleResponse response = new GetRoleResponse();
SecurityBusinessComponent bc = DependencyInjectionHelper.GetSecurityBusinessComponent();
Role role = bc.GetRoleById(request.RoleId);
response.Role = SecurityAdapter.RoleToDTO(role);
return(response);
}
private static SaveRoleModel MapModel(GetRoleResponse response)
{
var model = new SaveRoleModel
{
Version = response.Data.Version,
Name = response.Data.Name,
Description = response.Data.Description,
};
return model;
}
public GetRoleResponse Get(GetRoleRequest request)
{
GetRoleResponse response = new GetRoleResponse();
Role role = _roleRepository.Get(request.Id);
response.SystemRole = role.SystemRole;
response.RolesUpdateModel = Mapper.Map <RolesUpdateModel>(role);
return(response);
}
public void Security_Role_DeleteRole_ShouldBeSuccess_WithValidRequest()
{
string name = "name of role" + Guid.NewGuid();
string description = "desc of role";
IList <Guid> permissions = new List <Guid>();
CreateRoleResponse createRoleResponse = this.CreateRole(name, description, permissions);
IRoleService roleService = IoC.Container.Resolve <IRoleService>();
roleService.Delete(createRoleResponse.Id);
GetRoleResponse roleRespone = roleService.Get(createRoleResponse.Id);
Assert.IsNull(roleRespone);
}
public GetRoleResponse Get(Guid id)
{
IRoleRepository repository = IoC.Container.Resolve <IRoleRepository>();
IPermissionRepository perRepo = IoC.Container.Resolve <IPermissionRepository>();
GetRoleResponse response = repository.GetById <GetRoleResponse>(id.ToString());
IList <Permission> rolerPermissions = perRepo.GetByRoleId(id.ToString());
foreach (Permission per in rolerPermissions)
{
response.Permissions.Add(per.Id);
}
return(response);
}
private static string PrepareExpectedResponse(RoleEntity roleEntity)
{
var getRoleResponse = new GetRoleResponse(roleEntity.Id, roleEntity.RowVersion, roleEntity.Name);
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultTestPlatformContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
};
return(JsonConvert.SerializeObject(getRoleResponse, settings));
}
public JsonResult GetDetail(System.Int32 id)
{
RoleDetailView vm = new RoleDetailView();
GetRoleRequest request = new GetRoleRequest();
request.RoleId = id;
GetRoleResponse response = _roleService.GetRole(request);
if (response.RoleFound)
{
vm = response.Role.ConvertToRoleDetailView();
}
return(Json(vm, JsonRequestBehavior.AllowGet));
}
public void TestGetRole()
{
int roleId = 1;
GetRoleResponse response = new GetRoleResponse();
response.Role = new RoleDTO()
{
Id = roleId
};
Expect.Once.On(service).Method("GetRoleById").Will(Return.Value(response));
RoleDTO role = serviceFacade.GetRoleById(roleId);
Assert.AreEqual(role.Id, roleId);
}
public override async Task <GetRoleResponse> GetRole(GetRoleRequest request, ServerCallContext context)
{
var role = await _authorizationApp.GetRoleAsync(request.Id);
var permissionIds = role.PermissionIds.Select(x => (GuidRequired)x);
var result = new GetRoleResponse
{
Id = role.Id,
Name = role.Name,
IsEnabled = role.IsEnabled,
};
result.PermissionIds.AddRange(permissionIds);
return(result);
}
private static async Task <string> PrepareExpectedResponseAsync(RivaIdentityDbContext context, string roleName)
{
var roleEntity = await context.Roles.SingleOrDefaultAsync(x => x.Name.Equals(roleName));
var getRoleResponse = new GetRoleResponse(roleEntity.Id, roleEntity.RowVersion, roleEntity.Name);
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultTestPlatformContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
};
return(JsonConvert.SerializeObject(getRoleResponse, settings));
}
public async Task GetRoleAsync_Should_Return_OkObjectResult_With_GetRoleResponse()
{
var roleOutputQuery = new RoleOutputQuery(Guid.NewGuid(), Array.Empty <byte>(),
DefaultRoleEnumeration.Administrator.DisplayName);
var getRoleResponse = new GetRoleResponse(roleOutputQuery.Id, roleOutputQuery.RowVersion, roleOutputQuery.Name);
_getRoleQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetRoleInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(roleOutputQuery);
_mapperMock.Setup(x => x.Map <RoleOutputQuery, GetRoleResponse>(It.IsAny <RoleOutputQuery>())).Returns(getRoleResponse);
var result = await _controller.GetRoleAsync(roleOutputQuery.Id);
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(getRoleResponse);
}
public IResponseData <GetRoleResponse> GetRole(Guid id)
{
IResponseData <GetRoleResponse> response = new ResponseData <GetRoleResponse>();
try
{
IRoleService roleService = IoC.Container.Resolve <IRoleService>();
GetRoleResponse role = roleService.Get(id);
response.SetData(role);
}
catch (ValidationException ex)
{
response.SetErrors(ex.Errors);
response.SetStatus(System.Net.HttpStatusCode.PreconditionFailed);
}
return(response);
}
public RoleDTO GetRoleById(int id)
{
try
{
GetRoleRequest request = new GetRoleRequest();
request.RoleId = id;
GetRoleResponse response = Service.GetRoleById(request);
return(response.Role);
}
catch (Exception ex)
{
if (ExceptionPolicy.HandleException(ex, "PL Policy"))
{
throw;
}
return(new RoleDTO());
}
}
public static GetRoleResponse Unmarshall(UnmarshallerContext context)
{
GetRoleResponse getRoleResponse = new GetRoleResponse();
getRoleResponse.HttpResponse = context.HttpResponse;
getRoleResponse.RequestId = context.StringValue("GetRole.RequestId");
GetRoleResponse.GetRole_Role role = new GetRoleResponse.GetRole_Role();
role.RoleId = context.StringValue("GetRole.Role.RoleId");
role.RoleName = context.StringValue("GetRole.Role.RoleName");
role.Arn = context.StringValue("GetRole.Role.Arn");
role.Description = context.StringValue("GetRole.Role.Description");
role.AssumeRolePolicyDocument = context.StringValue("GetRole.Role.AssumeRolePolicyDocument");
role.CreateDate = context.StringValue("GetRole.Role.CreateDate");
role.UpdateDate = context.StringValue("GetRole.Role.UpdateDate");
getRoleResponse.Role = role;
return(getRoleResponse);
}
/// <summary>
/// Gets the name of the role by.
/// </summary>
/// <param name="roleName">Name of the role.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <GetRoleResponse> GetRoleByName(String roleName,
CancellationToken cancellationToken)
{
GetRoleResponse response = null;
using (HttpClient client = new HttpClient())
{
String uri = $"{ConfigurationReader.GetBaseServerUri("SecurityService")}api/role?roleName={roleName}";
HttpResponseMessage httpResponse = await client.GetAsync(uri, CancellationToken.None).ConfigureAwait(false);
Logger.LogInformation($"Status Code: {httpResponse.StatusCode}");
String responseContent = await this.HandleResponse(httpResponse, cancellationToken);
response = JsonConvert.DeserializeObject <GetRoleResponse>(responseContent);
}
return(response);
}
public GetRoleResponse GetRole(GetRoleRequest request)
{
GetRoleResponse response = new GetRoleResponse();
Role role = _roleRepository
.FindBy(request.RoleId);
if (role != null)
{
response.RoleFound = true;
response.Role = role.ConvertToRoleView();
}
else
{
response.RoleFound = false;
}
return(response);
}
public ActionResult Update(Guid id)
{
GetRoleResponse response = _roleService.Get(new GetRoleRequest()
{
Id = id
});
if (response.HasError)
{
return(HttpNotFound());
}
if (response.SystemRole)
{
return(RedirectToAction("index")
.AndAlert(AlertType.Danger, "Invalid Operation.", "System roles cannot be modified."));
}
return(View(response.RolesUpdateModel));
}
/// <summary>
/// Gets the name of the role by.
/// </summary>
/// <param name="roleName">Name of the role.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
/// <exception cref="NotFoundException">No role found with name {roleName}</exception>
/// <exception cref="NotImplementedException"></exception>
public async Task <GetRoleResponse> GetRoleByName(String roleName,
CancellationToken cancellationToken)
{
Guard.ThrowIfNullOrEmpty(roleName, typeof(ArgumentNullException), "role name must be provided to get a role by name");
IdentityRole identityRole = await this.RoleManager.FindByNameAsync(roleName);
if (identityRole == null)
{
throw new NotFoundException($"No role found with name {roleName}");
}
// Role has been found
GetRoleResponse response = new GetRoleResponse
{
Id = Guid.Parse(identityRole.Id),
Name = identityRole.Name,
NormalizedName = identityRole.NormalizedName
};
return(response);
}
