public CognitoController(
IAmazonCognitoIdentityProvider client,
ILogger <CognitoController> logger)
{
this.client = client;
this.logger = logger;
}
//--- Constructors ---
public CognitoPostConfirmation(string prefix)
{
//_s3Client = new AmazonS3Client();
aDate = DateTime.UtcNow.AddHours(2); // Viser l'heure en cours en France
_cognitoIdentityProviderClient = new AmazonCognitoIdentityProviderClient();
_prefix = prefix;
}
public CognitoUsersClient(
IAmazonCognitoIdentityProvider cognito,
IUserIdsStorageManager userIdsStorage,
string userPoolId)
{
this.userIdsStorage = userIdsStorage;
this.cognito = cognito;
this.userPoolId = userPoolId;
}
public AwsCognitoAdapter(
IAmazonCognitoIdentityProvider awsCognitoClient,
AwsCognitoAdapterConfig cognitoConfig,
IAwsCognitoAdapterHelper cognitoAdapterHelper)
{
_awsCognitoClient = awsCognitoClient;
_clientId = cognitoConfig.ClientId;
_cognitoAdapterHelper = cognitoAdapterHelper;
}
public SignupsController(
IAmazonCognitoIdentityProvider identityProvider,
AWSCognitoClientOptions options,
CognitoClientSecret clientSecret)
{
_identityProvider = identityProvider ?? throw new ArgumentNullException(nameof(identityProvider));
_options = options ?? throw new ArgumentNullException(nameof(options));
_clientSecret = clientSecret ?? throw new ArgumentNullException(nameof(clientSecret));
}
void Start()
{
_aws = gameObject.AddComponent <AWSSDK>();
_cipClient = _aws.CreateCognitoIdentityProviderClient(
_aws.CreateAnonymousAWSCredentials(),
Region);
_pool = new CognitoUserPool(UserPoolId, ClientId, _cipClient);
_user = new CognitoUser("wuddupbuddddy", ClientId, _pool, _cipClient);
}
public UserService(IAmazonDynamoDB dynamoDb,
IAmazonCognitoIdentityProvider cognito,
IConfiguration config,
IUtilityService utils)
{
_dynamoDb = dynamoDb;
_cognito = cognito;
_config = config;
_utils = utils;
}
public void Setup()
{
_cognitoAdapterConfig = new AwsCognitoAdapterConfig
{
UserPoolId = "fake-userpool-id",
ClientId = "fake-client-id"
};
_awsCognitoClient = Substitute.For <IAmazonCognitoIdentityProvider>();
_cognitoAdapterHelper = new AwsCognitoAdapterHelper(_cognitoAdapterConfig, _awsCognitoClient);
}
/// <summary>
/// Creates an instance of CognitoUser
/// </summary>
/// <param name="userID">UserID of the specified user</param>
/// <param name="clientID">ClientID associated with the user pool</param>
/// <param name="pool">CognitoUserPool this user is associated with </param>
/// <param name="provider">IAmazonCognitoIdentityProvider for the specified user pool</param>
/// <param name="clientSecret">Client secret for the specified client, if exists</param>
/// <param name="username">Username for user, if different from userID</param>
public CognitoUser(string userID, string clientID,
CognitoUserPool pool,
IAmazonCognitoIdentityProvider provider,
string clientSecret = null,
string status = null,
string username = null,
Dictionary <string, string> attributes = null)
{
if (pool.PoolID.Contains("_"))
{
this.PoolName = pool.PoolID.Split('_')[1];
}
else
{
throw new ArgumentException("Pool's poolID malformed, should be of the form <region>_<poolname>.");
}
this.ClientSecret = clientSecret;
if (!string.IsNullOrEmpty(clientSecret))
{
this.SecretHash = CognitoAuthHelper.GetUserPoolSecretHash(userID, clientID, clientSecret);
}
this.UserID = userID;
this.Username = userID;
if (!string.IsNullOrEmpty(username))
{
this.Username = username;
}
else
{
this.Username = userID;
}
this.Status = status;
this.UserPool = pool;
this.ClientID = clientID;
this.SessionTokens = null;
if (attributes != null)
{
this.Attributes = attributes;
}
this.Provider = provider;
if (this.Provider is AmazonCognitoIdentityProviderClient eventProvider)
{
eventProvider.BeforeRequestEvent += CognitoAuthHelper.ServiceClientBeforeRequestEvent;
}
}
public AccountController(SignInManager <CognitoUser> signInManager,
UserManager <CognitoUser> userManager,
CognitoUserPool pool,
IAmazonCognitoIdentityProvider identityProvider,
IConfiguration configuration)
{
this.signInManager = signInManager;
this.userManager = userManager;
this.pool = pool;
this.identityProvider = identityProvider;
this.configuration = configuration;
}
public RegisterModel(
UserManager <CognitoUser> userManager,
SignInManager <CognitoUser> signInManager,
ILogger <RegisterModel> logger,
CognitoUserPool pool,
IAmazonCognitoIdentityProvider provider)
{
_userManager = userManager as CognitoUserManager <CognitoUser>;
_signInManager = signInManager;
_logger = logger;
_pool = pool;
_provider = provider;
}
public DeviceAuthenticationMethod(ILogger logger, IDevicePreferences preferences, IAWSSDK aws, string region, string userPoolId, string clientId, string identityPoolId)
{
_logger = logger;
_preferences = preferences;
_aws = aws;
_region = region;
_userPoolId = userPoolId;
_clientId = clientId;
_identityPoolId = identityPoolId;
_cipClient = _aws.CreateCognitoIdentityProviderClient(
_aws.CreateAnonymousAWSCredentials(),
_region
);
}
/// <summary>
/// Create an instance of CognitoUserPool
/// </summary>
/// <param name="poolID">PoolID of the associated user pool</param>
/// <param name="clientID">ClientID for the associated user pool</param>
/// <param name="provider">AmazonCognitoIdentityProviderClient for the specified user pool</param>
/// <param name="clientSecret">Client secret for the corresponding clientID, if exists</param>
public CognitoUserPool(string poolID,
string clientID,
IAmazonCognitoIdentityProvider provider,
string clientSecret = null)
{
if (!poolID.Contains("_"))
{
throw new ArgumentException("PoolID should be of the form <region>_<poolname>.", "poolID");
}
this.PoolID = poolID;
this.ClientID = clientID;
this.ClientSecret = clientSecret;
this.Provider = provider;
//this.Provider.BeforeRequestEvent += Util.ServiceClientBeforeRequestEvent;
}
public CognitoUserStore(IAmazonCognitoIdentityProvider cognitoClient, CognitoUserPool pool, IdentityErrorDescriber errors)
{
_cognitoClient = cognitoClient ?? throw new ArgumentNullException(nameof(cognitoClient));
_pool = pool ?? throw new ArgumentNullException(nameof(pool));
// IdentityErrorDescriber provides predefined error strings such as PasswordMismatch() or InvalidUserName(String)
// This is used when returning an instance of IdentityResult, which can be constructed with an array of errors to be surfaced to the UI.
if (errors == null)
{
throw new ArgumentNullException(nameof(errors));
}
if (errors is CognitoIdentityErrorDescriber)
{
_errorDescribers = errors as CognitoIdentityErrorDescriber;
}
else
{
throw new ArgumentException("The IdentityErrorDescriber must be of type CognitoIdentityErrorDescriber", nameof(errors));
}
}
/// <summary>
/// Creates an instance of CognitoUser
/// </summary>
/// <param name="userID">UserID of the specified user</param>
/// <param name="clientID">ClientID associated with the user pool</param>
/// <param name="pool">CognitoUserPool this user is associated with </param>
/// <param name="provider">AmazonCognitoIdentityProviderClient for the specified user pool</param>
/// <param name="clientSecret">Client secret for the specified client, if exists</param>
/// <param name="username">Username for user, if different from userID</param>
public CognitoUser(string userID, string clientID,
CognitoUserPool pool,
IAmazonCognitoIdentityProvider provider,
string clientSecret = null,
string username = null)
{
if (pool.PoolID.Contains("_"))
{
this.PoolName = pool.PoolID.Split('_')[1];
}
else
{
throw new ArgumentException("Pool's poolID malformed, should be of the form <region>_<poolname>.");
}
this.ClientSecret = clientSecret;
if (!string.IsNullOrEmpty(clientSecret))
{
this.SecretHash = Util.GetUserPoolSecretHash(userID, clientID, clientSecret);
}
this.UserID = userID;
this.Username = userID;
if (!string.IsNullOrEmpty(username))
{
this.Username = username;
}
else
{
this.Username = userID;
}
this.UserPool = pool;
this.ClientID = clientID;
this.SessionTokens = null;
this.Provider = provider;
//this.Provider.BeforeRequestEvent += Util.ServiceClientBeforeRequestEvent;
}
internal CognitoIdentityProviderPaginatorFactory(IAmazonCognitoIdentityProvider client)
{
this.client = client;
}
public AwsCognitoAdapterHelper(AwsCognitoAdapterConfig cognitoAdapterConfig, IAmazonCognitoIdentityProvider awsCognitoClient)
{
_userPoolId = cognitoAdapterConfig.UserPoolId;
_awsCognitoClient = awsCognitoClient;
}
public CustomAWSOptions(IAmazonCognitoIdentityProvider identityProvider, CognitoUserPool userPool)
{
_identityProvider = identityProvider;
_userPool = userPool;
}
internal ListUsersPaginator(IAmazonCognitoIdentityProvider client, ListUsersRequest request)
{
this._client = client;
this._request = request;
}
protected override void ProcessRecord()
{
base.ProcessRecord();
Client = CreateClient(_RegionEndpoint);
}
public CognitoUserManager(IAmazonCognitoIdentityProvider cognitoClient, IConfiguration configuration)
{
_cognitoClient = cognitoClient ?? throw new ArgumentNullException(nameof(cognitoClient));
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
}
public AuthenticationController(IAmazonCognitoIdentityProvider cognitoClient, ILogger <AuthenticationController> logger) : base(logger)
{
_client = cognitoClient;
}
public AccountController(CognitoUserPool userPool, IAmazonCognitoIdentityProvider identityProvider)
{
_userPool = userPool;
_identityProvider = identityProvider;
}
public CognitoRoleStore(IAmazonCognitoIdentityProvider cognitoClient, CognitoUserPool pool)
{
_cognitoClient = cognitoClient ?? throw new ArgumentNullException(nameof(cognitoClient));
_pool = pool ?? throw new ArgumentNullException(nameof(pool));
}
internal AdminListGroupsForUserPaginator(IAmazonCognitoIdentityProvider client, AdminListGroupsForUserRequest request)
{
this._client = client;
this._request = request;
}
public CognitoSignUpController(IAmazonCognitoIdentityProvider amazonCognitoIdentityProvider)
{
_amazonCognitoIdentityProvider = amazonCognitoIdentityProvider;
}
internal AdminListUserAuthEventsPaginator(IAmazonCognitoIdentityProvider client, AdminListUserAuthEventsRequest request)
{
this._client = client;
this._request = request;
}
//--- Constructors ---
public CognitoPostConfirmation(string prefix)
{
_s3Client = new AmazonS3Client();
_cognitoIdentityProviderClient = new AmazonCognitoIdentityProviderClient();
_prefix = prefix;
}
private Amazon.CognitoIdentityProvider.Model.SetUserPoolMfaConfigResponse CallAWSServiceOperation(IAmazonCognitoIdentityProvider client, Amazon.CognitoIdentityProvider.Model.SetUserPoolMfaConfigRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Cognito Identity Provider", "SetUserPoolMfaConfig");
try
{
#if DESKTOP
return(client.SetUserPoolMfaConfig(request));
#elif CORECLR
return(client.SetUserPoolMfaConfigAsync(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;
}
}
internal AdminAwsCognitoAdapter(IAmazonCognitoIdentityProvider awsCognitoClient, AwsCognitoAdapterConfig cognitoConfig, IAwsCognitoAdapterHelper cognitoAdapterHelper) : base(awsCognitoClient, cognitoConfig, cognitoAdapterHelper)
{
}
