public Task <GetRoleResponse> GetRole(GetRoleRequest request)
{
if (!request.Id.HasValue)
{
return(Task.FromResult(new GetRoleResponse()
{
Errors = "Không có thông tin Id"
}));
}
var record = _repoRole.FindOne(x => x.Id.Equals(request.Id.Value));
var role = new RoleDto
{
Id = record.Id,
Name = record.Name,
Descriptions = record.Descriptions
};
var permisData = _repoPermis.FindAll(x => x.RoleId.Equals(record.Id))
.Select(x => AutoMapper.Map <SysPermission, PermissionDto>(x));
role.PermissionData = permisData.ToList();
return(Task.FromResult(new GetRoleResponse()
{
Data = role
}));
}
public async Task <Role> EnsureRoleExistsAsync(RoleName roleName)
{
var identityResponse =
await _securityTokenServiceClient.GetCallerIdentityAsync(new GetCallerIdentityRequest());
var accountArn = new AwsAccountArn(identityResponse.Account);
var request = CreateRoleRequest(accountArn, roleName);
try
{
var response = await _client.CreateRoleAsync(request);
if (response.HttpStatusCode != HttpStatusCode.OK)
{
var metadata = string.Join(", ",
response.ResponseMetadata.Metadata.Select(m => $"{m.Key}:{m.Value}"));
throw new Exception(
$"Error creating role: \"{roleName}\". Status code was {response.HttpStatusCode}, metadata: {metadata}");
}
return(response.Role);
}
catch (EntityAlreadyExistsException)
{
// Role exists we are happy
var getRoleRequest = new GetRoleRequest {
RoleName = roleName
};
var getRoleResponse = await _client.GetRoleAsync(getRoleRequest);
return(getRoleResponse.Role);
}
}
public static string ExpandRoleName(IAmazonIdentityManagementService iamClient, string roleName)
{
if (roleName.StartsWith("arn:aws:iam"))
{
return(roleName);
}
// Wrapping this in a task to avoid dealing with aggregate exception.
var task = Task.Run <string>(async() =>
{
try
{
var request = new GetRoleRequest {
RoleName = roleName
};
var response = await iamClient.GetRoleAsync(request).ConfigureAwait(false);
return(response.Role.Arn);
}
catch (NoSuchEntityException)
{
return(null);
}
});
return(task.Result);
}
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 static string ExpandRoleName(IAmazonIdentityManagementService iamClient, string roleName)
{
if (roleName.StartsWith("arn:aws"))
{
return(roleName);
}
// Wrapping this in a task to avoid dealing with aggregate exception.
var task = Task.Run <string>(async() =>
{
try
{
var request = new GetRoleRequest {
RoleName = roleName
};
var response = await iamClient.GetRoleAsync(request).ConfigureAwait(false);
return(response.Role.Arn);
}
catch (NoSuchEntityException)
{
return(null);
}
});
if (task.Result == null)
{
throw new ToolsException($"Role \"{roleName}\" can not be found.", ToolsException.CommonErrorCode.RoleNotFound);
}
return(task.Result);
}
public static async Task <string> EnsureTaskExecutionRoleExists(IToolLogger logger, ECSBaseCommand command)
{
bool roleExists = false;
try
{
var request = new GetRoleRequest {
RoleName = DEFAULT_ECS_TASK_EXECUTION_ROLE
};
var response = await command.IAMClient.GetRoleAsync(request).ConfigureAwait(false);
roleExists = true;
logger.WriteLine("Task Execution role \"{0}\" already exists.", DEFAULT_ECS_TASK_EXECUTION_ROLE);
}
catch (Amazon.IdentityManagement.Model.NoSuchEntityException)
{
roleExists = false;
}
catch (Exception e)
{
logger.WriteLine("Error checking to make sure role \"ecsTaskExecutionRole\" exists, continuing on assuming the role exists: " + e.Message);
}
if (roleExists)
{
return(DEFAULT_ECS_TASK_EXECUTION_ROLE);
}
logger.WriteLine("Creating default \"{0}\" IAM role.", DEFAULT_ECS_TASK_EXECUTION_ROLE);
RoleHelper.CreateRole(command.IAMClient, DEFAULT_ECS_TASK_EXECUTION_ROLE, Amazon.Common.DotNetCli.Tools.Constants.ECS_TASKS_ASSUME_ROLE_POLICY, "CloudWatchLogsFullAccess", "AmazonEC2ContainerRegistryReadOnly");
return(DEFAULT_ECS_TASK_EXECUTION_ROLE);
}
public async Task <IActionResult> GetRoleAsync([FromRoute] Guid id)
{
var requestRole = new GetRoleRequest
{
Id = id,
};
var responseRole = await _authorizationClient.GetRoleAsync(requestRole);
var requestPermissions = new ListPermissionsRequest();
var responsePermissions = await _authorizationClient.ListPermissionsAsync(requestPermissions);
var result = new GetRoleOutput
{
Role = new RoleDetail
{
Id = responseRole.Id,
Name = responseRole.Name,
IsEnabled = responseRole.IsEnabled,
PermissionIds = responseRole.PermissionIds
.Select(x => (Guid)x)
.ToList(),
},
Permissions = responsePermissions.Items
.Select(x => new NamedEntityResult
{
Id = x.Id,
Name = x.Name
})
.ToList(),
};
return(Ok(result));
}
/// <summary>
/// Create the role if it's not there already.
/// Return true if it already existed.
/// </summary>
/// <returns></returns>
private static async Task <bool> ValidateAndSetIamRoleArn(AmazonIdentityManagementServiceClient iamClient)
{
var getRoleRequest = new GetRoleRequest
{
RoleName = ExecutionRoleName
};
try
{
ExecutionRoleArn = (await iamClient.GetRoleAsync(getRoleRequest)).Role.Arn;
return(true);
}
catch (NoSuchEntityException)
{
// create the role
var createRoleRequest = new CreateRoleRequest
{
RoleName = ExecutionRoleName,
Description = "Test role for CustomRuntimeTests.",
AssumeRolePolicyDocument = LAMBDA_ASSUME_ROLE_POLICY
};
ExecutionRoleArn = (await iamClient.CreateRoleAsync(createRoleRequest)).Role.Arn;
// Wait for role to propagate.
await Task.Delay(10000);
return(false);
}
}
public GetRoleResponse Get(GetRoleRequest request)
{
var query = repository
.AsQueryable <Models.Role>();
if (request.RoleId.HasValue)
{
query = query.Where(role => role.Id == request.RoleId);
}
else
{
query = query.Where(role => role.Name == request.RoleName);
}
var model = query
.Select(role => new RoleModel
{
Id = role.Id,
Version = role.Version,
CreatedBy = role.CreatedByUser,
CreatedOn = role.CreatedOn,
LastModifiedBy = role.ModifiedByUser,
LastModifiedOn = role.ModifiedOn,
Name = role.Name,
Description = role.Description,
IsSystematic = role.IsSystematic
})
.FirstOne();
return(new GetRoleResponse {
Data = model
});
}
public GetRoleResponse Get(GetRoleRequest request)
{
var query = repository
.AsQueryable<Models.Role>();
if (request.RoleId.HasValue)
{
query = query.Where(role => role.Id == request.RoleId);
}
else
{
query = query.Where(role => role.Name == request.RoleName);
}
var model = query
.Select(role => new RoleModel
{
Id = role.Id,
Version = role.Version,
CreatedBy = role.CreatedByUser,
CreatedOn = role.CreatedOn,
LastModifiedBy = role.ModifiedByUser,
LastModifiedOn = role.ModifiedOn,
Name = role.Name,
Description = role.Description,
IsSystematic = role.IsSystematic
})
.FirstOne();
return new GetRoleResponse { Data = 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);
}
public JsonResult GetRole(System.Int32 id)
{
DataTableViewModel data1;
GetRoleRequest request = new GetRoleRequest();
request.RoleId = id;
DetailRole_RoleDetailView data = _roleService.GetRole(request).Role.ConvertToDetailRole_RoleDetailView();
return(Json(data, JsonRequestBehavior.AllowGet));
}
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 DTO.Role Get(GetRoleRequest request)
{
try
{
var role = _roleRepository.FindBy(request.Id);
role.ThrowExceptionIfRecordIsNull();
return(TypeAdapter.Adapt <DTO.Role>(role));
}
catch (DataAccessException)
{
throw new ApplicationException();
}
}
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 JsonResult Update(RoleDetailView vm)
{
GetRoleRequest request = new GetRoleRequest();
request.RoleId = vm.RoleId;
ModifyRoleRequest updateRequest = _roleService.GetRole(request).Role.ConvertToModifyRoleRequest();
updateRequest.RoleId = vm.RoleId;
updateRequest.RoleName = vm.RoleName;
updateRequest.Description = vm.Description;
ModifyRoleResponse response = _roleService.ModifyRole(updateRequest);
return(Json(response));
}
/// <summary>
/// 本接口（GetRole）用于获取指定角色的详细信息。
/// </summary>
/// <param name="req">参考<see cref="GetRoleRequest"/></param>
/// <returns>参考<see cref="GetRoleResponse"/>实例</returns>
public async Task <GetRoleResponse> GetRole(GetRoleRequest req)
{
JsonResponseModel <GetRoleResponse> rsp = null;
try
{
var strResp = await this.InternalRequest(req, "GetRole");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <GetRoleResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
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);
}
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 JsonResult GetUserDataTable(System.Int32 id)
{
DataTableViewModel data;
GetRoleRequest request = new GetRoleRequest();
request.RoleId = id;
RoleView role = _roleService.GetRole(request).Role;
data = new DataTableViewModel();
data.draw = "1";
data.recordsTotal = role.Users.ToList().Count.ToString();
data.recordsFiltered = role.Users.ToList().Count.ToString();
data.data = role.Users.ConvertToDetailRoleUserDetailViews().ToList <object>();
return(Json(data, JsonRequestBehavior.AllowGet));
}
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 Task <GetFunctionByRoleResponse> GetFunctionByRole(GetRoleRequest request)
{
if (!request.Id.HasValue)
{
return(Task.FromResult(new GetFunctionByRoleResponse()
{
Errors = "Không có thông tin Id"
}));
}
IRepository <SysFunction> repoFunc = DependencyProvider.Resolve <IRepository <SysFunction> >();
var results = _repoPermis.FindAll(x => x.RoleId.Equals(request.Id.Value)).AsEnumerable();
var lstFunction = repoFunc.FindAll(x => results.Any(e => e.FnCd.Equals(x.FnCd))).AsEnumerable();
return(Task.FromResult(new GetFunctionByRoleResponse()
{
Data = AutoMapper.MapList <SysFunction, FunctionDto>(lstFunction)
}));
}
//获取角色信息
public async Task <IActionResult> Get(int id)
{
var request = new GetRoleRequest()
{
ID = id
};
try
{
var response = await _serviceProvider.HandlerAsync(request);
return(new JsonResult(response));
}
catch (Exception ex)
{
return(new JsonResult(new ResponseBase()
{
Result = -1, ResultInfo = ex.Message
}));
}
}
public async Task <ActionResult> Get([FromQuery] GetRoleRequest command)
{
return(await base.Query <GetRoleRequest, RoleDto>(command));
}
public IList <Role> Handle(GetRoleRequest query)
{
return(this.repository.Query <Entity.Role>().ProjectTo <Role>().ToList());
}
public override async Task <Role> GetRole(GetRoleRequest getRoleRequest, ServerCallContext context)
{
var getRole = _mapper.Map <GetRoleRequest, GetRole>(getRoleRequest);
return(_mapper.Map <RoleModel, Role>(await _mediator.Send(getRole)));
}
public Task <GetRoleResponse> GetRoleAsync(GetRoleRequest request, CancellationToken cancellationToken = new CancellationToken())
{
throw new System.NotImplementedException();
}
public GetRoleResponse Get(GetRoleRequest request)
{
throw new CmsException(UsersApiConstants.UsersApiHasNoImplementationMessage);
}
public async Task <QueryResponse <RoleResponse> > GetRole(GetRoleRequest request)
{
return(await SendAsync <GetRoleRequest, RoleResponse>("GetRole", request));
}
public Role Get(GetRoleRequest request)
{
return(_roleService.Get(request));
}
