public async Task <IActionResult> GetUserAsync([FromRoute] Guid id)
{
var requestUser = new GetUserRequest
{
Id = id,
};
var responseUser = await _authorizationClient.GetUserAsync(requestUser);
var requestRoles = new ListRolesRequest();
var responseRoles = await _authorizationClient.ListRolesAsync(requestRoles);
var result = new GetUserOutput
{
User = new UserDetail
{
Id = responseUser.Id,
UserName = responseUser.UserName,
Name = responseUser.Name,
DisplayName = responseUser.DisplayName,
IsEnabled = responseUser.IsEnabled,
RoleIds = responseUser.RoleIds
.Select(x => (Guid)x)
.ToList(),
},
Roles = responseRoles.Items
.Select(x => new NamedEntityResult
{
Id = x.Id,
Name = x.Name
})
.ToList(),
};
return(Ok(result));
}
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
{
AmazonIdentityManagementServiceConfig config = new AmazonIdentityManagementServiceConfig();
config.RegionEndpoint = region;
ConfigureClient(config);
AmazonIdentityManagementServiceClient client = new AmazonIdentityManagementServiceClient(creds, config);
ListRolesResponse resp = new ListRolesResponse();
do
{
ListRolesRequest req = new ListRolesRequest
{
Marker = resp.Marker
,
MaxItems = maxItems
};
resp = client.ListRoles(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.Roles)
{
AddObject(obj);
}
}while (!string.IsNullOrEmpty(resp.Marker));
}
public static async Task <IList <Role> > FindExistingRolesAsync(IAmazonIdentityManagementService iamClient, string assumeRolePrincpal, int maxRoles)
{
List <Role> roles = new List <Role>();
ListRolesRequest request = new ListRolesRequest();
ListRolesResponse response = null;
do
{
if (response != null)
{
request.Marker = response.Marker;
}
response = await iamClient.ListRolesAsync(request).ConfigureAwait(false);
foreach (var role in response.Roles)
{
if (AssumeRoleServicePrincipalSelector(role, assumeRolePrincpal))
{
roles.Add(role);
if (roles.Count == maxRoles)
{
break;
}
}
}
} while (response.IsTruncated && roles.Count < maxRoles);
return(roles);
}
private static void ListRoles(String PathPrefix)
{
if (String.IsNullOrEmpty(Token))
{
stsClient = new AmazonIdentityManagementServiceClient(AccessKeyId, SecretKey, iamconfig);
}
else
{
stsClient = new AmazonIdentityManagementServiceClient(AccessKeyId, SecretKey, Token, iamconfig);
}
ListRolesRequest Req = new ListRolesRequest();
if (!String.IsNullOrEmpty(PathPrefix))
{
Req.PathPrefix = PathPrefix;
}
try
{
ListRolesResponse response = stsClient.ListRoles(Req);
foreach (Role r in response.Roles)
{
Console.WriteLine("Role name : {0}, Path: {1}, Create Date: {2}", r.RoleName, r.Path, r.CreateDate.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine("Error occured while creating user. " + ex.ToString());
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
ListRolesRequest request;
try
{
request = new ListRolesRequest
{
ManagedDatabaseId = ManagedDatabaseId,
UserName = UserName,
OpcRequestId = OpcRequestId,
Name = Name,
SortBy = SortBy,
SortOrder = SortOrder,
Limit = Limit,
Page = Page
};
IEnumerable <ListRolesResponse> responses = GetRequestDelegate().Invoke(request);
foreach (var item in responses)
{
response = item;
WriteOutput(response, response.RoleCollection, true);
}
if (!ParameterSetName.Equals(AllPageSet) && !ParameterSetName.Equals(LimitSet) && response.OpcNextPage != null)
{
WriteWarning("This operation supports pagination and not all resources were returned. Re-run using the -All option to auto paginate and list all resources.");
}
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public override async Task <ListNamedEntityResponse> ListRoles(ListRolesRequest request, ServerCallContext context)
{
var roles = await _authorizationApp.GetRolesAsync();
var items = roles.Items.Select(x => new ListNamedEntityResponse.Types.NamedEntity
{
Id = x.Id,
Name = x.Name,
});
var result = new ListNamedEntityResponse();
result.Items.AddRange(items);
return(result);
}
public async Task <List <Role> > GetAll()
{
var channel = new Channel("iam.api.cloud.yandex.net", 443, new SslCredentials());
var client = new RoleService.RoleServiceClient(channel);
var request = new ListRolesRequest();
var response = await client.ListAsync(request);
return(response.Roles
.Select(x => new Role
{
Id = x.Id,
Desription = x.Description
})
.ToList());
}
public async Task<List<Role>> ListOfIAMRoles(OrchestratorSession session, string servicePrincipal)
{
var identityManagementServiceClient = _awsClientFactory.GetAWSClient<IAmazonIdentityManagementService>(session.AWSCredentials, session.AWSRegion);
var listRolesRequest = new ListRolesRequest();
var roles = new List<Role>();
var listStacksPaginator = identityManagementServiceClient.Paginators.ListRoles(listRolesRequest);
await foreach (var response in listStacksPaginator.Responses)
{
var filteredRoles = response.Roles.Where(role => AssumeRoleServicePrincipalSelector(role, servicePrincipal));
roles.AddRange(filteredRoles);
}
return roles;
}
/// <summary>
/// Processes ListRolesRequest message from client.
/// <para>Obtains a list of role servers and returns it in the response.</para>
/// </summary>
/// <param name="Client">Client that sent the request.</param>
/// <param name="RequestMessage">Full request message.</param>
/// <returns>Response message to be sent to the client.</returns>
public ProxProtocolMessage ProcessMessageListRolesRequest(IncomingClient Client, ProxProtocolMessage RequestMessage)
{
log.Trace("()");
ProxProtocolMessage res = null;
if (!CheckSessionConditions(Client, RequestMessage, ServerRole.Primary, null, out res))
{
log.Trace("(-):*.Response.Status={0}", res.Response.Status);
return(res);
}
ProxMessageBuilder messageBuilder = Client.MessageBuilder;
ListRolesRequest listRolesRequest = RequestMessage.Request.SingleRequest.ListRoles;
List <Iop.Proximityserver.ServerRole> roles = GetRolesFromServerComponent();
res = messageBuilder.CreateListRolesResponse(RequestMessage, roles);
log.Trace("(-):*.Response.Status={0}", res.Response.Status);
return(res);
}
public async Task <IActionResult> GetNewUserAsync()
{
var requestRoles = new ListRolesRequest();
var responseRoles = await _authorizationClient.ListRolesAsync(requestRoles);
var result = new GetUserOutput
{
User = new UserDetail
{
IsEnabled = true,
},
Roles = responseRoles.Items
.Select(x => new NamedEntityResult
{
Id = x.Id,
Name = x.Name
})
.ToList(),
};
return(Ok(result));
}
/// <summary>
/// Processes ListRolesRequest message from client.
/// <para>Obtains a list of role servers and returns it in the response.</para>
/// </summary>
/// <param name="Client">Client that sent the request.</param>
/// <param name="RequestMessage">Full request message.</param>
/// <returns>Response message to be sent to the client.</returns>
public Message ProcessMessageListRolesRequest(IncomingClient Client, Message RequestMessage)
{
log.Trace("()");
MessageBuilder messageBuilder = Client.MessageBuilder;
Message res = messageBuilder.CreateErrorBadRoleResponse(RequestMessage);
if (Client.ServerRole != ServerRole.Primary)
{
log.Trace("(-):*.Response.Status={0}", res.Response.Status);
return(res);
}
ListRolesRequest listRolesRequest = RequestMessage.Request.SingleRequest.ListRoles;
List <Iop.Profileserver.ServerRole> roles = GetRolesFromServerComponent();
res = messageBuilder.CreateListRolesResponse(RequestMessage, roles);
log.Trace("(-):*.Response.Status={0}", res.Response.Status);
return(res);
}
public Task <ListRolesResponse> ListRolesAsync(ListRolesRequest request, CancellationToken cancellationToken = new CancellationToken())
{
return(Task.FromResult(new ListRolesResponse {
Roles = Roles
}));
}
public ListRolesResponse ListRoles(ListRolesRequest request, string jsonRpcCallId)
{
ListRolesResponse result = new ListRolesResponse();
WireRequest(0, jsonRpcCallId, "system.list_roles", (writer) =>
{
request.Write(writer, false);
}, (reader) =>
{
result.Read(reader);
}
);
return result;
}
public ListRolesResponse ListRoles(ListRolesRequest request)
{
return ListRoles (request, Guid.NewGuid().ToString());
}
