private async Task <AuthEventEnum> NextChallenge(AuthEventEnum lastAuthEventEnum = AuthEventEnum.AuthChallenge)
{
await Init();
try
{
if (!HasChallenge)
{
switch (CurrentAuthProcess)
{
case AuthProcessEnum.None:
return(AuthEventEnum.Alert_NothingToDo);
case AuthProcessEnum.ResettingPassword:
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.PasswordResetDone);
case AuthProcessEnum.SigningUp:
if (HasChallenge)
{
return(AuthEventEnum.AuthChallenge);
}
if (!IsLoginFormatOk)
{
AuthChallengeList.Add(AuthChallengeEnum.Login);
}
else
if (!IsPasswordFormatOk)
{
AuthChallengeList.Add(AuthChallengeEnum.Password);
}
else
if (!IsEmailFormatOk)
{
AuthChallengeList.Add(AuthChallengeEnum.Email);
}
if (HasChallenge)
{
return(AuthEventEnum.AuthChallenge);
}
if (!IsCodeVerified)
{
// Request causes AWS to send Auth Code to user by email
var attr = new Dictionary <string, string>()
{
{ "email", email }
};
await jsModule.InvokeVoidAsync("LzAuth.signUp", login, password, attr);
if (!AuthChallengeList.Contains(AuthChallengeEnum.Code))
{
AuthChallengeList.Add(AuthChallengeEnum.Code);
}
return(AuthEventEnum.AuthChallenge);
}
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.SignedUp);
case AuthProcessEnum.SigningIn:
// await jsModule.InvokeVoidAsync("signIn", login, password);
await jsModule.InvokeVoidAsync("LzAuth.signIn", login, password);
IsSignedIn = true;
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.SignedIn);
case AuthProcessEnum.UpdatingEmail:
if (!IsCodeVerified)
{
AuthChallengeList.Add(AuthChallengeEnum.Code);
return(AuthEventEnum.VerificationCodeSent);
}
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.EmailUpdateDone);
case AuthProcessEnum.UpdatingPassword:
await jsModule.InvokeVoidAsync("LzAuth.changePassword", password, newPassword);
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.PasswordUpdateDone);
case AuthProcessEnum.UpdatingPhone:
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.PhoneUpdateDone);
}
}
}
catch (JSException ex)
{
var msg = ex.Message;
Debug.WriteLine(ex.Message);
//return GetAuthEventEnumForJsError(e);
}
catch (Exception e)
{
string message = e.Message;
return(AuthEventEnum.Alert_Unknown);
}
return(lastAuthEventEnum);
}
public virtual async Task <AuthEventEnum> VerifyNewEmailAsync(string newEmail)
{
if (CurrentChallenge != AuthChallengeEnum.NewEmail)
{
return(AuthEventEnum.Alert_VerifyCalledButNoChallengeFound);
}
if (!CheckEmailFormat(newEmail))
{
return(AuthEventEnum.Alert_EmailFormatRequirementsFailed);
}
await Init();
try
{
switch (CurrentAuthProcess)
{
case AuthProcessEnum.UpdatingEmail:
if (!IsSignedIn)
{
return(AuthEventEnum.Alert_NeedToBeSignedIn);
}
// Get the current values on the server.
// This step may throw an exception in RefreshUserDetailsAsync. There seems to be
// no way to recover from this other than retry or abandon the process. Let the
// calling class figure out what is right for their usecase.
AuthEventEnum refreshUserDetailsResult = await RefreshUserDetailsAsync().ConfigureAwait(false);
if (refreshUserDetailsResult != AuthEventEnum.Alert_RefreshUserDetailsDone)
{
return(AuthEventEnum.Alert_CantRetrieveUserDetails);
}
// make sure the values are different
if (this.email.Equals(newEmail)) //todo - check
{
return(AuthEventEnum.Alert_EmailAddressIsTheSame);
}
// Update the user email on the server
// Cognito sends a auth code when the Email attribute is changed
var attr = new Dictionary <string, string>()
{
{ "email", newEmail }
};
await jsModule.InvokeVoidAsync("LzAuth.updateUserAttributes", attr);
AuthChallengeList.Remove(AuthChallengeEnum.NewEmail);
IsEmailVerified = true;
return(await NextChallenge());
default:
return(AuthEventEnum.Alert_InternalProcessError);
}
}
catch (JSException e)
{
return(GetAuthEventEnumForJsError(e));
}
catch (Exception e)
{
Debug.WriteLine($"UpdateEmail() threw an exception {e}");
return(AuthEventEnum.Alert_Unknown);
}
}
private async Task <AuthEventEnum> NextChallenge(AuthEventEnum lastAuthEventEnum = AuthEventEnum.AuthChallenge)
{
try
{
if (!HasChallenge)
{
switch (CurrentAuthProcess)
{
case AuthProcessEnum.None:
return(AuthEventEnum.Alert_NothingToDo);
case AuthProcessEnum.ResettingPassword:
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.PasswordResetDone);
case AuthProcessEnum.SigningUp:
if (HasChallenge)
{
return(AuthEventEnum.AuthChallenge);
}
if (!IsLoginFormatOk)
{
AuthChallengeList.Add(AuthChallengeEnum.Login);
}
else
if (!IsPasswordFormatOk)
{
AuthChallengeList.Add(AuthChallengeEnum.Password);
}
else
if (!IsEmailFormatOk)
{
AuthChallengeList.Add(AuthChallengeEnum.Email);
}
if (HasChallenge)
{
return(AuthEventEnum.AuthChallenge);
}
if (!IsCodeVerified)
{
// Request Auth Code
var signUpRequest = new SignUpRequest()
{
ClientId = clientId,
Password = password,
Username = login
};
signUpRequest.UserAttributes.Add(
new AttributeType()
{
Name = "email",
Value = email
});
// This call may throw an exception
var result = await providerClient.SignUpAsync(signUpRequest).ConfigureAwait(false);
if (!AuthChallengeList.Contains(AuthChallengeEnum.Code))
{
AuthChallengeList.Add(AuthChallengeEnum.Code);
}
return(AuthEventEnum.AuthChallenge);
}
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.SignedUp);
case AuthProcessEnum.SigningIn:
if (authFlowResponse != null && authFlowResponse.ChallengeName == ChallengeNameType.NEW_PASSWORD_REQUIRED) // Update Passsword
{
if (!AuthChallengeList.Contains(AuthChallengeEnum.NewPassword))
{
AuthChallengeList.Add(AuthChallengeEnum.NewPassword);
}
authFlowResponse = null;
return(AuthEventEnum.AuthChallenge);
}
// Grab JWT from login to User Pools to extract User Pool Identity
//var token = new JwtSecurityToken(jwtEncodedString: CognitoUser.SessionTokens.IdToken);
//UpIdentity = token.Claims.First(c => c.Type == "sub").Value; // JWT sub cliam contains User Pool Identity
//// Note: creates Identity Pool identity if it doesn't exist
Credentials = CognitoUser.GetCognitoAWSCredentials(identityPoolId, regionEndpoint);
IsSignedIn = true;
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.SignedIn);
case AuthProcessEnum.UpdatingEmail:
if (!IsCodeVerified)
{
AuthChallengeList.Add(AuthChallengeEnum.Code);
return(AuthEventEnum.VerificationCodeSent);
}
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.EmailUpdateDone);
case AuthProcessEnum.UpdatingPassword:
await CognitoUser.ChangePasswordAsync(password, newPassword).ConfigureAwait(false);
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.PasswordUpdateDone);
case AuthProcessEnum.UpdatingPhone:
CurrentAuthProcess = AuthProcessEnum.None;
ClearSensitiveFields();
return(AuthEventEnum.PhoneUpdateDone);
}
}
}
catch (UsernameExistsException) { return(AuthEventEnum.Alert_LoginAlreadyUsed); }
catch (InvalidParameterException) { return(AuthEventEnum.Alert_InternalProcessError); }
catch (InvalidPasswordException) { return(AuthEventEnum.Alert_PasswordFormatRequirementsFailed); }
catch (TooManyRequestsException) { return(AuthEventEnum.Alert_TooManyAttempts); }
catch (TooManyFailedAttemptsException) { return(AuthEventEnum.Alert_TooManyAttempts); }
catch (PasswordResetRequiredException) { return(AuthEventEnum.Alert_PasswordResetRequiredException); }
catch (Exception e)
{
Debug.WriteLine($"SignUp() threw an exception {e}");
return(AuthEventEnum.Alert_Unknown);
}
return(lastAuthEventEnum);
}
public AuthModuleEventArgs(AuthEventEnum r)
{
Result = r;
}
protected async virtual Task <AuthEventEnum> RaiseAuthModuleEventAndProperties(AuthEventEnum r)
{
await Task.Delay(0);
OnAuthModuleEvent(new AuthModuleEventArgs(r));
// update alert message
_alertMessage = string.Empty;
if ((int)r >= (int)AuthEventEnum.Alert) // All enum items after the enum Alert are Alerts
{
string message = appConfig[$"AuthAlertMessages:{LanguageCode}:{r}"];
_alertMessage =
message == null
? r.ToString()
:message;
}
// update process message
if (string.IsNullOrEmpty(AuthChallengeMessage) || lastAuthChallengeEnum != CurrentChallenge)
{
string challengeMessage = appConfig[$"AuthChallengeMessages:{LanguageCode}:{CurrentChallenge}"];
_authChallengeMessage =
challengeMessage == null
? CurrentChallenge.ToString()
: challengeMessage;
lastAuthChallengeEnum = CurrentChallenge;
}
// update challenge message
if (string.IsNullOrEmpty(AuthProcessMessage) || lastAuthProcessEnum != CurrentAuthProcess)
{
string processMessage = appConfig[$"AuthProcessMessages:{LanguageCode}:{CurrentAuthProcess}"];
_authProcessMessage =
processMessage == null
? CurrentAuthProcess.ToString()
: processMessage;
lastAuthProcessEnum = CurrentAuthProcess;
}
if (r == AuthEventEnum.SignedIn ||
r == AuthEventEnum.SignedUp ||
r == AuthEventEnum.SignedOut ||
r == AuthEventEnum.PasswordResetDone
)
{
ClearSensitiveFields();
}
if (IsChatty)
{
RaiseAllProperties();
}
return(r);
}
void RaiseAuthModuleEvent(AuthEventEnum r)
{
OnAuthModuleEvent(new AuthModuleEventArgs(r));
}
