Container for the parameters to the ListUsers operation. Lists the users in the Amazon Cognito user pool.
Inheritance: AmazonCognitoIdentityProviderRequest
Beispiel #1
0
 internal ListUsersPaginator(IAmazonCognitoIdentityProvider client, ListUsersRequest request)
 {
     this._client  = client;
     this._request = request;
 }
 private Amazon.CognitoIdentityProvider.Model.ListUsersResponse CallAWSServiceOperation(IAmazonCognitoIdentityProvider client, Amazon.CognitoIdentityProvider.Model.ListUsersRequest request)
 {
     Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Cognito Identity Provider", "ListUsers");
     try
     {
         #if DESKTOP
         return client.ListUsers(request);
         #elif CORECLR
         return client.ListUsersAsync(request).GetAwaiter().GetResult();
         #else
                 #error "Unknown build edition"
         #endif
     }
     catch (AmazonServiceException exc)
     {
         var webException = exc.InnerException as System.Net.WebException;
         if (webException != null)
         {
             throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
         }
         throw;
     }
 }
 /// <summary>
 /// Paginator for ListUsers operation
 ///</summary>
 public IListUsersPaginator ListUsers(ListUsersRequest request)
 {
     return(new ListUsersPaginator(this.client, request));
 }
 public object Execute(ExecutorContext context)
 {
     var cmdletContext = context as CmdletContext;
     var useParameterSelect = this.Select.StartsWith("^") || this.PassThru.IsPresent;
     
     // create request and set iteration invariants
     var request = new Amazon.CognitoIdentityProvider.Model.ListUsersRequest();
     if (cmdletContext.AttributesToGet != null)
     {
         request.AttributesToGet = cmdletContext.AttributesToGet;
     }
     if (cmdletContext.Filter != null)
     {
         request.Filter = cmdletContext.Filter;
     }
     if (cmdletContext.UserPoolId != null)
     {
         request.UserPoolId = cmdletContext.UserPoolId;
     }
     
     // Initialize loop variants and commence piping
     System.String _nextToken = null;
     int? _emitLimit = null;
     int _retrievedSoFar = 0;
     if (AutoIterationHelpers.HasValue(cmdletContext.PaginationToken))
     {
         _nextToken = cmdletContext.PaginationToken;
     }
     if (cmdletContext.Limit.HasValue)
     {
         // The service has a maximum page size of 60. If the user has
         // asked for more items than page max, and there is no page size
         // configured, we rely on the service ignoring the set maximum
         // and giving us 60 items back. If a page size is set, that will
         // be used to configure the pagination.
         // We'll make further calls to satisfy the user's request.
         _emitLimit = cmdletContext.Limit;
     }
     var _userControllingPaging = this.NoAutoIteration.IsPresent || ParameterWasBound(nameof(this.PaginationToken));
     
     var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
     do
     {
         request.PaginationToken = _nextToken;
         if (_emitLimit.HasValue)
         {
             int correctPageSize = Math.Min(60, _emitLimit.Value);
             request.Limit = AutoIterationHelpers.ConvertEmitLimitToInt32(correctPageSize);
         }
         else if (!ParameterWasBound(nameof(this.Limit)))
         {
             request.Limit = AutoIterationHelpers.ConvertEmitLimitToInt32(60);
         }
         
         CmdletOutput output;
         
         try
         {
             
             var response = CallAWSServiceOperation(client, request);
             object pipelineOutput = null;
             if (!useParameterSelect)
             {
                 pipelineOutput = cmdletContext.Select(response, this);
             }
             output = new CmdletOutput
             {
                 PipelineOutput = pipelineOutput,
                 ServiceResponse = response
             };
             int _receivedThisCall = response.Users.Count;
             
             _nextToken = response.PaginationToken;
             _retrievedSoFar += _receivedThisCall;
             if (_emitLimit.HasValue)
             {
                 _emitLimit -= _receivedThisCall;
             }
         }
         catch (Exception e)
         {
             if (_retrievedSoFar == 0 || !_emitLimit.HasValue)
             {
                 output = new CmdletOutput { ErrorResponse = e };
             }
             else
             {
                 break;
             }
         }
         
         ProcessOutput(output);
     } while (!_userControllingPaging && AutoIterationHelpers.HasValue(_nextToken) && (!_emitLimit.HasValue || _emitLimit.Value >= 0));
     
     
     if (useParameterSelect)
     {
         WriteObject(cmdletContext.Select(null, this));
     }
     
     
     return null;
 }
 public object Execute(ExecutorContext context)
 {
     var cmdletContext = context as CmdletContext;
     #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute
     var useParameterSelect = this.Select.StartsWith("^") || this.PassThru.IsPresent;
     #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute
     
     // create request and set iteration invariants
     var request = new Amazon.CognitoIdentityProvider.Model.ListUsersRequest();
     
     if (cmdletContext.AttributesToGet != null)
     {
         request.AttributesToGet = cmdletContext.AttributesToGet;
     }
     if (cmdletContext.Filter != null)
     {
         request.Filter = cmdletContext.Filter;
     }
     if (cmdletContext.Limit != null)
     {
         request.Limit = AutoIterationHelpers.ConvertEmitLimitToServiceTypeInt32(cmdletContext.Limit.Value);
     }
     if (cmdletContext.UserPoolId != null)
     {
         request.UserPoolId = cmdletContext.UserPoolId;
     }
     
     // Initialize loop variant and commence piping
     var _nextToken = cmdletContext.PaginationToken;
     var _userControllingPaging = this.NoAutoIteration.IsPresent || ParameterWasBound(nameof(this.PaginationToken));
     
     var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
     do
     {
         request.PaginationToken = _nextToken;
         
         CmdletOutput output;
         
         try
         {
             
             var response = CallAWSServiceOperation(client, request);
             
             object pipelineOutput = null;
             if (!useParameterSelect)
             {
                 pipelineOutput = cmdletContext.Select(response, this);
             }
             output = new CmdletOutput
             {
                 PipelineOutput = pipelineOutput,
                 ServiceResponse = response
             };
             
             _nextToken = response.PaginationToken;
         }
         catch (Exception e)
         {
             output = new CmdletOutput { ErrorResponse = e };
         }
         
         ProcessOutput(output);
         
     } while (!_userControllingPaging && AutoIterationHelpers.HasValue(_nextToken));
     
     if (useParameterSelect)
     {
         WriteObject(cmdletContext.Select(null, this));
     }
     
     
     return null;
 }
        /// <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>
        public Task<ListUsersResponse> ListUsersAsync(ListUsersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ListUsersRequestMarshaller();
            var unmarshaller = ListUsersResponseUnmarshaller.Instance;

            return InvokeAsync<ListUsersRequest,ListUsersResponse>(request, marshaller, 
                unmarshaller, cancellationToken);
        }
        /// <summary>
        /// Lists the users in the Amazon Cognito user pool.
        /// </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 CognitoIdentityProvider.</returns>
        /// <exception cref="Amazon.CognitoIdentityProvider.Model.InternalErrorException">
        /// This exception is thrown when Amazon Cognito encounters an internal error.
        /// </exception>
        /// <exception cref="Amazon.CognitoIdentityProvider.Model.InvalidParameterException">
        /// This exception is thrown when the Amazon Cognito service encounters an invalid parameter.
        /// </exception>
        /// <exception cref="Amazon.CognitoIdentityProvider.Model.NotAuthorizedException">
        /// This exception gets thrown when a user is not authorized.
        /// </exception>
        /// <exception cref="Amazon.CognitoIdentityProvider.Model.ResourceNotFoundException">
        /// This exception is thrown when the Amazon Cognito service cannot find the requested
        /// resource.
        /// </exception>
        /// <exception cref="Amazon.CognitoIdentityProvider.Model.TooManyRequestsException">
        /// This exception gets thrown when the user has made too many requests for a given operation.
        /// </exception>
        public ListUsersResponse ListUsers(ListUsersRequest request)
        {
            var marshaller = new ListUsersRequestMarshaller();
            var unmarshaller = ListUsersResponseUnmarshaller.Instance;

            return Invoke<ListUsersRequest,ListUsersResponse>(request, marshaller, unmarshaller);
        }
        /// <summary>
        /// Initiates the asynchronous execution of the ListUsers operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ListUsers operation on AmazonCognitoIdentityProviderClient.</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>
        public IAsyncResult BeginListUsers(ListUsersRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new ListUsersRequestMarshaller();
            var unmarshaller = ListUsersResponseUnmarshaller.Instance;

            return BeginInvoke<ListUsersRequest>(request, marshaller, unmarshaller,
                callback, state);
        }