@pi-spi/app 0.0.0-stage → 1.2.0

package/src/core/routes.tsx

@@ -0,0 +1,377 @@
+import { useState } from 'react';
+import { AliasPage } from '../modules/alias/presentation/pages/alias_page';
+import { AliasPageClaim } from '../modules/alias/presentation/pages/alias_page_claim';
+import { CategorieAddPage, CategorieEditPage } from '../modules/categorie/presentation/pages/categorie_form_pages';
+import { CategorieSelectPage } from '../modules/categorie/presentation/pages/categorie_select_page';
+import {
+  ContactCreatePage,
+  type ContactCreatePageParams,
+} from '../modules/contacts/presentation/pages/create/contact_create_page';
+import type { Transaction } from '../modules/transactions/domain/models/transaction';
+import { TransactionFormPage } from '../modules/transactions/presentation/pages/transaction_form/transaction_form_page';
+import { TransactionFormPageSchedule } from '../modules/transactions/presentation/pages/transaction_form/transaction_form_page_schedule';
+import { TransactionVerificationPage } from '../modules/transactions/presentation/pages/transaction_form/transaction_form_page_verification';
+import { TransactionSendPage } from '../modules/transactions/presentation/pages/transaction_send/transaction_send_page';
+import type { NotificationType } from '../modules/notification/domain/models/notification_type';
+import { Subscription } from '../modules/subscription/domain/models/subscription';
+import { SubscriptionCreatePage } from '../modules/subscription/presentation/pages/subscription_create/subscription_create_page';
+import { SubscriptionDetailsPage } from '../modules/subscription/presentation/pages/subscription_details/subscription_details_page';
+import type { NotificationBloc } from '../modules/notification/presentation/bloc/notification_bloc';
+import { NotificationPage } from '../modules/notification/presentation/pages/notification_page';
+import { TransactionRtpPage } from '../modules/transactions/presentation/pages/transaction_rtp/transaction_rtp_page';
+import { TransactionCancelPage } from '../modules/transactions/presentation/pages/transaction_cancel/transaction_cancel_page';
+import { TransactionSearchBloc } from '../modules/transactions/presentation/bloc/transaction_search/transaction_search_bloc';
+import { TransactionSearchPage } from '../modules/transactions/presentation/pages/transaction_search/transaction_search_page';
+import { TransactionSearchPageFilters } from '../modules/transactions/presentation/pages/transaction_search/transaction_search_page_filters';
+import type { ContactPI } from '../modules/contacts/domain/contact_pi';
+import { ContactSelectPage } from '../modules/contacts/presentation/pages/contact_select_page';
+import { TransactionSplitPageRepartition } from '../modules/transactions/presentation/pages/transaction_split/transaction_split_page_repartition';
+import { TransactionSplitPageTx } from '../modules/transactions/presentation/pages/transaction_split/transaction_split_page_tx';
+import { TransactionDetailsPage } from '../modules/transactions/presentation/pages/transaction_details/transaction_details_page';
+import { ProfilePage } from '../modules/profile/presentation/pages/profile_page';
+import { ProfilePageContacts } from '../modules/profile/presentation/pages/profile_page_contacts';
+import { ProfileComptePage } from '../modules/profile/presentation/pages/compte/profile_compte_page';
+import { ProfileParametrePage } from '../modules/profile/presentation/pages/parametre/profile_parametre_page';
+import { ProfileParametrePageNotifications } from '../modules/profile/presentation/pages/parametre/profile_parametre_page_notifications';
+import { ProfileParametrePageNotificationsSon } from '../modules/profile/presentation/pages/parametre/profile_parametre_page_notifications_son';
+import { ProfileParametrePageTheme } from '../modules/profile/presentation/pages/parametre/profile_parametre_page_theme';
+import { ProfileWebPage } from '../modules/profile/presentation/pages/web/profile_web_page';
+import { AppEnv } from './env';
+import { QrcodeData } from '../modules/qrcode/domain/models/qrcode_data';
+import { QrCodeAliasPage } from '../modules/qrcode/presentation/pages/qrcode_alias_page';
+import { QrcodeScanPage } from '../modules/qrcode/presentation/pages/qrcode_scan_page';
+import { TransactionCanal } from '../modules/transactions/domain/models/transaction_canal';
+import { TransactionSendCommand } from '../modules/transactions/domain/models/transaction_send/transaction_send_command';
+import { TransactionSendCommandAlias } from '../modules/transactions/domain/models/transaction_send/transaction_send_command_alias';
+import { TransactionSendCommandAmount } from '../modules/transactions/domain/models/transaction_send/transaction_send_command_amount';
+import { TransactionSendMethod } from '../modules/transactions/domain/models/transaction_send/transaction_send_method';
+import { TransactionFormPageQrcode } from '../modules/transactions/presentation/pages/transaction_form/transaction_form_page_qrcode';
+import { AliasExistState } from '../modules/alias/presentation/bloc/alias_state';
+import { HomePage } from '../modules/home/presentation/pages/home_page';
+import { SelectAccountPage } from '../modules/home/presentation/pages/select_account_page';
+import { IntroductionPage } from '../modules/introduction/presentation/pages/introduction';
+import { PermissionsPage } from '../modules/permission/presentation/pages/permissions_page';
+import { AliasBloc } from '../modules/alias/presentation/bloc/alias_bloc';
+import { BlocProvider, useBloc } from './bloc_react';
+import { CompteAliasStatus } from './compte_alias_status';
+import { Di } from './di';
+import { Logger } from './logger';
+import { AppRouter, type RouteDef } from './router';
+
+const logger = new Logger();
+
+/**
+ * Routes déclarées par les modules déjà portés depuis le SDK Flutter
+ * (équivalent de la liste `routes:` du `GoRouter` dans router.dart). Toute
+ * route encore absente de cette liste affiche `NotFoundPage` (« A venir »),
+ * comme l'`errorPageBuilder` de GoRouter.
+ */
+export function appRoutes(): RouteDef[] {
+  return [
+    // Première utilisation
+    ...introductionRoute(),
+    ...permissionsRoute(),
+    ...selectAccountRoute(),
+    // Alias
+    ...aliasRoutes(),
+    // Page d'accueil
+    ...homeRoute(),
+    // Abonnements (l'onglet de l'accueil ; les autres routes avec leur module)
+    ...subscriptionListRoute(),
+    // Catégories
+    ...categorieRoutes(),
+    // Contacts
+    ...contactRoutes(),
+    // Transactions
+    ...transactionRoutes(),
+    // Profil et paramètres
+    ...profilRoutes(),
+    // QR code
+    ...qrcodeRoutes(),
+    // Notifications
+    ...notificationsRoute(),
+  ];
+}
+
+/** NOTIFICATIONS (bloc fourni par la cloche de l'accueil) */
+function notificationsRoute(): RouteDef[] {
+  return [
+    {
+      path: AppRouter.notifications,
+      kind: 'dialog',
+      builder: (state) => (
+        <BlocProvider blocs={[state.extra as NotificationBloc]}>
+          <NotificationPage />
+        </BlocProvider>
+      ),
+    },
+  ];
+}
+
+/** INTRODUCTION (première utilisation) */
+function introductionRoute(): RouteDef[] {
+  return [{ path: AppRouter.introduction, kind: 'page', builder: () => <IntroductionPage /> }];
+}
+
+/** PERMISSION CONTACTS (première utilisation, après l'introduction) */
+function permissionsRoute(): RouteDef[] {
+  return [{ path: AppRouter.permissions, kind: 'page', builder: () => <PermissionsPage /> }];
+}
+
+/** ALIAS */
+function aliasRoutes(): RouteDef[] {
+  return [
+    { path: AppRouter.alias, kind: 'page', builder: () => <AliasPage /> },
+    {
+      path: AppRouter.aliasClaimDetails,
+      kind: 'dialog',
+      builder: (state) => <AliasPageClaim id={state.pathParameters.id} />,
+    },
+  ];
+}
+
+/** SÉLECTION DE COMPTE (client à plusieurs comptes, à chaque ouverture) */
+function selectAccountRoute(): RouteDef[] {
+  return [{ path: AppRouter.selectAccount, kind: 'page', builder: () => <SelectAccountPage /> }];
+}
+
+/** HOME */
+function homeRoute(): RouteDef[] {
+  return [
+    {
+      path: AppRouter.home,
+      kind: 'page',
+      builder: (state) => <HomePage selectedTab={typeof state.extra === 'number' ? state.extra : undefined} />,
+      redirect: async (_state, context) => {
+        // Vérifie systématiquement, à chaque redirection vers l'accueil,
+        // que le compte actif a bien un alias — jamais de raccourci sur un
+        // état en cache : l'accueil ne doit jamais s'afficher sans que ce
+        // soit vérifié.
+        logger.i('[home redirect] start');
+        const aliasBloc = context.read(AliasBloc);
+        const compte = Di.activeCompte;
+        const aliasState = await aliasBloc.fetchFor(compte);
+        const status = CompteAliasStatus.fromState(aliasState);
+        // Source de vérité de l'état de l'alias du compte actif à l'arrivée sur l'accueil.
+        Di.activeCompteAlias.value = status;
+        logger.i(`[home redirect] ${compte} -> ${aliasState.constructor.name}`);
+
+        switch (status) {
+          case CompteAliasStatus.exists:
+            return null;
+          case CompteAliasStatus.error:
+            // Impossible de vérifier (réseau, serveur) : on reste sur
+            // l'accueil, qui grise les actions et propose de réessayer.
+            return null;
+          default:
+            // Le client vient de refuser explicitement de créer un alias
+            // pour ce compte (retour depuis AliasPage) : on le laisse
+            // atterrir sur l'accueil une seule fois.
+            if (Di.skipHomeAliasCheckForCompte === compte) {
+              Di.skipHomeAliasCheckForCompte = null;
+              return null;
+            }
+            return AppRouter.alias;
+        }
+      },
+    },
+  ];
+}
+
+/** ABONNEMENTS : la liste est l'onglet 1 de l'accueil */
+function subscriptionListRoute(): RouteDef[] {
+  return [
+    // Programmer un paiement unique
+    { path: AppRouter.subscriptionSchedule, kind: 'dialog', builder: () => <TransactionSendPage action="send_schedule" /> },
+    // Souscrire à un abonnement
+    { path: AppRouter.subscriptionSubscribe, kind: 'page', builder: () => <SubscriptionCreatePage /> },
+    // Liste
+    { path: AppRouter.subscriptionList, kind: 'page', builder: () => <HomePage selectedTab={1} /> },
+    // Détail
+    {
+      path: AppRouter.subscriptionDetails,
+      kind: 'dialog',
+      builder: (state) => {
+        const params = state.extra as { tx: Transaction; route?: string | null };
+        return <SubscriptionDetailsPage subscription={Subscription.fromTransaction(params.tx)} detailsBackRoute={params.route} />;
+      },
+    },
+  ];
+}
+
+/** CATÉGORIES */
+function categorieRoutes(): RouteDef[] {
+  return [
+    { path: AppRouter.categoriesSelect, kind: 'dialog', builder: () => <CategorieSelectPage /> },
+    { path: AppRouter.categoriesAdd, kind: 'dialog', builder: () => <CategorieAddPage /> },
+    { path: AppRouter.categoriesEdit, kind: 'dialog', builder: () => <CategorieEditPage /> },
+  ];
+}
+
+/** CONTACTS (la sélection multiple est ouverte par le partage de dépense) */
+function contactRoutes(): RouteDef[] {
+  return [
+    {
+      path: AppRouter.contactCreate,
+      kind: 'page',
+      builder: (state) => {
+        const params = (state.extra ?? {}) as ContactCreatePageParams;
+        return (
+          <ContactCreatePage
+            contact={params.contact}
+            contactAlias={params.contactAlias}
+            mbnoForbidden={params.mbnoForbidden}
+          />
+        );
+      },
+    },
+  ];
+}
+
+/** TRANSACTIONS (ajoutées au fil du portage du module) */
+function transactionRoutes(): RouteDef[] {
+  return [
+    // Envoyer / demander de l'argent
+    { path: AppRouter.transactionSend, kind: 'dialog', builder: () => <TransactionSendPage action="send_now" /> },
+    { path: AppRouter.transactionReceive, kind: 'dialog', builder: () => <TransactionSendPage action="receive_now" /> },
+    // Détail d'une demande de paiement
+    {
+      path: AppRouter.transactionReceiveDetails,
+      kind: 'dialog',
+      builder: (state) => {
+        const params = (state.extra ?? {}) as {
+          type?: NotificationType | null;
+          clientAlias?: string | null;
+          clientCategorie?: string | null;
+        };
+        return (
+          <TransactionRtpPage
+            id={state.pathParameters.id}
+            type={params.type}
+            clientAlias={params.clientAlias}
+            clientCategorie={params.clientCategorie}
+          />
+        );
+      },
+    },
+    // Demande d'annulation reçue
+    { path: AppRouter.transactionCancel, kind: 'dialog', builder: (state) => <TransactionCancelPage id={state.pathParameters.id} /> },
+    // Recherche et filtres
+    { path: AppRouter.transactionSearch, kind: 'page', builder: () => <TransactionSearchPage /> },
+    {
+      path: AppRouter.transactionSearchFilters,
+      kind: 'dialog',
+      builder: (state) => (
+        <BlocProvider blocs={[state.extra as TransactionSearchBloc]}>
+          <TransactionSearchPageFilters />
+        </BlocProvider>
+      ),
+    },
+    // Partage de dépense : contacts, paiement à partager, répartition
+    {
+      path: AppRouter.transactionSplitPayment,
+      kind: 'page',
+      builder: (state) => {
+        const params = state.extra as { onContinue: (contacts: ContactPI[]) => void };
+        return <ContactSelectPage onContinue={params.onContinue} mbnoForbidden />;
+      },
+    },
+    { path: AppRouter.transactionSplitPaymentTx, kind: 'page', builder: () => <TransactionSplitPageTx /> },
+    {
+      path: AppRouter.transactionSplitPaymentRepartition,
+      kind: 'page',
+      builder: (state) => {
+        const params = state.extra as { tx: Transaction; contacts: ContactPI[] };
+        return <TransactionSplitPageRepartition transaction={params.tx} contacts={params.contacts} />;
+      },
+    },
+    // Formulaire, vérification et programmation
+    { path: AppRouter.transactionFormPage, kind: 'page', builder: () => <TransactionFormPage /> },
+    { path: AppRouter.transactionFormVerification, kind: 'page', builder: () => <TransactionVerificationPage /> },
+    {
+      path: AppRouter.transactionFormSchedule,
+      kind: 'page',
+      builder: (state) => {
+        const params = (state.extra ?? {}) as { dateExpiration?: Date | null; isRtpSchedule?: boolean | null };
+        return <TransactionFormPageSchedule dateExpiration={params.dateExpiration} isRtpSchedule={params.isRtpSchedule} />;
+      },
+    },
+    {
+      path: AppRouter.transactionSendDetails,
+      kind: 'dialog',
+      builder: (state) => {
+        const params = (state.extra ?? {}) as { tx?: Transaction | null; route?: string | null };
+        return (
+          <TransactionDetailsPage
+            endToEndId={state.pathParameters.id}
+            transaction={params.tx}
+            detailsBackRoute={params.route}
+          />
+        );
+      },
+    },
+  ];
+}
+
+/** PROFIL ET PARAMÈTRES */
+function profilRoutes(): RouteDef[] {
+  return [
+    { path: AppRouter.profile, kind: 'page', builder: () => <ProfilePage /> },
+    { path: AppRouter.profileCompte, kind: 'page', builder: () => <ProfileComptePage /> },
+    // Paramètres de l'application
+    { path: AppRouter.profileParametre, kind: 'page', builder: () => <ProfileParametrePage /> },
+    { path: AppRouter.profileParametreTheme, kind: 'page', builder: () => <ProfileParametrePageTheme /> },
+    { path: AppRouter.profileParametreNotifications, kind: 'dialog', builder: () => <ProfileParametrePageNotifications /> },
+    { path: AppRouter.profileParametreNotificationsSon, kind: 'dialog', builder: () => <ProfileParametrePageNotificationsSon /> },
+    // Contacts et alias
+    {
+      path: AppRouter.profileContacts,
+      kind: 'page',
+      builder: (state) => <ProfilePageContacts contactPI={(state.extra as ContactPI | undefined) ?? null} />,
+    },
+    // Aide, CGU et politique de confidentialité
+    { path: AppRouter.profileHelpCenter, kind: 'dialog', builder: () => <ProfileWebPage url={AppEnv.aideLink ?? ''} /> },
+    { path: AppRouter.loginCgu, kind: 'dialog', builder: () => <ProfileWebPage url={AppEnv.cguLink ?? ''} /> },
+    { path: AppRouter.loginPoc, kind: 'dialog', builder: () => <ProfileWebPage url={AppEnv.pocLink ?? ''} /> },
+  ];
+}
+
+/** QR CODE */
+function qrcodeRoutes(): RouteDef[] {
+  return [
+    // Scanner un QR code
+    {
+      path: AppRouter.qrcodeScan,
+      kind: 'page',
+      builder: (state) => <QrcodeScanPage action={(state.extra as string | undefined) ?? TransactionSendCommand.actionSendNow} />,
+    },
+    // Mon QR code
+    { path: AppRouter.qrcodeShow, kind: 'page', builder: () => <QrCodeAliasPage /> },
+    // Transfert à partir d'un QR code scanné
+    {
+      path: AppRouter.qrcodeTransactionSend,
+      kind: 'page',
+      builder: (state) => <QrcodeTransactionSend data={state.extra as QrcodeData} action={state.queryParameters.action} />,
+    },
+  ];
+}
+
+/** Formulaire de transfert prérempli avec le QR code scanné */
+function QrcodeTransactionSend({ data, action: actionParam }: { data: QrcodeData; action?: string }) {
+  const aliasBloc = useBloc(AliasBloc);
+  const [command] = useState(() => {
+    const action = actionParam != null && actionParam.length > 0 && actionParam !== 'undefined' ? actionParam : TransactionSendCommand.actionSendNow;
+    const aliasState = aliasBloc.state;
+    return new TransactionSendCommand({
+      compte: Di.activeCompte,
+      compteAlias: aliasState instanceof AliasExistState ? aliasState.alias.getShid() : undefined,
+      action,
+      method: TransactionSendMethod.qrcode,
+      alias: new TransactionSendCommandAlias({ action, value: data.alias }),
+      canal: action === TransactionSendCommand.actionReceiveNow ? TransactionCanal.transfertParRequestToPay.code : data.channel,
+      amount: data.montant != null ? new TransactionSendCommandAmount({ action, value: data.montant }) : undefined,
+      txId: data.txId,
+    });
+  });
+  return <TransactionFormPageQrcode command={command} />;
+}

package/src/core/sounds.ts

@@ -0,0 +1,52 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+import { createAudioPlayer, type AudioPlayer } from 'expo-audio';
+
+export class SoundItem {
+  constructor(
+    readonly name: string,
+    /** Identifiant du son, persisté dans les préférences (identique au SDK Flutter). */
+    readonly path: string,
+    /** Module Metro du fichier audio. */
+    readonly source: number,
+  ) {}
+}
+
+export class SoundManager {
+  /** Lecteur dédié au SDK, créé à la première lecture. */
+  private static audioPlayer?: AudioPlayer;
+
+  static readonly liste: readonly SoundItem[] = [
+    new SoundItem('Aurora', 'sounds/aurora.mp3', require('../../assets/sounds/aurora.mp3')),
+    new SoundItem('Bamboo', 'sounds/bamboo.mp3', require('../../assets/sounds/bamboo.mp3')),
+    new SoundItem('Chord', 'sounds/chord.mp3', require('../../assets/sounds/chord.mp3')),
+    new SoundItem('Circles', 'sounds/circles.mp3', require('../../assets/sounds/circles.mp3')),
+    new SoundItem('Complete', 'sounds/complete.mp3', require('../../assets/sounds/complete.mp3')),
+    new SoundItem('Hello', 'sounds/hello.mp3', require('../../assets/sounds/hello.mp3')),
+    new SoundItem('Keys', 'sounds/keys.mp3', require('../../assets/sounds/keys.mp3')),
+    new SoundItem('Note', 'sounds/note.mp3', require('../../assets/sounds/note.mp3')),
+    new SoundItem('Popcorn', 'sounds/popcorn.mp3', require('../../assets/sounds/popcorn.mp3')),
+  ];
+
+  static nameFromPath(path: string): string {
+    const item = SoundManager.liste.find((element) => element.path === path);
+    if (!item) throw new Error(`Son inconnu : ${path}`);
+    return item.name;
+  }
+
+  static async playSound(soundPath: string): Promise<void> {
+    const item = SoundManager.liste.find((element) => element.path === soundPath);
+    if (!item) return;
+    if (!SoundManager.audioPlayer) {
+      SoundManager.audioPlayer = createAudioPlayer(item.source);
+    } else {
+      SoundManager.audioPlayer.replace(item.source);
+    }
+    await SoundManager.audioPlayer.seekTo(0);
+    SoundManager.audioPlayer.play();
+  }
+
+  static dispose(): void {
+    SoundManager.audioPlayer?.remove();
+    SoundManager.audioPlayer = undefined;
+  }
+}

package/src/core/sse.ts

@@ -0,0 +1,100 @@
+/**
+ * Client SSE (Server-Sent Events) minimal, équivalent de
+ * `SSEClient.subscribeToSSE` (flutter_client_sse) : `fetch` ne sait pas
+ * lire un flux sous React Native, mais `XMLHttpRequest` reçoit la réponse
+ * au fil de l'eau (événements `progress`).
+ */
+/** Aucun événement reçu dans le délai imparti (≈ `TimeoutException` Dart). */
+export class TimeoutException extends Error {
+  constructor(readonly durationMs: number) {
+    super(`Timeout after ${durationMs} ms`);
+    this.name = 'TimeoutException';
+  }
+}
+
+export type SseEvent = { id?: string; event?: string; data?: string };
+
+export type SseSubscription = { close(): void };
+
+export function subscribeToSSE(params: {
+  url: string;
+  headers: Record<string, string>;
+  onEvent: (event: SseEvent) => void;
+  onError: (error: unknown) => void;
+  /** Délai sans événement au-delà duquel [onError] reçoit une erreur de timeout. */
+  timeoutMs?: number;
+}): SseSubscription {
+  const xhr = new XMLHttpRequest();
+  let processed = 0;
+  let buffer = '';
+  let closed = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    if (timer) clearTimeout(timer);
+    xhr.abort();
+  };
+
+  const armTimeout = () => {
+    if (params.timeoutMs == null) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      if (closed) return;
+      close();
+      params.onError(new TimeoutException(params.timeoutMs!));
+    }, params.timeoutMs);
+  };
+
+  const consume = () => {
+    const text = xhr.responseText ?? '';
+    buffer += text.substring(processed);
+    processed = text.length;
+    // Les événements sont séparés par une ligne vide
+    let separator = buffer.search(/\r?\n\r?\n/);
+    while (separator >= 0 && !closed) {
+      const block = buffer.substring(0, separator);
+      buffer = buffer.substring(separator).replace(/^\r?\n\r?\n/, '');
+      const event: SseEvent = {};
+      const data: string[] = [];
+      for (const line of block.split(/\r?\n/)) {
+        if (line.startsWith(':')) continue;
+        const index = line.indexOf(':');
+        const field = index >= 0 ? line.substring(0, index) : line;
+        const value = index >= 0 ? line.substring(index + 1).replace(/^ /, '') : '';
+        if (field === 'data') data.push(value);
+        else if (field === 'event') event.event = value;
+        else if (field === 'id') event.id = value;
+      }
+      if (data.length > 0) event.data = data.join('\n');
+      if (event.data != null || event.event != null) params.onEvent(event);
+      separator = buffer.search(/\r?\n\r?\n/);
+    }
+  };
+
+  xhr.open('GET', params.url);
+  for (const [key, value] of Object.entries(params.headers)) xhr.setRequestHeader(key, value);
+  xhr.onprogress = () => {
+    armTimeout();
+    consume();
+  };
+  xhr.onreadystatechange = () => {
+    if (closed) return;
+    if (xhr.readyState === XMLHttpRequest.DONE) {
+      consume();
+      if (xhr.status !== 200 && !closed) {
+        close();
+        params.onError(new Error(`SSE HTTP ${xhr.status}`));
+      }
+    }
+  };
+  xhr.onerror = () => {
+    if (closed) return;
+    close();
+    params.onError(new Error('SSE connection error'));
+  };
+  armTimeout();
+  xhr.send();
+  return { close };
+}