private async Task <object> GetAllUsersAsync(string pUserPool)
{
AmazonCognitoIdentityProviderClient provider =
new AmazonCognitoIdentityProviderClient(RegionEndpoint.USEast2);
ListUsersRequest vRequest = new ListUsersRequest
{
UserPoolId = pUserPool
};
ListUsersInGroupResponse vGroupResponse = await provider.ListUsersInGroupAsync(new ListUsersInGroupRequest
{
GroupName = ADMIN_GROUP,
UserPoolId = pUserPool
});
ListUsersResponse vResponse = await provider.ListUsersAsync(vRequest);
var vReturn = new
{
Admins = vGroupResponse.Users,
AllUsers = vResponse.Users
};
return(vReturn);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
ListUsersRequest request;
try
{
request = new ListUsersRequest
{
CompartmentId = CompartmentId,
Page = Page,
Limit = Limit,
IdentityProviderId = IdentityProviderId,
ExternalIdentifier = ExternalIdentifier,
Name = Name,
SortBy = SortBy,
SortOrder = SortOrder,
LifecycleState = LifecycleState
};
IEnumerable <ListUsersResponse> responses = GetRequestDelegate().Invoke(request);
foreach (var item in responses)
{
response = item;
WriteOutput(response, response.Items, true);
}
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
ListUsersRequest request;
try
{
request = new ListUsersRequest
{
ManagedDatabaseId = ManagedDatabaseId,
OpcRequestId = OpcRequestId,
Name = Name,
SortBy = SortBy,
SortOrder = SortOrder,
Limit = Limit,
Page = Page
};
IEnumerable <ListUsersResponse> responses = GetRequestDelegate().Invoke(request);
foreach (var item in responses)
{
response = item;
WriteOutput(response, response.UserCollection, 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);
}
}
private IList <UserRowData> InternalSelect(int startRowIndex, int maximumRows, out int resultCount)
{
if (maximumRows == 0)
{
resultCount = 0;
return(new List <UserRowData>());
}
List <UserRowData> users;
using (var service = new UserManagement())
{
var filter = new ListUsersRequest
{
UserName = UserName.Replace("*", "%").Replace("?", "_"),
DisplayName = DisplayName.Replace("*", "%").Replace("?", "_"),
Page = { FirstRow = startRowIndex },
ExactMatchOnly = false
};
users = CollectionUtils.Map(
service.FindUsers(filter),
(UserSummary summary) => new UserRowData(summary, service.GetUserDetail(summary.UserName)));
}
resultCount = users.Count;
return(users);
}
public ListUsersResponse List(Connection connection, ListUsersRequest listUsersRequest)
{
var request = Request(connection, $"http://{connection.Url}/v1/usermanagement/users/list", HttpMethod.Post);
request.AddJsonContent(listUsersRequest);
return(Client.Execute <ListUsersResponse>(request));
}
public void List()
{
var request = new ListUsersRequest();
var users = AutomationAnywhereApi.UsersList(Connection, request);
Assert.IsTrue(users != null);
}
private static void ListUsers(String PathPrefix)
{
if (String.IsNullOrEmpty(Token))
{
stsClient = new AmazonIdentityManagementServiceClient(AccessKeyId, SecretKey, iamconfig);
}
else
{
stsClient = new AmazonIdentityManagementServiceClient(AccessKeyId, SecretKey, Token, iamconfig);
}
ListUsersRequest req = new ListUsersRequest();
if (!String.IsNullOrEmpty(PathPrefix))
{
req.PathPrefix = PathPrefix;
}
try
{
ListUsersResponse response = stsClient.ListUsers(req);
foreach (User u in response.Users)
{
Console.WriteLine("Id: {0}, User name : {1}, Path: {2}, Create Date: {3}", u.UserId, u.UserName, u.Path, u.CreateDate.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine("Error occured while creating user. " + ex.ToString());
}
}
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);
ListUsersResponse resp = new ListUsersResponse();
do
{
ListUsersRequest req = new ListUsersRequest
{
Marker = resp.Marker
,
MaxItems = maxItems
};
resp = client.ListUsers(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.Users)
{
AddObject(obj);
}
}while (!string.IsNullOrEmpty(resp.Marker));
}
internal static void UpdateUserAccount(string userName, StaffSummary staff)
{
if (!string.IsNullOrEmpty(userName))
{
Platform.GetService <IUserAdminService>(
delegate(IUserAdminService service)
{
// check if the user account exists
ListUsersRequest request = new ListUsersRequest();
request.UserName = userName;
request.ExactMatchOnly = true;
UserSummary user = CollectionUtils.FirstElement(service.ListUsers(request).Users);
if (user != null)
{
// modify the display name on the user account
UserDetail detail = service.LoadUserForEdit(
new LoadUserForEditRequest(userName)).UserDetail;
detail.DisplayName = (staff == null) ? null : staff.Name.ToString();
service.UpdateUser(new UpdateUserRequest(detail));
}
});
}
}
public static void ConsoleDisplay(ClientConfig config)
{
var identityClient = new IdentityClient(config)
{
Region = Regions.US_ASHBURN_1
};
LoadOciUsers(identityClient);
Console.WriteLine("* Users------------------------");
var listUsersRequest = new ListUsersRequest()
{
CompartmentId = config.TenancyId
};
var users = identityClient.ListUsers(listUsersRequest).Items;
foreach (var user in users)
{
Console.WriteLine($" |-{user.Name}");
Console.WriteLine($" | providerId: {user.IdentityProviderId}");
Console.WriteLine($" | inactiveStatus: {user.InactiveStatus}");
Console.WriteLine($" | lifecycleState: {user.LifecycleState}");
Console.WriteLine($" | mfaActivated: {user.IsMfaActivated}");
Console.WriteLine($" | timeCreated: {user.TimeCreated}");
}
}
internal virtual ListUsersResponse ListUsers(ListUsersRequest request)
{
var marshaller = ListUsersRequestMarshaller.Instance;
var unmarshaller = ListUsersResponseUnmarshaller.Instance;
return(Invoke <ListUsersRequest, ListUsersResponse>(request, marshaller, unmarshaller));
}
public async Task TestSignUpProcess()
{
var userID = "User55";
var password = "******";
var userAttributes = new Dictionary <string, string>(StringComparer.Ordinal)
{
{ CognitoConstants.UserAttrEmail, "*****@*****.**" }
};
var validationData = new Dictionary <string, string>(StringComparer.Ordinal)
{
{ CognitoConstants.UserAttrEmail, "*****@*****.**" }
};
await pool.SignUpAsync(userID, password, userAttributes, validationData).ConfigureAwait(false);
var listUsersRequest = new ListUsersRequest()
{
Limit = 2,
UserPoolId = pool.PoolID
};
var listUsersResponse = await provider.ListUsersAsync(listUsersRequest).ConfigureAwait(false);
var containsUser55 = false;
foreach (var user in listUsersResponse.Users)
{
if (string.Equals(user.Username, userID, StringComparison.Ordinal))
{
containsUser55 = true;
}
}
Assert.True(containsUser55);
}
/**
* This method demonstrates how to do pagination yourself by manually managing the next page
* tokens returned by service responses
*
* @param identityClient the client used to make service calls
* @param compartmentId the OCID of the compartment we'll issue the ListUsers request against. This should be your tenancy OCID
*/
private static async Task DoManualPagination(IdentityClient identityClient, string compartmentId)
{
logger.Info("Manual Pagination");
logger.Info("==================");
string nextPageToken = null;
ListUsersRequest listUsersRequest = null;
ListUsersResponse listUsersResponse = null;
do
{
listUsersRequest = new ListUsersRequest
{
CompartmentId = compartmentId,
Page = nextPageToken
};
listUsersResponse = await identityClient.ListUsers(listUsersRequest);
foreach (User user in listUsersResponse.Items)
{
logger.Info($"user: {user.Name}");
}
nextPageToken = listUsersResponse.OpcNextPage;
} while (nextPageToken != null);
logger.Info("\n\n");
}
/// <summary>
/// Initiates the asynchronous execution of the ListUsers operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListUsers operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/mq-2017-11-27/ListUsers">REST API Reference for ListUsers Operation</seealso>
public virtual Task <ListUsersResponse> ListUsersAsync(ListUsersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = ListUsersRequestMarshaller.Instance;
var unmarshaller = ListUsersResponseUnmarshaller.Instance;
return(InvokeAsync <ListUsersRequest, ListUsersResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
/// <summary>
/// Lists the attribute name and value of the user that you specified in the search. We
/// only support <code>UserName</code> as a valid filter attribute path currently, and
/// filter is required. This API returns minimum attributes, including <code>UserId</code>
/// and <code>UserName</code> in the response.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListUsers service method.</param>
///
/// <returns>The response from the ListUsers service method, as returned by IdentityStore.</returns>
/// <exception cref="Amazon.IdentityStore.Model.AccessDeniedException">
/// You do not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.IdentityStore.Model.InternalServerException">
/// The request processing has failed because of an unknown error, exception or failure
/// with an internal server.
/// </exception>
/// <exception cref="Amazon.IdentityStore.Model.ResourceNotFoundException">
/// Indicates that a requested resource is not found.
/// </exception>
/// <exception cref="Amazon.IdentityStore.Model.ThrottlingException">
/// Indicates that the principal has crossed the throttling limits of the API operations.
/// </exception>
/// <exception cref="Amazon.IdentityStore.Model.ValidationException">
/// The request failed because it contains a syntax error.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/identitystore-2020-06-15/ListUsers">REST API Reference for ListUsers Operation</seealso>
public virtual ListUsersResponse ListUsers(ListUsersRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListUsersRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListUsersResponseUnmarshaller.Instance;
return(Invoke <ListUsersResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the ListUsers operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListUsers operation on AmazonIdentityStoreClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListUsers
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/identitystore-2020-06-15/ListUsers">REST API Reference for ListUsers Operation</seealso>
public virtual IAsyncResult BeginListUsers(ListUsersRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListUsersRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListUsersResponseUnmarshaller.Instance;
return(BeginInvoke(request, options, callback, state));
}
/// <summary>
/// Initiates the asynchronous execution of the ListUsers operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListUsers operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListUsers">REST API Reference for ListUsers Operation</seealso>
public virtual Task <ListUsersResponse> ListUsersAsync(ListUsersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListUsersRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListUsersResponseUnmarshaller.Instance;
return(InvokeAsync <ListUsersResponse>(request, options, cancellationToken));
}
public Task <ListUsersResponse> ListUsers()
{
var req = new ListUsersRequest
{
UserPoolId = userPoolId
};
return(client.ListUsersAsync(req));
}
public override async Task ListUsers(ListUsersRequest request, IServerStreamWriter <ListUsersResponse> responseStream, ServerCallContext context)
{
using (var db = new AuthDbContext())
{
foreach (var user in db.Users)
{
await responseStream.WriteAsync(new ListUsersResponse { Id = user.Id, FirstName = user.FirstName, LastName = user.LastName, Email = user.Email });
}
}
}
public ListUsersResponse ListUsers(ListUsersRequest request)
{
var users = _userRepository.List().Select(u => new User() {UserId = u.UserId, Name = u.Name});
return new ListUsersResponse()
{
StatusCode = StatusOk,
Users = users
};
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public async Task <List <string> > ListUsers()
{
var iamClient = new AmazonIdentityManagementServiceClient(AWSAccessKey, AWSSecurityKey);
var requestUsers = new ListUsersRequest()
{
MaxItems = 10
};
var responseUsers = await iamClient.ListUsersAsync(requestUsers);
return(responseUsers.Users.Select(a => a.UserName).ToList());
}
public async Task <ListResponse <UsersListItemDto> > ListAsync(ListUsersRequest request)
{
var filter = _mapper.Map <ListUsersRequest, UsersFilter>(request);
var sort = _mapper.Map <ListUsersRequest, Sort>(request);
var paging = _mapper.Map <ListUsersRequest, Paging>(request);
var users = await _userRepository.GetListAsync(filter, sort, paging);
var usersCount = await _userRepository.CountAsync(filter);
var usersDtosList = _mapper.Map <List <User>, List <UsersListItemDto> >(users);
return(new ListResponse <UsersListItemDto>(usersDtosList, usersCount));
}
public static void ListUsers()
{
var iamClient = new AmazonIdentityManagementServiceClient();
var requestUsers = new ListUsersRequest()
{
MaxItems = 10
};
var responseUsers = iamClient.ListUsers(requestUsers);
foreach (var user in responseUsers.Users)
{
Console.WriteLine("User " + user.UserName + " Created: " + user.CreateDate.ToShortDateString());
}
}
public static void ListUsersAndGroups()
{
var iamClient = new AmazonIdentityManagementServiceClient();
var requestUsers = new ListUsersRequest();
var responseUsers = iamClient.ListUsers(requestUsers);
foreach (var user in responseUsers.Users)
{
Console.WriteLine("For user {0}:", user.UserName);
Console.WriteLine(" In groups:");
var requestGroups = new ListGroupsForUserRequest
{
UserName = user.UserName
};
var responseGroups = iamClient.ListGroupsForUser(requestGroups);
foreach (var group in responseGroups.Groups)
{
Console.WriteLine(" {0}", group.GroupName);
}
Console.WriteLine(" Policies:");
var requestPolicies = new ListUserPoliciesRequest
{
UserName = user.UserName
};
var responsePolicies = iamClient.ListUserPolicies(requestPolicies);
foreach (var policy in responsePolicies.PolicyNames)
{
Console.WriteLine(" {0}", policy);
}
var requestAccessKeys = new ListAccessKeysRequest
{
UserName = user.UserName
};
var responseAccessKeys = iamClient.ListAccessKeys(requestAccessKeys);
Console.WriteLine(" Access keys:");
foreach (var accessKey in responseAccessKeys.AccessKeyMetadata)
{
Console.WriteLine(" {0}", accessKey.AccessKeyId);
}
}
}
public async Task <IActionResult> List([FromQuery] ListUsersRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var response = await _userService.ListAsync(request);
if (!response.IsValid)
{
return(BadRequest(response.Message));
}
return(Ok(response));
}
/// <summary>
/// 获取用户列表信息。
/// </summary>
/// <param name="req"><see cref="ListUsersRequest"/></param>
/// <returns><see cref="ListUsersResponse"/></returns>
public ListUsersResponse ListUsersSync(ListUsersRequest req)
{
JsonResponseModel <ListUsersResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "ListUsers");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <ListUsersResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public ListUsersResponse ListUsers(ListUsersRequest request)
{
// establish which account types this user is entitled to see
var visibleAccountTypes = GetAccountTypesAuthorizedToManage(request.IncludeGroupAccounts, request.IncludeSystemAccounts).ToList();
if (!visibleAccountTypes.Any())
{
throw new SecurityException(SR.MessageUserNotAuthorized);
}
var criteria = new UserSearchCriteria();
criteria.AccountType.In(visibleAccountTypes);
criteria.UserName.SortAsc(0);
// create the criteria, depending on whether matches should be "exact" or "like"
if (request.ExactMatchOnly)
{
if (!string.IsNullOrEmpty(request.UserName))
{
criteria.UserName.EqualTo(request.UserName);
}
if (!string.IsNullOrEmpty(request.DisplayName))
{
criteria.DisplayName.EqualTo(request.DisplayName);
}
}
else
{
if (!string.IsNullOrEmpty(request.UserName))
{
criteria.UserName.StartsWith(request.UserName);
}
if (!string.IsNullOrEmpty(request.DisplayName))
{
criteria.DisplayName.Like(string.Format("%{0}%", request.DisplayName));
}
}
var broker = PersistenceContext.GetBroker <IUserBroker>();
var assembler = new UserAssembler();
var userSummaries = CollectionUtils.Map(
broker.Find(criteria, request.Page),
(User user) => assembler.GetUserSummary(user));
var total = broker.Count(criteria);
return(new ListUsersResponse(userSummaries, (int)total));
}
private static IList <UserLookupData> ListUsers(string query)
{
var users = new List <UserLookupData>();
Platform.GetService <IUserAdminService>(
service =>
{
var request = new ListUsersRequest {
UserName = query
};
var response = service.ListUsers(request);
users = CollectionUtils.Map(response.Users, (UserSummary summary) => new UserLookupData(summary.UserName));
});
return(users);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
ListUsersRequest request;
try
{
request = new ListUsersRequest
{
UserAssessmentId = UserAssessmentId,
Limit = Limit,
CompartmentIdInSubtree = CompartmentIdInSubtree,
AccessLevel = AccessLevel,
UserCategory = UserCategory,
UserKey = UserKey,
AccountStatus = AccountStatus,
AuthenticationType = AuthenticationType,
UserName = UserName,
TargetId = TargetId,
TimeLastLoginGreaterThanOrEqualTo = TimeLastLoginGreaterThanOrEqualTo,
TimeLastLoginLessThan = TimeLastLoginLessThan,
TimeUserCreatedGreaterThanOrEqualTo = TimeUserCreatedGreaterThanOrEqualTo,
TimeUserCreatedLessThan = TimeUserCreatedLessThan,
TimePasswordLastChangedGreaterThanOrEqualTo = TimePasswordLastChangedGreaterThanOrEqualTo,
TimePasswordLastChangedLessThan = TimePasswordLastChangedLessThan,
Page = Page,
SortOrder = SortOrder,
SortBy = SortBy,
OpcRequestId = OpcRequestId
};
IEnumerable <ListUsersResponse> responses = GetRequestDelegate().Invoke(request);
foreach (var item in responses)
{
response = item;
WriteOutput(response, response.Items, 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);
}
}
private async Task <UserType> LookupUserByEmailAsync(string userPoolId, string userName)
{
var listUsersRequest = new ListUsersRequest()
{
AttributesToGet = new List <string>()
{
"sub"
},
Filter = $"email=\"{userName}\"",
UserPoolId = userPoolId
};
var listUsersResponse = await _awsCognitoClient.ListUsersAsync(listUsersRequest);
var user = listUsersResponse.Users.FirstOrDefault();
return(user);
}
public override async Task <ListUsersReply> ListUsers(ListUsersRequest request, ServerCallContext context)
{
__log.Debug("\"ListUsers\" Request received");
string filter = request.Filter;
ListUsersReply reply = new ListUsersReply();
IGuild guild = _client.GetGuild(_guildId);
var users = await guild.GetUsersAsync();
if (!string.IsNullOrEmpty(filter))
{
filter = ".*";
}
Regex regex = new Regex(filter,
RegexOptions.IgnoreCase | RegexOptions.Compiled);
foreach (IGuildUser user in users)
{
__log.DebugFormat("Check user \"{0}\"", user.Username);
if (request.OnlyOnline &&
user.Status != UserStatus.Online)
{
__log.DebugFormat("User \"{0}\" not online", user.Username);
continue;
}
if (!regex.IsMatch(user.Username))
{
__log.DebugFormat("Username \"{0}\" does not match filter \"{1}\"", user.Username, filter);
continue;
}
__log.DebugFormat("Add user \"{0}\" with Id {1}", user.Username, user.Id);
User replyUser = new User();
replyUser.Id = user.Id.ToString();
replyUser.Name = user.Username;
reply.Users.Add(replyUser);
}
__log.DebugFormat("Return {0} users", reply.Users.Count);
return(reply);
}
