Handledning: Lägg till lösenordsåterställning med självbetjäning

Gäller för: Externa klienter (läs mer)

Den här självstudien visar hur du gör det möjligt för användare att ändra eller återställa sitt lösenord, utan administratörs- eller supportavdelningsengagemang.

I den här handledningen kommer du att:

Förutsättningar

• Slutför stegen i Logga in användare i ett exempel på ett inbyggt Android-mobilprogram. Den här artikeln visar hur du kör ett Android-exempel som du konfigurerar med hjälp av klientinställningarna.
• Aktivera lösenordsåterställning med självbetjäning. I den här artikeln kan du aktivera autentiseringsmetoden för engångslösenord för e-post för alla användare i din klientorganisation, vilket är ett krav för SSPR.
• Självstudie: Förbered din Android-app för intern autentisering.

Lägga till lösenordsåterställningsflöde för självbetjäning

Om du vill lägga till SSPR-flöde i ditt Android-program behöver du ett användargränssnitt för lösenordsåterställning:

• Ett indatatextfält för att samla in användarens e-postadress (användarnamn).
• Ett indatatextfält för att samla in engångslösenord.
• Ett indatatextfält för att samla in nytt lösenord.

När användarna glömmer sina lösenord behöver de ett formulär för att ange sina användarnamn (e-postadresser) för att starta flödet för lösenordsåterställning. Användaren väljer knappen eller länken Glöm lösenord.

Starta flödet för lösenordsåterställning

Om du vill hantera begäran när användaren väljer knappen eller länken Glöm lösenord använder du Android SDK:s resetPassword(parameters)-metod enligt följande kodfragment:

 private fun forgetPassword() { 
     CoroutineScope(Dispatchers.Main).launch { 
         val parameter = NativeAuthResetPasswordParameters(username = email)
         val actionResult = authClient.resetPassword(parameter)

         when (resetPasswordResult) { 
             is ResetPasswordStartResult.CodeRequired -> { 
                 // The implementation of submitCode() please see below. 
                 submitCode(resetPasswordResult.nextState) 
             } 
             is ResetPasswordError -> {
                 // Handle errors
                 handleResetPasswordError(resetPasswordResult)
             }
         }
     } 
 } 

• resetPassword(parameters)-metoden initierar flödet för lösenordsåterställning och ett engångslösenord för e-post skickas till användarens e-postadress för verifiering.

• Returresultatet för resetPassword(parameters) är antingen ResetPasswordStartResult.CodeRequired eller ResetPasswordError.

• Om resetPasswordResult is ResetPasswordStartResult.CodeRequiredmåste appen samla in engångslösenordet för e-post från användaren och skicka det enligt Skicka e-post engångslösenord.

• Om resetPasswordResult is ResetPasswordErrortillhandahåller Android SDK verktygsmetoder så att du kan analysera de specifika felen ytterligare: – isUserNotFound() - isBrowserRequired()

• Dessa fel indikerar att den tidigare åtgärden misslyckades, så en referens till ett nytt tillstånd är inte tillgänglig. Hantera dessa fel så som visas i avsnitt Hantera fel.

Skicka e-post engångslösenord

Appen samlar in engångskod för e-post från användaren. Om du vill skicka e-postlösenordet en gång använder du följande kodfragment:

private suspend fun submitCode(currentState: ResetPasswordCodeRequiredState) { 
    val code = binding.codeText.text.toString() 
    val submitCodeResult = currentState.submitCode(code) 

    when (submitCodeResult) { 
        is ResetPasswordSubmitCodeResult.PasswordRequired -> { 
            // Handle success
            resetPassword(submitCodeResult.nextState) 
        } 
         is SubmitCodeError -> {
             // Handle errors
             handleSubmitCodeError(actionResult)
         }
    } 
} 

• Returresultatet för åtgärden submitCode() är antingen ResetPasswordSubmitCodeResult.PasswordRequired eller SubmitCodeError.

• Om submitCodeResult is ResetPasswordSubmitCodeResult.PasswordRequired måste appen samla in ett nytt lösenord från användaren och skicka det enligt Skicka ett nytt lösenord.

• Om användaren inte får engångslösenordet via e-post kan appen skicka det via e-post igen. Använd följande kodfragment för att skicka ett nytt engångslösenord för e-post:

  private fun resendCode() { 
       clearCode() 
  
       val currentState = ResetPasswordCodeRequiredState 
  
       CoroutineScope(Dispatchers.Main).launch { 
           val resendCodeResult = currentState.resendCode() 
  
           when (resendCodeResult) { 
               is ResetPasswordResendCodeResult.Success -> { 
                   // Handle code resent success
               } 
               is ResendCodeError -> {
                    // Handle ResendCodeError errors
                }
           } 
       } 
  } 
  

  • Returresultatet för åtgärden resendCode() är antingen ResetPasswordResendCodeResult.Success eller ResendCodeError.

  • ResendCodeError är ett oväntat fel för SDK. Det här felet anger att den föregående åtgärden misslyckades, så en referens till ett nytt tillstånd är inte tillgänglig.

• Om submitCodeResult is SubmitCodeErrortillhandahåller Android SDK verktygsmetoder så att du kan analysera de specifika felen ytterligare:

  • isInvalidCode()
  • isBrowserRequired()

  Dessa fel indikerar att den tidigare åtgärden misslyckades, så en referens till ett nytt tillstånd är inte tillgänglig. Hantera dessa fel så som visas i avsnitt Hantera fel.

Skicka ett nytt lösenord

När du har verifierat användarens e-post måste du samla in ett nytt lösenord från användaren och skicka det. Lösenordet som appen samlar in från användaren måste uppfylla Microsoft Entras lösenordsprinciper. Använd följande kodfragment:

private suspend fun resetPassword(currentState: ResetPasswordPasswordRequiredState) { 
    val password = binding.passwordText.text.toString() 

    val submitPasswordResult = currentState.submitPassword(password) 

    when (submitPasswordResult) { 
        is ResetPasswordResult.Complete -> { 
            // Handle reset password complete. 
        } 
        is ResetPasswordSubmitPasswordError -> {
            // Handle errors
            handleSubmitPasswordError(actionResult)
        }
    } 
} 

• Returresultatet för åtgärden submitPassword() är antingen ResetPasswordResult.Complete eller ResetPasswordSubmitPasswordError.

• ResetPasswordResult.Complete anger ett lyckat flöde för lösenordsåterställning.

• Om submitPasswordResult is ResetPasswordSubmitPasswordErrortillhandahåller SDK verktygsmetoder för att ytterligare analysera den specifika typ av fel som returneras: – isInvalidPassword() - isPasswordResetFailed()

  Dessa fel indikerar att den tidigare åtgärden misslyckades, så en referens till ett nytt tillstånd är inte tillgänglig. Hantera dessa fel så som visas i avsnitt Hantera fel.

Automatisk inloggning efter lösenordsåterställning

Efter ett lyckat flöde för lösenordsåterställning kan du automatiskt logga in dina användare utan att initiera ett nytt inloggningsflöde.

ResetPasswordResult.Complete returnerar SignInContinuationState objekt. SignInContinuationState ger åtkomst till signIn(parameters)-metoden.

Om du vill logga in användare automatiskt efter en lösenordsåterställning använder du följande kodfragment:

 private suspend fun resetPassword(currentState: ResetPasswordPasswordRequiredState) { 
     val submitPasswordResult = currentState.submitPassword(password) 
 
     when (submitPasswordResult) { 
         is ResetPasswordResult.Complete -> { 
             signInAfterPasswordReset(nextState = actionResult.nextState)
         } 
     } 
 } 
 
 private suspend fun signInAfterPasswordReset(nextState: SignInContinuationState) {
     val signInContinuationState = nextState

     val parameters = NativeAuthSignInContinuationParameters()
     val signInActionResult = signInContinuationState.signIn(parameters)

     when (actionResult) {
         is SignInResult.Complete -> {
             fetchTokens(accountState = actionResult.resultValue)
         }
         else {
             // Handle unexpected error
         }
     }
  }
 
 private suspend fun fetchTokens(accountState: AccountState) {
     val getAccessTokenParameters = NativeAuthGetAccessTokenParameters()
     val accessTokenResult = accountState.getAccessToken(getAccessTokenParameters)

     if (accessTokenResult is GetAccessTokenResult.Complete) {
         val accessToken =  accessTokenResult.resultValue.accessToken
         val idToken = accountState.getIdToken()
     }
 }

Om du vill hämta ID-tokenanspråk efter inloggning, använd stegen i Läs ID-tokenanspråk.

Hantera fel vid lösenordsåterställning

Några förväntade fel kan inträffa. Användaren kan till exempel försöka återställa lösenordet med ett obefintligt e-postmeddelande eller ange ett lösenord som inte uppfyller lösenordskraven.

När fel inträffar ger du användarna en ledtråd till felen.

Dessa fel kan inträffa i början av flödet för lösenordsåterställning eller vid skicka e-post engångslösenord eller vid skicka lösenord.

Hantera fel vid start av lösenordsåterställning

Använd följande kodfragment för att hantera fel som orsakas av startlösenordsåterställning:

private fun handleResetPasswordError(error: ResetPasswordError) {
    when {
        error.isUserNotFound() -> {
            // Display error
        }
        else -> {
            // Unexpected error
        }
    }
}

Hantera fel vid inlämning av engångslösenord via e-post

Om du vill hantera fel som orsakas av att skicka e-postlösenord en gång använder du följande kodfragment:

private fun handleSubmitCodeError(error: SubmitCodeError) {
    when {
        error.isInvalidCode() -> {
            // Display error
        }
        else -> {
            // Unexpected error
        }
    }
}

Hantera fel vid lösenordsinlämning

Använd följande kodfragment för att hantera fel som orsakas av att skicka lösenord:

private fun handleSubmitPasswordError(error: ResetPasswordSubmitPasswordError) {
    when {
        error.isInvalidPassword() || error.isPasswordResetFailed()
        -> {
            // Display error
        }
        else -> {
            // Unexpected error
        }
    }
}

Nästa steg

Självstudie: Stöd för webbfallback i Android-app