[SIW-1455] Reissuing expired or expiring eID

locales/en/index.yml

@@ -3494,6 +3494,7 @@ features:
             valid: L'ultima verifica è del {{date}}.
             expiring: Verifica la tua identità entro il {{date}}.
             expired: È necessario un rapido passaggio di verifica per continuare a usare Documenti su IO.
+            action: Inizia
         MDL:
           expiring:
             title: "Patente su IO: documento in scadenza"
@@ -3549,6 +3550,13 @@ features:
         openPdf: Show document
         shareButton: Save or share
         fiscalCode: Your Fiscal Code
+      eid: 
+        verificationExpired:
+          title: Verifica la tua identità
+          contentStart: "È un passaggio di sicurezza necessario per continuare ad usare "
+          contentBold: Documenti su IO
+          contentEnd: "."
+          primaryAction: Inizia
       statusAttestationUnknown:
         title: Non siamo riusciti a caricare {{credentialName}}
         content: Chiudi e riapri l'app per riprovare.

locales/it/index.yml

@@ -3494,6 +3494,7 @@ features:
             valid: L'ultima verifica è del {{date}}.
             expiring: Verifica la tua identità entro il {{date}}.
             expired: È necessario un rapido passaggio di verifica per continuare a usare Documenti su IO.
+            action: Inizia
         MDL:
           expiring:
             title: "Patente su IO: documento in scadenza"
@@ -3549,6 +3550,13 @@ features:
         openPdf: "Mostra documento"
         shareButton: Salva o condividi
         fiscalCode: Il tuo Codice Fiscale
+      eid: 
+        verificationExpired:
+          title: Verifica la tua identità
+          contentStart: "È un passaggio di sicurezza necessario per continuare ad usare "
+          contentBold: Documenti su IO
+          contentEnd: "."
+          primaryAction: Inizia
       statusAttestationUnknown:
         title: Non siamo riusciti a caricare {{credentialName}}
         content: Chiudi e riapri l'app per riprovare.

ts/features/itwallet/common/components/ItwEidInfoBottomSheetContent.tsx

@@ -96,7 +96,7 @@ const ItwEidInfoBottomSheetContent = ({
             </React.Fragment>
           ))}
         </View>
-        <ItwEidLifecycleAlert />
+        <ItwEidLifecycleAlert navigation={navigation} />
         <IOMarkdown
           content={I18n.t(
             "features.itWallet.presentation.bottomSheets.eidInfo.contentBottom"

ts/features/itwallet/common/components/ItwEidLifecycleAlert.tsx

@@ -15,6 +15,8 @@ import {
   ItwJwtCredentialStatus,
   StoredCredential
 } from "../utils/itwTypesUtils";
+import { useIONavigation } from "../../../../navigation/params/AppParamsList";
+import { ITW_ROUTES } from "../../navigation/routes";
 
 const defaultLifecycleStatus: Array<ItwJwtCredentialStatus> = [
   "valid",
@@ -27,17 +29,28 @@ type Props = {
    * The eID statuses that will render the alert.
    */
   lifecycleStatus?: Array<ItwJwtCredentialStatus>;
+  navigation: ReturnType<typeof useIONavigation>;
 };
 
 /**
  * This component renders an alert that displays information on the eID status.
  */
 export const ItwEidLifecycleAlert = ({
-  lifecycleStatus = defaultLifecycleStatus
+  lifecycleStatus = defaultLifecycleStatus,
+  navigation
 }: Props) => {
   const eidOption = useIOSelector(itwCredentialsEidSelector);
   const maybeEidStatus = useIOSelector(itwCredentialsEidStatusSelector);
 
+  const startEidReissuing = () => {
+    navigation.navigate(ITW_ROUTES.MAIN, {
+      screen: ITW_ROUTES.IDENTIFICATION.MODE_SELECTION,
+      params: {
+        eidReissuing: true
+      }
+    });
+  };
+
   const Content = ({
     eid,
     eidStatus
@@ -73,14 +86,22 @@ export const ItwEidLifecycleAlert = ({
           {
             date: format(eid.jwt.expiration, "DD-MM-YYYY")
           }
-        )
+        ),
+        action: I18n.t(
+          "features.itWallet.presentation.bottomSheets.eidInfo.alert.action"
+        ),
+        onPress: startEidReissuing
       },
       jwtExpired: {
         testID: "itwEidLifecycleAlertTestID_jwtExpired",
         variant: "error",
         content: I18n.t(
           "features.itWallet.presentation.bottomSheets.eidInfo.alert.expired"
-        )
+        ),
+        action: I18n.t(
+          "features.itWallet.presentation.bottomSheets.eidInfo.alert.action"
+        ),
+        onPress: startEidReissuing
       }
     };
 

ts/features/itwallet/identification/screens/ItwIdentificationModeSelectionScreen.tsx

@@ -16,9 +16,20 @@ import {
 } from "../../analytics";
 import { IOScrollViewWithLargeHeader } from "../../../../components/ui/IOScrollViewWithLargeHeader";
 import { isCIEAuthenticationSupportedSelector } from "../../machine/eid/selectors";
+import { IOStackNavigationRouteProps } from "../../../../navigation/params/AppParamsList";
+import { ItwParamsList } from "../../navigation/ItwParamsList";
 import { itwDisabledIdentificationMethodsSelector } from "../../common/store/selectors/remoteConfig";
 
-export const ItwIdentificationModeSelectionScreen = () => {
+export type ItwIdentificationModeSelectionScreenNavigationParams = {
+  eidReissuing?: boolean;
+};
+
+type ScreenProps = IOStackNavigationRouteProps<
+  ItwParamsList,
+  "ITW_IDENTIFICATION_MODE_SELECTION"
+>;
+
+export const ItwIdentificationModeSelectionScreen = (params: ScreenProps) => {
   const machineRef = ItwEidIssuanceMachineContext.useActorRef();
   const isCieAuthenticationSupported = ItwEidIssuanceMachineContext.useSelector(
     isCIEAuthenticationSupportedSelector
@@ -45,6 +56,16 @@ export const ItwIdentificationModeSelectionScreen = () => {
     [isCieAuthenticationSupported]
   );
 
+  const { eidReissuing } = params.route.params;
+
+  useFocusEffect(
+    useCallback(() => {
+      if (eidReissuing) {
+        machineRef.send({ type: "start-reissuing" });
+      }
+    }, [eidReissuing, machineRef])
+  );
+
   useFocusEffect(trackItWalletIDMethod);
 
   const handleSpidPress = useCallback(() => {

ts/features/itwallet/identification/screens/__tests__/ItwIdentificationModeSelectionScreen.test.tsx

@@ -15,6 +15,8 @@ import { ItwEidIssuanceMachineContext } from "../../../machine/provider";
 import { itwEidIssuanceMachine } from "../../../machine/eid/machine";
 import { ItwLifecycleState } from "../../../lifecycle/store/reducers";
 import { ToolEnum } from "../../../../../../definitions/content/AssistanceToolConfig";
+import { IOStackNavigationProp } from "../../../../../navigation/params/AppParamsList";
+import { ItwParamsList } from "../../../navigation/ItwParamsList";
 
 jest.mock("../../../../../config", () => ({
   itwEnabled: true
@@ -128,10 +130,29 @@ describe("ItwIdentificationModeSelectionScreen", () => {
       }
     });
 
+    const mockNavigation = new Proxy(
+      {},
+      {
+        get: _ => jest.fn()
+      }
+    ) as unknown as IOStackNavigationProp<
+      ItwParamsList,
+      "ITW_IDENTIFICATION_MODE_SELECTION"
+    >;
+
+    const route = {
+      key: "ITW_IDENTIFICATION_MODE_SELECTION",
+      name: ITW_ROUTES.IDENTIFICATION.MODE_SELECTION,
+      params: {}
+    };
+
     return renderScreenWithNavigationStoreContext<GlobalState>(
       () => (
         <ItwEidIssuanceMachineContext.Provider logic={logic}>
-          <ItwIdentificationModeSelectionScreen />
+          <ItwIdentificationModeSelectionScreen
+            navigation={mockNavigation}
+            route={route}
+          />
         </ItwEidIssuanceMachineContext.Provider>
       ),
       ITW_ROUTES.IDENTIFICATION.MODE_SELECTION,

ts/features/itwallet/machine/eid/__tests__/machine.test.ts

@@ -94,7 +94,10 @@ describe("itwEidIssuanceMachine", () => {
       resetWalletInstance,
       trackWalletInstanceCreation,
       trackWalletInstanceRevocation,
-      onInit: assign(onInit)
+      onInit: assign(onInit),
+      setIsReissuing: assign({
+        isReissuing: true
+      })
     },
     actors: {
       createWalletInstance: fromPromise<string>(createWalletInstance),
@@ -985,6 +988,185 @@ describe("itwEidIssuanceMachine", () => {
     expect(actor.getSnapshot().value).toStrictEqual("Idle");
   });
 
+  it("Should obtain an eID (SPID), reissuing mode", async () => {
+    // The wallet instance and attestation already exist
+    const initialContext = {
+      ...InitialContext,
+      integrityKeyTag: T_INTEGRITY_KEY,
+      walletInstanceAttestation: T_WIA
+    };
+
+    const actor = createActor(mockedMachine);
+    actor.start();
+
+    // eslint-disable-next-line functional/immutable-data
+    actor.getSnapshot().context = initialContext;
+
+    hasValidWalletInstanceAttestation.mockImplementation(() => true);
+
+    await waitFor(() => expect(onInit).toHaveBeenCalledTimes(1));
+
+    expect(actor.getSnapshot().value).toStrictEqual("Idle");
+    expect(actor.getSnapshot().tags).toStrictEqual(new Set());
+
+    actor.send({ type: "start-reissuing" });
+
+    expect(actor.getSnapshot().value).toStrictEqual({
+      UserIdentification: "ModeSelection"
+    });
+
+    expect(actor.getSnapshot().context).toStrictEqual<Context>({
+      ...initialContext,
+      isReissuing: true
+    });
+
+    /**
+     * Choose SPID as identification mode
+     */
+
+    actor.send({ type: "select-identification-mode", mode: "spid" });
+
+    expect(actor.getSnapshot().value).toStrictEqual({
+      UserIdentification: {
+        Spid: "IdpSelection"
+      }
+    });
+    expect(actor.getSnapshot().tags).toStrictEqual(new Set());
+    expect(navigateToIdpSelectionScreen).toHaveBeenCalledTimes(1);
+
+    /**
+     * Choose first IDP in list for SPID identification
+     */
+
+    startAuthFlow.mockImplementation(() => Promise.resolve({}));
+
+    requestEid.mockImplementation(() =>
+      Promise.resolve(ItwStoredCredentialsMocks.eid)
+    );
+
+    issuedEidMatchesAuthenticatedUser.mockImplementation(() => true);
+
+    actor.send({ type: "select-spid-idp", idp: idps[0] });
+
+    expect(actor.getSnapshot().value).toStrictEqual({
+      UserIdentification: {
+        Spid: "StartingSpidAuthFlow"
+      }
+    });
+
+    expect(actor.getSnapshot().context).toStrictEqual<Context>({
+      ...initialContext,
+      integrityKeyTag: T_INTEGRITY_KEY,
+      walletInstanceAttestation: T_WIA,
+      isReissuing: true,
+      identification: {
+        mode: "spid",
+        idpId: idps[0].id
+      }
+    });
+
+    expect(actor.getSnapshot().tags).toStrictEqual(new Set([ItwTags.Loading]));
+
+    await waitFor(() => expect(startAuthFlow).toHaveBeenCalledTimes(1));
+
+    expect(actor.getSnapshot().value).toStrictEqual({
+      UserIdentification: {
+        Spid: "CompletingSpidAuthFlow"
+      }
+    });
+
+    actor.send({
+      type: "user-identification-completed",
+      authRedirectUrl: "http://test.it"
+    });
+
+    expect(actor.getSnapshot().value).toStrictEqual({
+      Issuance: "RequestingEid"
+    });
+
+    expect(actor.getSnapshot().tags).toStrictEqual(new Set([ItwTags.Loading]));
+    expect(actor.getSnapshot().context).toMatchObject({
+      authenticationContext: {
+        callbackUrl: "http://test.it"
+      }
+    });
+    expect(navigateToEidPreviewScreen).toHaveBeenCalledTimes(1);
+
+    // EID obtained
+
+    // eslint-disable-next-line sonarjs/no-identical-functions
+    await waitFor(() =>
+      expect(actor.getSnapshot().value).toStrictEqual({
+        Issuance: "DisplayingPreview"
+      })
+    );
+
+    actor.send({ type: "add-to-wallet" });
+
+    expect(storeEidCredential).toHaveBeenCalledTimes(1);
+    expect(setWalletInstanceToValid).toHaveBeenCalledTimes(1);
+    expect(navigateToWallet).toHaveBeenCalledTimes(1);
+
+    expect(actor.getSnapshot().context).toStrictEqual<Context>({
+      ...initialContext,
+      integrityKeyTag: T_INTEGRITY_KEY,
+      walletInstanceAttestation: T_WIA,
+      isReissuing: true,
+      identification: {
+        mode: "spid",
+        idpId: idps[0].id
+      },
+      authenticationContext: expect.objectContaining({
+        callbackUrl: "http://test.it"
+      }),
+      eid: ItwStoredCredentialsMocks.eid
+    });
+  });
+
+  it("Should go back to Idle state if isReissuing is true", async () => {
+    const initialSnapshot: MachineSnapshot = createActor(
+      itwEidIssuanceMachine
+    ).getSnapshot();
+
+    const snapshot: MachineSnapshot = _.merge(undefined, initialSnapshot, {
+      value: { UserIdentification: "ModeSelection" },
+      context: {
+        isReissuing: true
+      }
+    } as MachineSnapshot);
+
+    const actor = createActor(mockedMachine, {
+      snapshot
+    });
+    actor.start();
+
+    actor.send({ type: "back" });
+
+    expect(actor.getSnapshot().value).toStrictEqual("Idle");
+  });
+
+  it("Should go back to IpzsPrivacyAcceptance state if isReissuing is false", async () => {
+    const initialSnapshot: MachineSnapshot = createActor(
+      itwEidIssuanceMachine
+    ).getSnapshot();
+
+    const snapshot: MachineSnapshot = _.merge(undefined, initialSnapshot, {
+      value: { UserIdentification: "ModeSelection" },
+      context: {
+        isReissuing: false
+      }
+    } as MachineSnapshot);
+
+    const actor = createActor(mockedMachine, {
+      snapshot
+    });
+    actor.start();
+
+    actor.send({ type: "back" });
+
+    expect(actor.getSnapshot().value).toStrictEqual("IpzsPrivacyAcceptance");
+  });
+
   it("should cleanup integrity key tag and fail when obtaining Wallet Instance Attestation fails", async () => {
     const actor = createActor(mockedMachine);
     actor.start();