//public CognitoAWSCredentials GetCachedCognitoIdentity()
//{
// Console.WriteLine("GetCachedCognitoIdentity");
// if (!string.IsNullOrEmpty(credentials.GetCachedIdentityId()) || credentials.CurrentLoginProviders.Length > 0)
// {
// return credentials;
// }
// return null;
//}
public async Task GetAWSCredentialsWithGoogleToken(string token)
{
try
{
CognitoAWSCredentials credentials = new CognitoAWSCredentials(this.IDENTITYPOOL_ID, RegionEndpoint.EUCentral1);
credentials.Clear();
credentials.AddLogin("accounts.google.com", token);
AmazonCognitoIdentityClient cli = new AmazonCognitoIdentityClient(credentials, RegionEndpoint.EUCentral1);
var req = new Amazon.CognitoIdentity.Model.GetIdRequest();
req.Logins.Add("accounts.google.com", token);
req.IdentityPoolId = this.IDENTITYPOOL_ID;
GetIdResponse getIdResponse = await cli.GetIdAsync(req);
var getCredentialReq = new Amazon.CognitoIdentity.Model.GetCredentialsForIdentityRequest();
getCredentialReq.IdentityId = getIdResponse.IdentityId;
getCredentialReq.Logins.Add("accounts.google.com", token);
GetCredentialsForIdentityResponse getCredentialsResponse = await cli.GetCredentialsForIdentityAsync(getCredentialReq);
UserInfo.Credentials = getCredentialsResponse.Credentials;
UserInfo.IdentityId = getCredentialsResponse.IdentityId;
}
catch (Exception ex)
{
Console.WriteLine("GetAWSCredentialsWithGoogleToken ERROR: " + ex.Message);
throw ex;
}
}
static private async Task <UserCognitoCredentials> getCognitoCredentials(String userEmail, String userPassword)
{
String cognitoUserPoolId = "us-east-1_n8TiZp7tu";
String cognitoClientId = "6clvd0v40jggbaa5qid2h6hkqf";
String cognitoIdentityPoolId = "us-east-1:bff024bb-06d0-4b04-9e5d-eb34ed07f884";
Amazon.RegionEndpoint cognitoRegion = Amazon.RegionEndpoint.USEast1;
AmazonCognitoIdentityProviderClient provider =
new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials(), Amazon.RegionEndpoint.USEast1);
CognitoUserPool userPool = new CognitoUserPool(cognitoUserPoolId, cognitoClientId, provider);
CognitoUser user = new CognitoUser(userEmail, cognitoClientId, userPool, provider);
AuthFlowResponse context = await user.StartWithSrpAuthAsync(new InitiateSrpAuthRequest()
{
Password = userPassword
}).ConfigureAwait(false);
String accessToken = context.AuthenticationResult.AccessToken;
String idToken = context.AuthenticationResult.IdToken;
CognitoAWSCredentials credentials =
user.GetCognitoAWSCredentials(cognitoIdentityPoolId, cognitoRegion);
var identityClient = new AmazonCognitoIdentityClient(credentials, cognitoRegion);
var idRequest = new Amazon.CognitoIdentity.Model.GetIdRequest();
idRequest.IdentityPoolId = cognitoIdentityPoolId;
idRequest.Logins = new Dictionary <string, string> {
{ "cognito-idp.us-east-1.amazonaws.com/" + cognitoUserPoolId, idToken }
};
var idResponseId = await identityClient.GetIdAsync(idRequest).ConfigureAwait(false);
if (idResponseId.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
Console.WriteLine(String.Format("Failed to get credentials for identity. Status code: {0} ", idResponseId.HttpStatusCode));
System.Environment.Exit(1);
}
var idResponseCredential = await identityClient.GetCredentialsForIdentityAsync(idResponseId.IdentityId, new Dictionary <string, string> {
{ "cognito-idp.us-east-1.amazonaws.com/" + cognitoUserPoolId, idToken }
}).ConfigureAwait(false);
if (idResponseCredential.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
Console.WriteLine(String.Format("Failed to get credentials for identity. Status code: {0} ", idResponseCredential.HttpStatusCode));
System.Environment.Exit(1);
}
var cognitoCredentials = new UserCognitoCredentials(idResponseCredential.Credentials);
return(cognitoCredentials);
}
/// <summary>
/// Generates (or retrieves) a Cognito ID. Supplying multiple logins will create an implicit
/// linked account.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetId service method.</param>
///
/// <returns>The response from the GetId service method, as returned by CognitoIdentity.</returns>
/// <exception cref="Amazon.CognitoIdentity.Model.InternalErrorException">
/// Thrown when the service encounters an error during processing the request.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.InvalidParameterException">
/// Thrown for missing or bad input parameter(s).
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.LimitExceededException">
/// Thrown when the total number of user pools has exceeded a preset limit.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.NotAuthorizedException">
/// Thrown when a user is not authorized to access the requested resource.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.ResourceConflictException">
/// Thrown when a user tries to use a login which is already linked to another account.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.ResourceNotFoundException">
/// Thrown when the requested resource (for example, a dataset or record) does not exist.
/// </exception>
/// <exception cref="Amazon.CognitoIdentity.Model.TooManyRequestsException">
/// Thrown when a request is throttled.
/// </exception>
internal GetIdResponse GetId(GetIdRequest request)
{
var marshaller = new GetIdRequestMarshaller();
var unmarshaller = GetIdResponseUnmarshaller.Instance;
return Invoke<GetIdRequest,GetIdResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Initiates the asynchronous execution of the GetId operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetId operation on AmazonCognitoIdentityClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void GetIdAsync(GetIdRequest request, AmazonServiceCallback<GetIdRequest, GetIdResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new GetIdRequestMarshaller();
var unmarshaller = GetIdResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<GetIdRequest,GetIdResponse> responseObject
= new AmazonServiceResult<GetIdRequest,GetIdResponse>((GetIdRequest)req, (GetIdResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<GetIdRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Initiates the asynchronous execution of the GetId operation.
/// <seealso cref="Amazon.CognitoIdentity.IAmazonCognitoIdentity.GetId"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetId 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<GetIdResponse> GetIdAsync(GetIdRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetIdRequestMarshaller();
var unmarshaller = GetIdResponseUnmarshaller.GetInstance();
return Invoke<IRequest, GetIdRequest, GetIdResponse>(request, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// Generates (or retrieves) a Cognito ID. Supplying multiple logins will create an implicit
/// linked account.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetId service method.</param>
///
/// <returns>The response from the GetId service method, as returned by CognitoIdentity.</returns>
/// <exception cref="T:Amazon.CognitoIdentity.Model.InternalErrorException">
/// Thrown when the service encounters an error during processing the request.
/// </exception>
/// <exception cref="T:Amazon.CognitoIdentity.Model.InvalidParameterException">
/// Thrown for missing or bad input parameter(s).
/// </exception>
/// <exception cref="T:Amazon.CognitoIdentity.Model.LimitExceededException">
/// Thrown when the total number of user pools has exceeded a preset limit.
/// </exception>
/// <exception cref="T:Amazon.CognitoIdentity.Model.NotAuthorizedException">
/// Thrown when a user is not authorized to access the requested resource.
/// </exception>
/// <exception cref="T:Amazon.CognitoIdentity.Model.ResourceConflictException">
/// Thrown when a user tries to use a login which is already linked to another account.
/// </exception>
/// <exception cref="T:Amazon.CognitoIdentity.Model.ResourceNotFoundException">
/// Thrown when the requested resource (for example, a dataset or record) does not exist.
/// </exception>
/// <exception cref="T:Amazon.CognitoIdentity.Model.TooManyRequestsException">
/// Thrown when a request is throttled.
/// </exception>
public GetIdResponse GetId(GetIdRequest request)
{
var task = GetIdAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// Gets the Identity Id corresponding to the credentials retrieved from Cognito.
/// Note: this setting may change during execution. To be notified of its
/// new value, attach a listener to IdentityChangedEvent
/// </summary>
public async System.Threading.Tasks.Task<string> GetIdentityIdAsync()
{
if (!IsIdentitySet)
{
var cachedIdentityId = this.GetCachedIdentityId();
if (string.IsNullOrEmpty(cachedIdentityId))
{
var getIdRequest = new GetIdRequest
{
AccountId = AccountId,
IdentityPoolId = IdentityPoolId,
Logins = Logins
};
var getIdResult = await cib.GetIdAsync(getIdRequest);
UpdateIdentity(getIdResult.IdentityId, true);
}
else
{
UpdateIdentity(cachedIdentityId, false);
}
}
return identityId;
}
/// <summary>
/// Gets the Identity Id corresponding to the credentials retrieved from Cognito.
/// Note: this setting may change during execution. To be notified of its
/// new value, attach a listener to IdentityChangedEvent
/// </summary>
public string GetIdentityId()
{
if (!IsIdentitySet)
{
var cachedIdentityId = this.GetCachedIdentityId();
if (string.IsNullOrEmpty(cachedIdentityId))
{
var getIdRequest = new GetIdRequest
{
AccountId = AccountId,
IdentityPoolId = IdentityPoolId,
Logins = Logins
};
#if BCL
var response = cib.GetId(getIdRequest);
#else
var response = Amazon.Runtime.Internal.Util.AsyncHelpers.RunSync<GetIdResponse>(() => cib.GetIdAsync(getIdRequest));
#endif
UpdateIdentity(response.IdentityId, true);
}
else
{
UpdateIdentity(cachedIdentityId, false);
}
}
return identityId;
}
/// <summary>
/// Gets the Identity Id corresponding to the credentials retrieved from Cognito.
/// Note: this setting may change during execution. To be notified of its
/// new value, attach a listener to IdentityChangedEvent
/// </summary>
public async System.Threading.Tasks.Task<string> GetIdentityIdAsync()
{
if (!IsIdentitySet)
{
var getIdRequest = new GetIdRequest
{
AccountId = AccountId,
IdentityPoolId = IdentityPoolId,
Logins = Logins
};
var getIdResult = await cib.GetIdAsync(getIdRequest);
UpdateIdentity(getIdResult.IdentityId, true);
}
return identityId;
}
/// <summary>
/// Initiates the asynchronous execution of the GetId operation.
/// <seealso cref="Amazon.CognitoIdentity.IAmazonCognitoIdentity"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetId operation on AmazonCognitoIdentityClient.</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 EndGetId
/// operation.</returns>
public IAsyncResult BeginGetId(GetIdRequest request, AsyncCallback callback, object state)
{
var marshaller = new GetIdRequestMarshaller();
var unmarshaller = GetIdResponseUnmarshaller.Instance;
return BeginInvoke<GetIdRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Initiates the asynchronous execution of the GetId operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetId 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<GetIdResponse> GetIdAsync(GetIdRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetIdRequestMarshaller();
var unmarshaller = GetIdResponseUnmarshaller.Instance;
return InvokeAsync<GetIdRequest,GetIdResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Provides a way to override fetching the identity in case of developer authenticated identities.
/// The default behaviour will be using Cognito to retrieve the identity id.
/// </summary>
/// <returns>returns a <see cref="IdentityState"/></returns>
public virtual async System.Threading.Tasks.Task<IdentityState> RefreshIdentityAsync()
{
bool isCached = true;
if (!IsIdentitySet)
{
var getIdRequest = new GetIdRequest
{
AccountId = AccountId,
IdentityPoolId = IdentityPoolId,
Logins = Logins
};
var response = await cib.GetIdAsync(getIdRequest).ConfigureAwait(false);
isCached = false;
UpdateIdentity(response.IdentityId);
}
return new IdentityState(identityId, isCached);
}
/// <summary>
/// Provides a way to override fetching the identity in case of developer authenticated identities.
/// The default behaviour will be using Cognito to retrieve the identity id.
/// </summary>
/// <returns>returns a <see cref="IdentityState"/></returns>
protected virtual IdentityState RefreshIdentity()
{
bool isCached = true;
if (!IsIdentitySet)
{
var getIdRequest = new GetIdRequest
{
AccountId = AccountId,
IdentityPoolId = IdentityPoolId,
Logins = Logins
};
#if BCL
var response = cib.GetId(getIdRequest);
#else
var response = Amazon.Runtime.Internal.Util.AsyncHelpers.RunSync<GetIdResponse>(() => cib.GetIdAsync(getIdRequest));
#endif
isCached = false;
UpdateIdentity(response.IdentityId);
}
return new IdentityState(identityId, isCached);
}
IAsyncResult invokeGetId(GetIdRequest request, AsyncCallback callback, object state, bool synchronized)
{
var marshaller = new GetIdRequestMarshaller();
var unmarshaller = GetIdResponseUnmarshaller.Instance;
return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer);
}
/// <summary>
/// Initiates the asynchronous execution of the GetId operation.
/// <seealso cref="Amazon.CognitoIdentity.IAmazonCognitoIdentity"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetId operation on AmazonCognitoIdentityClient.</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 EndGetId
/// operation.</returns>
public IAsyncResult BeginGetId(GetIdRequest request, AsyncCallback callback, object state)
{
return invokeGetId(request, callback, state, false);
}
/// <summary>
/// Generates (or retrieves) a Cognito ID. Supplying multiple logins will create an implicit
/// linked account.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetId service method.</param>
///
/// <returns>The response from the GetId service method, as returned by CognitoIdentity.</returns>
/// <exception cref="InternalErrorException">
/// Thrown when the service encounters an error during processing the request.
/// </exception>
/// <exception cref="InvalidParameterException">
/// Thrown for missing or bad input parameter(s).
/// </exception>
/// <exception cref="LimitExceededException">
/// Thrown when the total number of user pools has exceeded a preset limit.
/// </exception>
/// <exception cref="NotAuthorizedException">
/// Thrown when a user is not authorized to access the requested resource.
/// </exception>
/// <exception cref="ResourceConflictException">
/// Thrown when a user tries to use a login which is already linked to another account.
/// </exception>
/// <exception cref="ResourceNotFoundException">
/// Thrown when the requested resource (for example, a dataset or record) does not exist.
/// </exception>
/// <exception cref="TooManyRequestsException">
/// Thrown when a request is throttled.
/// </exception>
public GetIdResponse GetId(GetIdRequest request)
{
IAsyncResult asyncResult = invokeGetId(request, null, null, true);
return EndGetId(asyncResult);
}
