Password Reset Center Workflow Activities

//Instantiate a new instance of the RecoveryManager class, passing in TargetPerson
recoveryManager = new RecoveryManager(TargetPerson);

//Set the RecoveryResult property to the recoveryManager status
RecoveryResult = recoveryManager.Status;

//If person is not enrolled for Password Self-Service reset display the 
//invalid enrollment message and exit the activity; otherwise, begin the recovery process
//by executing the AnswerQuestion Form activity 

if (RecoveryResult != RecoveryStatus.Recovering)
     InvalidEnrollmentMessage.Message = this.GetRecoveryStatusMessage(RecoveryResult);
else
{
    this.InitializeRecoveryAttempt();
}

//Sets the Title and Description properties for the InvalidEnrollmentMessage Bubble activity
InvalidEnrollmentMessage.ControlTitle = "EmpowerIDApplicationGeneralMessages_MessageBoxRequestStatusTitle";
InvalidEnrollmentMessage.ControlDescription = "EmpowerIDApplicationGeneralMessages_MessageBoxRequestStatusDesc";

//Sets the Title and Description properties for the AnswerQuestion Form activity
AnswerQuestion.ControlTitle = "PasswordManagerQuestions_AnswerQuestionsTitle";
AnswerQuestion.ControlDescription = "PasswordManagerQuestions_AnswerQuestionsDesc";

//Instantiate a new instance of the AnswerRecoveryResult class, 
//passing in the answer to the challenge question provided by the person
AnswerRecoveryQuestionResult AnswerRecoveryQuestionResult = recoveryAttemp.AnswerQuestion(AnswerQuestion.Answer);

//Set the RecoveryResult property to the AnswerRecoveryQuestionResult status
//If the person answered the question correctly, the status is set to Recovering
RecoveryResult = AnswerRecoveryQuestionResult.Status; 

//Reset the answer to an empty string for the next iteration
AnswerQuestion.Answer = "";

//If the person answered the question correctly the status is set to recovering
//and the next question is presented
if (AnswerRecoveryQuestionResult.Status == RecoveryStatus.Recovering)
{
     AnswerQuestion.Question = AnswerRecoveryQuestionResult.NextQuestion;

}
else
{
    //If the RecoveryStatus for the person is not set to Recovered and they did not correctly answer the
    //the challenge question, call SetFailedAttempt(). If the status is set to Recovered, then exit the activity    
    if (AnswerRecoveryQuestionResult.Status != RecoveryStatus.Recovered)
      {
         recoveryManager.SetFailedAttempt();

         //If the person reaches the maximum number of failed attempts set the status to 
         //Lockout; otherwise, call the InitializeRecoveryAttempt() and present the next question
         if (recoveryManager.Status == RecoveryStatus.Lockout)
         {
                 RecoveryResult = recoveryManager.Status;
                 InvalidEnrollmentMessage.Message = this.GetRecoveryStatusMessage(RecoveryResult);
         }
         else
        {
             InitializeRecoveryAttempt();
        }
     }

}

//Give the person the option to have their one-time password sent to their personal email if the
//SendPasswordToPersonalEmail parameter is true and the person has a personal email address set on their person
ResetOptions.ShowPersonalEmail = !string.IsNullOrEmpty(IdentifyYourself.TargetPerson.PersonalEmail) && (this.SendPasswordToPersonalEmail);

//Give the person the option to have their one-time password sent to their primary email address 
//if the SendPasswordToEmail parameter is true and the person has a primary email address set on their person
ResetOptions.ShowPrimaryEmail = !string.IsNullOrEmpty(IdentifyYourself.TargetPerson.Email) && (this.SendPasswordToEmail);

//Give the person the option to have their one-time password sent via a phone call if the SendPasswordToTwilioVoiceCall is set to true
//and the person has a mobile phone number set on their person and the organization has a Twilio account registered in EmpowerID  
ResetOptions.ShowVoiceCall = !string.IsNullOrEmpty(IdentifyYourself.TargetPerson.MobilePhone) && (this.OAuthConsumerID != null) && (this.SendPasswordToTwilioVoiceCall);

//Give the person the option to have their one-time password sent via a text message if the SendPasswordToTwilioSMS is set to true
//and the person has a mobile phone number set on their person and the organization has a Twilio account registered in EmpowerID  
ResetOptions.ShowSMSToMobile = !string.IsNullOrEmpty(IdentifyYourself.TargetPerson.MobilePhone) && (this.OAuthConsumerID != null) && (this.SendPasswordToTwilioSMS);

if(IdentifyYourself.TargetPerson.Email != null)
{
    ResetOptions.EmailFriendlyName = IdentifyYourself.TargetPerson.Email.Substring(0, Math.Min(4, IdentifyYourself.TargetPerson.Email.Length)) + "***********";
}
if(IdentifyYourself.TargetPerson.PersonalEmail != null)
{
    ResetOptions.PersonalEmailFriendlyName = IdentifyYourself.TargetPerson.PersonalEmail.Substring(0, Math.Min(4, IdentifyYourself.TargetPerson.PersonalEmail.Length))+ "***********";
}
string s = IdentifyYourself.TargetPerson.MobilePhone;

if(s != null)
{
     int ii = 4;
     string ss = "*";
       if (s.IndexOf("@") > 0)
            ii = s.IndexOf("@") - 1;

        for (int i = 0; i < s.Length - ii; i++)
        {
            ss = ss + "*";
        }

        s = ss + s.Substring(s.Length - ii);
            ResetOptions.MobilePhoneFriendlyName = s;
}

ValidateTOTP.SendPersonOneTimePassword_SendPasswordToEmail = ResetOptions.PrimaryEmail;
ValidateTOTP.SendPersonOneTimePassword_SendPasswordToPersonalEmail = ResetOptions.PersonalEmail;
ValidateTOTP.SendPersonOneTimePassword_SendPasswordTwilioSMS = ResetOptions.SMSToMobile;
ValidateTOTP.SendPersonOneTimePassword_SendPasswordTwilioVoiceCall = ResetOptions.VoiceCall;

UnlockOnly = !ResetOptions.UnlockAndReset;

//Set the one-time password using the CryptoHelper class, passing in the property values set on the
//ValidateTOTP activity
OneTimePassword =  CryptoHelper.GetStrongPassword(OneTimePasswordLength,NumberOfSpecialCharactersInOneTimePassword,
                        NumberOfDigitsInOneTimePassword,
                        NumberOfUpperCaseLettersInOneTimePassword,
                        NumberOfLowerCaseLettersInOneTimePassword);

//Set the one-time password on the person, passing in the password and the validation time
 TargetPerson.SetOneTimePassword(OneTimePassword,OneTimePasswordValidityDurationInMinites);

 //If no template is specified use the default
 if (string.IsNullOrEmpty(TwilioOTPVoiceMessageTemplateName))
    TwilioOTPVoiceMessageTemplateName = "TwilioOTPVoiceMessage";

//Instantiate a new instance of EmailMessage for the Twilio template
 C.EMailMessage voiceMessageTemplate =  C.EMailMessage.GetByName(TwilioOTPVoiceMessageTemplateName);

//Loop through the characters in OneTimePassword, adding each to the voiceOTP
 string voiceOTP =  "";
 foreach(char c in OneTimePassword)
     voiceOTP += c + " ";

//Send voice message with OneTimePassword to person using Twilio
 SendUsingTwilio.VoiceMessage = "Please enter this security code when prompted: " + voiceOTP;
 if (voiceMessageTemplate != null)
     SendUsingTwilio.VoiceMessage =  voiceMessageTemplate.EMailBody.Replace("{PassCode}",voiceOTP);

//Set the SMS subject and body
 if (string.IsNullOrEmpty(SMSMessage))
     SendUsingTwilio.SMSMessage = "Please enter this security code when prompted: " + OneTimePassword;
 else
     SendUsingTwilio.SMSMessage = SMSMessage.ToEmpowerIDLocalizedString().Replace("{PassCode}",OneTimePassword);

//Set the email subject and body
 if (string.IsNullOrEmpty(EmailSubject))
     EmailSubject = "Your one-time login security code";

  if (string.IsNullOrEmpty(EmailBody))
     EmailBody = "Please enter this security code when prompted: " + OneTimePassword;

//Set SMS body and subject on the SendSMS activity within ruleDecisionActivity1
SendSMS.Body = EmailBody.TrimEnd();
SendSMS.Subject = EmailSubject;

//Set email body and subject on the SendEmail activity within ruleDecisionActivity1
SendEmail.Body = EmailBody.TrimEnd();
SendEmail.Subject = EmailSubject;

//Send email if the person has either a primary or personal email address and one or both of those related workflow parameters are true
SendEmail.ToEmail = "";
if (!string.IsNullOrEmpty(EmailAddress))
     SendEmail.ToEmail = EmailAddress;
else {
        if (!string.IsNullOrEmpty(TargetPerson.Email) && SendPasswordToEmail)
            SendEmail.ToEmail +=  TargetPerson.Email + ";";
        if (!string.IsNullOrEmpty(TargetPerson.PersonalEmail) && SendPasswordToPersonalEmail)
            SendEmail.ToEmail +=  TargetPerson.PersonalEmail;
        SendEmail.ToEmail = SendEmail.ToEmail.TrimEnd(';');
}

System.Text.RegularExpressions.Regex _digitRegex = new System.Text.RegularExpressions.Regex(@"\d+", System.Text.RegularExpressions.RegexOptions.Compiled);
System.Text.RegularExpressions.MatchCollection matches = _digitRegex.Matches(TargetPerson.MobilePhone.ToSafeString());

StringBuilder digitBuilder = new StringBuilder();

    foreach (System.Text.RegularExpressions.Match match in matches)
    {
        digitBuilder.Append(match.Value);
    }

     SendUsingTwilio.PhoneNumber = digitBuilder.ToString();

//Send SMS if person has a mobile phone provider and mobile phone registered in EmpowerID and the related workflow parameter is true
if (TargetPerson.MobilePhoneProviderID != null && !string.IsNullOrEmpty(TargetPerson.MobilePhone))
{
    SendSMS.ToEmail = digitBuilder + TargetPerson.MobilePhoneProviderIDSource.SMSGatewaySuffix;
}