public void ResendVerification(ConfirmationResendRequest confirmationResendRequest) { AdminCreateUserRequest adminCreateUserRequest = new AdminCreateUserRequest { UserPoolId = _connectionInfo.UserPoolId, Username = confirmationResendRequest.Email, DesiredDeliveryMediums = new List <string> { "EMAIL" }, MessageAction = MessageActionType.RESEND }; try { var response = _provider.AdminCreateUserAsync(adminCreateUserRequest).Result; } catch (Exception e) { LoggingHandler.LogError(e.Message); LoggingHandler.LogError(e.StackTrace); throw; } }
public string AdminCreateUser(Boundary.Requests.AdminCreateUserRequest createRequest) { AdminCreateUserRequest adminCreateUserRequest = new AdminCreateUserRequest { UserPoolId = _connectionInfo.UserPoolId, Username = createRequest.Email, DesiredDeliveryMediums = new List <string> { "EMAIL" } }; try { var response = _provider.AdminCreateUserAsync(adminCreateUserRequest).Result; return(response.User.Username); } catch (Exception e) { LoggingHandler.LogError(e.Message); LoggingHandler.LogError(e.StackTrace); throw; } }
private Amazon.CognitoIdentityProvider.Model.AdminCreateUserResponse CallAWSServiceOperation(IAmazonCognitoIdentityProvider client, Amazon.CognitoIdentityProvider.Model.AdminCreateUserRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Cognito Identity Provider", "AdminCreateUser"); try { #if DESKTOP return(client.AdminCreateUser(request)); #elif CORECLR return(client.AdminCreateUserAsync(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; } }
public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.CognitoIdentityProvider.Model.AdminCreateUserRequest(); if (cmdletContext.ClientMetadata != null) { request.ClientMetadata = cmdletContext.ClientMetadata; } if (cmdletContext.DesiredDeliveryMedium != null) { request.DesiredDeliveryMediums = cmdletContext.DesiredDeliveryMedium; } if (cmdletContext.ForceAliasCreation != null) { request.ForceAliasCreation = cmdletContext.ForceAliasCreation.Value; } if (cmdletContext.MessageAction != null) { request.MessageAction = cmdletContext.MessageAction; } if (cmdletContext.TemporaryPassword != null) { request.TemporaryPassword = cmdletContext.TemporaryPassword; } if (cmdletContext.UserAttribute != null) { request.UserAttributes = cmdletContext.UserAttribute; } if (cmdletContext.Username != null) { request.Username = cmdletContext.Username; } if (cmdletContext.UserPoolId != null) { request.UserPoolId = cmdletContext.UserPoolId; } if (cmdletContext.ValidationData != null) { request.ValidationData = cmdletContext.ValidationData; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return(output); }
/// <summary> /// Initiates the asynchronous execution of the AdminCreateUser operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the AdminCreateUser 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<AdminCreateUserResponse> AdminCreateUserAsync(AdminCreateUserRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new AdminCreateUserRequestMarshaller(); var unmarshaller = AdminCreateUserResponseUnmarshaller.Instance; return InvokeAsync<AdminCreateUserRequest,AdminCreateUserResponse>(request, marshaller, unmarshaller, cancellationToken); }
/// <summary> /// Creates a new user in the specified user pool and sends a welcome message via email /// or phone (SMS). This message is based on a template that you configured in your call /// to CreateUserPool or UpdateUserPool. This template includes your custom sign-up instructions /// and placeholders for user name and temporary password. /// /// /// <para> /// Requires developer credentials. /// </para> /// </summary> /// <param name="request">Container for the necessary parameters to execute the AdminCreateUser service method.</param> /// /// <returns>The response from the AdminCreateUser service method, as returned by CognitoIdentityProvider.</returns> /// <exception cref="Amazon.CognitoIdentityProvider.Model.CodeDeliveryFailureException"> /// This exception is thrown when a verification code fails to deliver successfully. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.InternalErrorException"> /// This exception is thrown when Amazon Cognito encounters an internal error. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.InvalidLambdaResponseException"> /// This exception is thrown when the Amazon Cognito service encounters an invalid AWS /// Lambda response. /// </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.InvalidPasswordException"> /// This exception is thrown when the Amazon Cognito service encounters an invalid password. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.InvalidSmsRoleAccessPolicyException"> /// This exception is returned when the role provided for SMS configuration does not have /// permission to publish using Amazon SNS. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.InvalidSmsRoleTrustRelationshipException"> /// This exception is thrown when the trust relationship is invalid for the role provided /// for SMS configuration. This can happen if you do not trust <b>cognito-idp.amazonaws.com</b> /// or the external ID provided in the role does not match what is provided in the SMS /// configuration for the user pool. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.NotAuthorizedException"> /// This exception gets thrown when a user is not authorized. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.PreconditionNotMetException"> /// This exception is thrown when a precondition is not met. /// </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> /// <exception cref="Amazon.CognitoIdentityProvider.Model.UnexpectedLambdaException"> /// This exception gets thrown when the Amazon Cognito service encounters an unexpected /// exception with the AWS Lambda service. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.UnsupportedUserStateException"> /// The request failed because the user is in an unsupported state. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.UserLambdaValidationException"> /// This exception gets thrown when the Amazon Cognito service encounters a user validation /// exception with the AWS Lambda service. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.UsernameExistsException"> /// This exception is thrown when Amazon Cognito encounters a user name that already exists /// in the user pool. /// </exception> /// <exception cref="Amazon.CognitoIdentityProvider.Model.UserNotFoundException"> /// This exception is thrown when a user is not found. /// </exception> public AdminCreateUserResponse AdminCreateUser(AdminCreateUserRequest request) { var marshaller = new AdminCreateUserRequestMarshaller(); var unmarshaller = AdminCreateUserResponseUnmarshaller.Instance; return Invoke<AdminCreateUserRequest,AdminCreateUserResponse>(request, marshaller, unmarshaller); }
/// <summary> /// Initiates the asynchronous execution of the AdminCreateUser operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the AdminCreateUser 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 EndAdminCreateUser /// operation.</returns> public IAsyncResult BeginAdminCreateUser(AdminCreateUserRequest request, AsyncCallback callback, object state) { var marshaller = new AdminCreateUserRequestMarshaller(); var unmarshaller = AdminCreateUserResponseUnmarshaller.Instance; return BeginInvoke<AdminCreateUserRequest>(request, marshaller, unmarshaller, callback, state); }
/// <summary> /// Used to Create User in cognito. other attributes can be provided but are not mandatory. /// </summary> /// <param name="username"></param> /// <param name="email"></param> /// <param name="phoneNumber"></param> /// <returns></returns> public async Task <AdminCreateUserResponse> AdminCreateUserAsync(Real.AdminCreateUserRequest request) { AmazonCognitoIdentityProviderClient provider = new AmazonCognitoIdentityProviderClient(RegionEndpoint.GetBySystemName(REGION)); AWSModels.AdminCreateUserRequest userRequest = new AWSModels.AdminCreateUserRequest(); userRequest.Username = request.Username; userRequest.UserPoolId = POOL_ID; userRequest.DesiredDeliveryMediums = new List <string>() { "EMAIL" }; userRequest.TemporaryPassword = PasswordGenerator.GeneratePassword(true, true, true, true, false, 6); userRequest.UserAttributes.Add(new AttributeType { Name = "email", Value = request.Email }); userRequest.UserAttributes.Add(new AttributeType { Name = "phone_number", Value = request.PhoneNumber }); AdminCreateUserResponse response = null; try { response = await provider.AdminCreateUserAsync(userRequest); } catch (CodeDeliveryFailureException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.CodeDeliveryFailureException, ex.StackTrace, ex.Message); } catch (InternalErrorException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.InternalErrorException, ex.StackTrace, ex.Message); } catch (InvalidLambdaResponseException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.InvalidLambdaResponseException, ex.StackTrace, ex.Message); } catch (InvalidParameterException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.InvalidParameterException, ex.StackTrace, ex.Message); } catch (InvalidUserPoolConfigurationException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.InvalidUserPoolConfigurationException, ex.StackTrace, ex.Message); } catch (PasswordResetRequiredException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.PasswordResetRequiredException, ex.StackTrace, ex.Message); } catch (ResourceNotFoundException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.ResourceNotFoundException, ex.StackTrace, ex.Message); } catch (TooManyRequestsException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.TooManyRequestsException, ex.StackTrace, ex.Message); } catch (UnexpectedLambdaException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.UnexpectedLambdaException, ex.StackTrace, ex.Message); } catch (UserLambdaValidationException ex) { if (ex.Message == "User account already exists") { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.UserNameExistsException, ex.StackTrace, ex.Message); } ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.UserLambdaValidationException, ex.StackTrace, ex.Message); } catch (UserNotConfirmedException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.UserNotConfirmedException, ex.StackTrace, ex.Message); } catch (UserNotFoundException ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.UserNotFoundException, ex.StackTrace, ex.Message); } catch (AmazonCognitoIdentityProviderException ex) { if (ex.Message == "User account already exists") { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.UserNameExistsException, ex.StackTrace, ex.Message); } ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.AmazonCognitoIdentityProviderException, ex.StackTrace, ex.Message); } catch (Exception ex) { ThrowCustomException(CognitoActionType.AdminCreateUser, ExceptionConstants.ErrorException, ex.StackTrace, ex.Message); } return(response); }