@pi-spi/app 0.0.0-stage → 1.2.0

package/src/core/di.ts

@@ -0,0 +1,242 @@
+import { NotificationService } from '../modules/notification/domain/services/notification_service';
+import { NotificationOutputRepository } from '../modules/notification/infra/notification_output_repository';
+import type { NotificationInputPort } from '../modules/notification/ports/input/notification_input_port';
+import { SubscriptionService } from '../modules/subscription/domain/services/subscription_service';
+import { SubscriptionOutputRepository } from '../modules/subscription/infra/subscription_output_repository';
+import type { SubscriptionInputPort } from '../modules/subscription/ports/input/subscription_input_port';
+import { AliasService } from '../modules/alias/domain/services/alias_service';
+import { AliasOutputRepository } from '../modules/alias/infra/alias_output_repository';
+import type { AliasInputPort } from '../modules/alias/ports/input/alias_input_port';
+import { CategorieService } from '../modules/categorie/domain/services/categorie_service';
+import { CategorieOutputRepository } from '../modules/categorie/infra/categorie_output_repository';
+import type { CategorieInputPort } from '../modules/categorie/ports/input/categorie_input_port';
+import { CompteService } from '../modules/compte/domain/services/compte_service';
+import { CompteOutputRepository } from '../modules/compte/infra/compte_output_repository';
+import type { CompteInputPort } from '../modules/compte/ports/input/compte_input_port';
+import { ConfigOutputPrefs } from '../modules/config/adapters/infra/config_output_prefs';
+import { ConfigKey } from '../modules/config/domain/models/config_keys';
+import { ConfigService } from '../modules/config/domain/services/config_service';
+import type { ConfigInputPort } from '../modules/config/ports/input/config_input_port';
+import { PermissionService } from '../modules/permission/domain/services/permission_service';
+import { PermissionOutputLocal } from '../modules/permission/infra/permissions_output_local';
+import type { PermissionInputPort } from '../modules/permission/ports/input/permission_input_port';
+import { QrcodeService } from '../modules/qrcode/domain/services/qrcode_service';
+import type { QrcodeInputPort } from '../modules/qrcode/ports/input/qrcode_input_port';
+import { ParticipantService } from '../modules/transactions/domain/services/participant_service';
+import { TransactionService } from '../modules/transactions/domain/services/transaction_service';
+import { ParticipantOutputRepository } from '../modules/transactions/infra/participant_output_repository';
+import { TransactionOutputRepository } from '../modules/transactions/infra/transaction_output_repository';
+import type { ParticipantInputPort } from '../modules/transactions/ports/input/participant_input_port';
+import type { TransactionInputPort } from '../modules/transactions/ports/input/transaction_input_port';
+import { Api } from './api';
+import { CompteAliasStatus } from './compte_alias_status';
+import { AppEnv } from './env';
+import { AppLogger } from './logger';
+import type { PiSpiSdkConfig } from './pi_spi_sdk_config';
+import { AppStorage, SecureStorage, SharedPreferences } from './storage';
+import { ValueNotifier } from './value_notifier';
+
+/**
+ * Injection de dépendances des ports d'entrée/sortie pour tous les modules
+ * métier du SDK PI-SPI. L'authentification (login, PIN, biométrie) n'est
+ * pas gérée ici : elle reste entièrement à la charge de l'application hôte.
+ *
+ * Les ports des modules métier (alias, compte, transactions, ...) sont
+ * ajoutés ici au fur et à mesure de leur portage depuis le SDK Flutter.
+ */
+export class Di {
+  static sharedPreferences: SharedPreferences;
+  static secureStorage: SecureStorage;
+  static config: PiSpiSdkConfig;
+
+  /**
+   * Compte actuellement actif pour la session en cours : celui utilisé
+   * pour retrouver/créer l'alias PI-SPI, envoyer une transaction, générer
+   * le QR code, etc. Initialisé depuis `config.user.currentAccount` (ou
+   * `comptes[0].numero` à défaut), puis mis à jour quand le client
+   * choisit un compte (écran de sélection, ou carrousel de l'accueil).
+   */
+  static activeCompte: string;
+
+  /**
+   * État de l'alias PI-SPI de {@link activeCompte}. Mis à jour par le
+   * redirect de `/home` et par le carrousel de l'accueil
+   * (`CompteAliasStatus.checking` dès qu'on swipe sur un autre compte, puis
+   * selon le résultat) : l'accueil s'en sert pour griser les actions qui
+   * nécessitent un alias (profil, notifications, onglets, Envoyer,
+   * Recevoir, Plus) et proposer de réessayer en cas d'erreur.
+   */
+  static readonly activeCompteAlias = new ValueNotifier<CompteAliasStatus>(CompteAliasStatus.exists);
+
+  /**
+   * Consommé une seule fois par le redirect de la route `/home` : quand
+   * non-null et égal à {@link activeCompte}, autorise l'accueil à
+   * s'afficher sans vérifier l'alias (et se réinitialise aussitôt à
+   * `null`). Posé par AliasPage juste avant un `pop()` vers l'accueil,
+   * pour le cas où le client refuse explicitement de créer un alias
+   * (bouton retour) — sans ça, le redirect le renverrait aussitôt vers la
+   * création, empêchant tout retour réel à l'accueil.
+   */
+  static skipHomeAliasCheckForCompte: string | null = null;
+
+  /** Configuration - paramètres - préférences utilisateur */
+  static pConfigInputPort?: ConfigInputPort;
+
+  /** Permissions runtime (contacts, notifications, localisation) */
+  static pPermissionInputPort?: PermissionInputPort;
+
+  /** Alias */
+  static pAliasInputPort?: AliasInputPort;
+
+  /** Gestion du compte */
+  static pCompteInputPort?: CompteInputPort;
+
+  /** Gestion des QR Code */
+  static pQrcodeInputPort?: QrcodeInputPort;
+
+  /** Gestion des catégories */
+  static pCategorieInputPort?: CategorieInputPort;
+
+  /** Gestion des PSPs */
+  static pParticipantInputPort?: ParticipantInputPort;
+
+  /** Gestion des transactions */
+  static pTransactionInputPort?: TransactionInputPort;
+
+  static pSubscriptionInputPort?: SubscriptionInputPort;
+
+  static pNotificationInputPort?: NotificationInputPort;
+
+  /**
+   * Initialise le SDK : stockage local, client API, injection des
+   * dépendances. Appelé par `PiSpiSdkEntry` avant d'afficher le SDK.
+   */
+  static async init(config: PiSpiSdkConfig): Promise<void> {
+    Di.config = config;
+    Di.activeCompte = config.user.currentAccount ?? config.user.comptes[0].numero;
+    Di.activeCompteAlias.value = CompteAliasStatus.exists;
+    AppEnv.configure(config);
+    AppLogger.config(config);
+
+    Di.sharedPreferences = await SharedPreferences.getInstance();
+    Di.secureStorage = new SecureStorage();
+
+    await Di.applyDefaultTheme(config);
+
+    Api.initClient(config);
+    await AppStorage.init(Di.secureStorage);
+  }
+
+  /**
+   * Applique le thème fourni par l'hôte (s'il y en a un) et le persiste
+   * comme nouveau thème par défaut : à chaque ouverture du SDK où l'hôte
+   * transmet `PiSpiAppConfig.defaultTheme`, cette valeur prend effet
+   * immédiatement et écrase la préférence locale existante, y compris un
+   * choix que le client aurait fait lui-même depuis les écrans de
+   * paramètres du SDK lors d'une session précédente. Si l'hôte ne fournit
+   * pas de thème, la préférence locale actuelle (ou le défaut du SDK si
+   * aucune n'existe encore) est conservée telle quelle.
+   */
+  private static async applyDefaultTheme(config: PiSpiSdkConfig): Promise<void> {
+    if (config.appConfig.defaultTheme != null) {
+      await Di.sharedPreferences.setString(ConfigKey.preferedTheme, config.appConfig.defaultTheme);
+    }
+  }
+
+  /**
+   * Réinitialise tous les singletons (utile si le SDK est ré-ouvert
+   * pour un utilisateur différent au sein de la même application hôte).
+   */
+  static reset(): void {
+    Di.pConfigInputPort = undefined;
+    Di.pPermissionInputPort = undefined;
+    Di.pAliasInputPort = undefined;
+    Di.pCompteInputPort = undefined;
+    Di.pQrcodeInputPort = undefined;
+    Di.pParticipantInputPort = undefined;
+    Di.pCategorieInputPort = undefined;
+    Di.pTransactionInputPort = undefined;
+    Di.pSubscriptionInputPort = undefined;
+    Di.pNotificationInputPort = undefined;
+  }
+
+  /** Retourne l'implementation de configuration Input Port */
+  static getConfigInputPort(): ConfigInputPort {
+    if (!Di.pConfigInputPort) {
+      Di.pConfigInputPort = new ConfigService(new ConfigOutputPrefs(Di.sharedPreferences));
+    }
+    return Di.pConfigInputPort;
+  }
+
+  /** Retourne l'implementation de permission input port */
+  static getPermissionInputPort(): PermissionInputPort {
+    if (!Di.pPermissionInputPort) {
+      Di.pPermissionInputPort = new PermissionService(new PermissionOutputLocal());
+    }
+    return Di.pPermissionInputPort;
+  }
+
+  /** Retourne l'implementation de alias input port */
+  static getAliasInputPort(): AliasInputPort {
+    if (!Di.pAliasInputPort) {
+      Di.pAliasInputPort = new AliasService(new AliasOutputRepository());
+    }
+    return Di.pAliasInputPort;
+  }
+
+  /** Retourne l'implementation de compte input port */
+  static getCompteInputPort(): CompteInputPort {
+    if (!Di.pCompteInputPort) {
+      Di.pCompteInputPort = new CompteService(new CompteOutputRepository());
+    }
+    return Di.pCompteInputPort;
+  }
+
+  /** Retourne l'implementation des QR Code */
+  static getQrcodeInputPort(): QrcodeInputPort {
+    if (!Di.pQrcodeInputPort) {
+      Di.pQrcodeInputPort = new QrcodeService();
+    }
+    return Di.pQrcodeInputPort;
+  }
+
+  /** Retourne l'implementation de participant input port */
+  static getParticipantInputPort(): ParticipantInputPort {
+    if (!Di.pParticipantInputPort) {
+      Di.pParticipantInputPort = new ParticipantService(new ParticipantOutputRepository());
+    }
+    return Di.pParticipantInputPort;
+  }
+
+  /** Retourne l'implementation de transaction input port */
+  static getTransactionInputPort(): TransactionInputPort {
+    if (!Di.pTransactionInputPort) {
+      Di.pTransactionInputPort = new TransactionService(new TransactionOutputRepository());
+    }
+    return Di.pTransactionInputPort;
+  }
+
+  /** Retourne l'implementation de categorie input port */
+  static getCategorieInputPort(): CategorieInputPort {
+    if (!Di.pCategorieInputPort) {
+      Di.pCategorieInputPort = new CategorieService(new CategorieOutputRepository());
+    }
+    return Di.pCategorieInputPort;
+  }
+
+  /** Retourne l'implementation de subscription input port */
+  static getSubscriptionInputPort(): SubscriptionInputPort {
+    if (!Di.pSubscriptionInputPort) {
+      Di.pSubscriptionInputPort = new SubscriptionService(new SubscriptionOutputRepository());
+    }
+    return Di.pSubscriptionInputPort;
+  }
+
+  /** Retourne l'implementation de notification input port */
+  static getNotificationInputPort(): NotificationInputPort {
+    if (!Di.pNotificationInputPort) {
+      Di.pNotificationInputPort = new NotificationService(new NotificationOutputRepository());
+    }
+    return Di.pNotificationInputPort;
+  }
+}

package/src/core/env.ts

@@ -0,0 +1,34 @@
+import type { PiSpiSdkConfig } from './pi_spi_sdk_config';
+
+/**
+ * Pont entre {@link PiSpiSdkConfig} (fourni par l'hôte à l'init) et le code
+ * interne du SDK. Alimenté une seule fois par `Di.init`.
+ */
+export class AppEnv {
+  static apiUrl = '';
+  static codeMembre = '';
+  static appName = '';
+  static version = '';
+  static cguLink?: string;
+  static pocLink?: string;
+  static aideLink?: string;
+  static playstoreLink = '';
+  static appstoreLink = '';
+  static logLevel = 'info';
+
+  /** Constructeur privé : la classe n'est jamais instanciée. */
+  private constructor() {}
+
+  static configure(config: PiSpiSdkConfig): void {
+    AppEnv.apiUrl = config.api.apiBaseUrl;
+    AppEnv.codeMembre = config.appConfig.pspCodeMembre;
+    AppEnv.appName = config.appConfig.appName;
+    AppEnv.version = config.appConfig.appVersion;
+    AppEnv.cguLink = config.appConfig.cguLink;
+    AppEnv.pocLink = config.appConfig.pocLink;
+    AppEnv.aideLink = config.appConfig.aideLink;
+    AppEnv.playstoreLink = config.appConfig.playstoreLink;
+    AppEnv.appstoreLink = config.appConfig.appstoreLink;
+    AppEnv.logLevel = config.log.logLevel;
+  }
+}

package/src/core/location.ts

@@ -0,0 +1,47 @@
+import * as Location from 'expo-location';
+
+export type Position = { latitude: number; longitude: number };
+
+/**
+ * Position GPS actuelle (≈ `Geolocator.getCurrentPosition` avec la
+ * précision haute) : échoue si le service de localisation est désactivé
+ * ou si la permission est refusée.
+ */
+export async function getCurrentPosition(): Promise<Position> {
+  // Vérifie d'abord si le service de localisation est activé
+  if (!(await Location.hasServicesEnabledAsync())) {
+    throw new Error('Le service de localisation est désactivé.');
+  }
+  // Vérifie le statut de la permission
+  let permission = await Location.getForegroundPermissionsAsync();
+  if (!permission.granted && permission.canAskAgain) {
+    permission = await Location.requestForegroundPermissionsAsync();
+  }
+  if (!permission.granted) {
+    throw new Error(
+      permission.canAskAgain
+        ? 'Permission de localisation refusée.'
+        : 'Permission de localisation refusée définitivement.',
+    );
+  }
+  // OK → on récupère la position
+  const position = await Location.getCurrentPositionAsync({ accuracy: Location.Accuracy.High });
+  return { latitude: position.coords.latitude, longitude: position.coords.longitude };
+}
+
+/**
+ * Position GPS, en demandant la permission (via [grantPermission]) si
+ * elle n'est pas encore accordée ; `null` si elle reste indisponible.
+ */
+export async function getPositionOrAsk(grantPermission: () => Promise<boolean>): Promise<Position | null> {
+  try {
+    return await getCurrentPosition();
+  } catch {
+    if (!(await grantPermission())) return null;
+    try {
+      return await getCurrentPosition();
+    } catch {
+      return null;
+    }
+  }
+}

package/src/core/logger.ts

@@ -0,0 +1,149 @@
+import type { PiSpiSdkConfig } from './pi_spi_sdk_config';
+
+/** Niveaux de journalisation, dans le même ordre que `package:logger` (Dart). */
+export enum Level {
+  all = 0,
+  trace = 1000,
+  debug = 2000,
+  info = 3000,
+  warning = 4000,
+  error = 5000,
+  fatal = 6000,
+  off = 10000,
+}
+
+type LogOptions = { error?: unknown; stackTrace?: unknown };
+
+/**
+ * Petit équivalent de `Logger` (package:logger) utilisé dans tout le SDK :
+ * `logger.t/d/i/w/e/f(message, { error, stackTrace })`. Le niveau est
+ * global ({@link Logger.level}), fixé par {@link AppLogger.config}.
+ */
+export class Logger {
+  static level: Level = Level.debug;
+
+  t(message: unknown, options?: LogOptions): void {
+    this.log(Level.trace, message, options);
+  }
+
+  d(message: unknown, options?: LogOptions): void {
+    this.log(Level.debug, message, options);
+  }
+
+  i(message: unknown, options?: LogOptions): void {
+    this.log(Level.info, message, options);
+  }
+
+  w(message: unknown, options?: LogOptions): void {
+    this.log(Level.warning, message, options);
+  }
+
+  e(message: unknown, options?: LogOptions): void {
+    this.log(Level.error, message, options);
+  }
+
+  f(message: unknown, options?: LogOptions): void {
+    this.log(Level.fatal, message, options);
+  }
+
+  private log(level: Level, message: unknown, options?: LogOptions): void {
+    if (Logger.level === Level.off || level < Logger.level) return;
+    const prefix = `[PI-SPI][${Level[level].toUpperCase()}]`;
+    const extras = [options?.error, options?.stackTrace].filter((v) => v !== undefined);
+    if (level >= Level.error) console.error(prefix, message, ...extras);
+    else if (level === Level.warning) console.warn(prefix, message, ...extras);
+    else console.log(prefix, message, ...extras);
+  }
+}
+
+type GlobalErrorHandler = (error: unknown, isFatal?: boolean) => void;
+
+declare const ErrorUtils:
+  | {
+      getGlobalHandler(): GlobalErrorHandler;
+      setGlobalHandler(handler: GlobalErrorHandler): void;
+    }
+  | undefined;
+
+/**
+ * Configuration du niveau de journalisation du SDK, et transmission
+ * optionnelle des erreurs JS à l'application hôte.
+ *
+ * Contrairement à l'application de référence, le SDK n'installe pas son
+ * propre crash reporting (pas de Crashlytics) : un package embarqué dans
+ * une app hôte ne doit jamais intercepter/remplacer l'UI de l'hôte sur
+ * erreur, ni faire planter l'app à sa place. Si l'hôte fournit
+ * `PiSpiLogConfig.onError`, ses erreurs lui sont simplement transmises
+ * pour qu'il les remonte à son propre outil.
+ */
+export class AppLogger {
+  /**
+   * Gestionnaire d'erreurs global déjà en place côté hôte avant que le SDK
+   * ne soit ouvert (capturé une seule fois, pour ne jamais l'écraser).
+   * Toujours rappelé après `PiSpiLogConfig.onError`.
+   */
+  private static hostOnError?: GlobalErrorHandler;
+  private static errorForwardingInstalled = false;
+
+  /** Callback courant de l'hôte (remplacé à chaque ouverture du SDK). */
+  private static onError?: (error: unknown, isFatal: boolean) => void;
+
+  private constructor() {}
+
+  /**
+   * Configure le niveau de journalisation, et installe (une seule fois,
+   * même si le SDK est fermé puis rouvert plusieurs fois dans la même
+   * session hôte) la transmission des erreurs JS globales si
+   * `PiSpiLogConfig.onError` est fourni.
+   */
+  static config(config: PiSpiSdkConfig): void {
+    AppLogger.defineLevel(config.log.logLevel);
+    AppLogger.onError = config.log.onError;
+
+    if (config.log.onError && !AppLogger.errorForwardingInstalled && typeof ErrorUtils !== 'undefined') {
+      AppLogger.hostOnError = ErrorUtils.getGlobalHandler();
+      AppLogger.errorForwardingInstalled = true;
+      ErrorUtils.setGlobalHandler((error, isFatal) => {
+        AppLogger.onError?.(error, isFatal ?? false);
+        AppLogger.hostOnError?.(error, isFatal);
+      });
+    }
+  }
+
+  /**
+   * Transmet à l'hôte une erreur interceptée par le SDK lui-même (ex.
+   * erreur de rendu attrapée par la frontière d'erreur de `PiSpiSdkEntry`).
+   */
+  static report(error: unknown, isFatal = false): void {
+    AppLogger.onError?.(error, isFatal);
+  }
+
+  /** Définit le niveau de journalisation. */
+  private static defineLevel(logLevel: string): void {
+    switch (logLevel) {
+      case 'debug':
+        Logger.level = Level.debug;
+        break;
+      case 'fatal':
+        Logger.level = Level.fatal;
+        break;
+      case 'error':
+        Logger.level = Level.error;
+        break;
+      case 'warning':
+        Logger.level = Level.warning;
+        break;
+      case 'info':
+        Logger.level = Level.info;
+        break;
+      case 'trace':
+        Logger.level = Level.trace;
+        break;
+      case 'off':
+        Logger.level = Level.off;
+        break;
+      default:
+        Logger.level = Level.all;
+    }
+  }
+}

package/src/core/notifications.ts

@@ -0,0 +1,51 @@
+import { StreamController } from './stream';
+
+/**
+ * Bus d'événements internes du SDK. Le SDK n'intègre aucun fournisseur de
+ * notifications push (Firebase, APNs, ...) — c'est l'application hôte qui
+ * s'en charge avec sa propre configuration, puis transmet les événements
+ * pertinents au SDK via `PiSpiPush.handleIncoming` (voir pi_spi_push.ts),
+ * qui republie dans ce bus. Les écrans qui écoutent
+ * {@link AppNotifications.eventStreamController} /
+ * {@link AppNotifications.transfertEmisStreamController} réagissent de la
+ * même façon, que l'événement vienne d'un push ou d'une action interne au
+ * SDK (ex. confirmation d'un envoi de transaction).
+ */
+export class AppNotifications {
+  static readonly eventStreamController = new StreamController<NotificationExternalEvent>();
+
+  static readonly transfertEmisStreamController = new StreamController<Record<string, any>>();
+}
+
+export class NotificationExternalEvent {
+  static readonly notificationStyleSnackBar = 'snackbar';
+  static readonly notificationStyleDialog = 'dialog';
+
+  /** identifiant de la notification enregistrée */
+  readonly notificationId?: string;
+  /** identifiant de l'objet concerné */
+  readonly idObject?: string;
+  readonly type?: string;
+  readonly title?: string;
+  readonly body?: string;
+  readonly montant?: number;
+  readonly clientAlias?: string;
+  readonly clientNom?: string;
+  readonly clientCategorie?: string;
+  readonly canal?: string;
+
+  constructor(params: {
+    notificationId?: string;
+    idObject?: string;
+    type?: string;
+    title?: string;
+    body?: string;
+    montant?: number;
+    clientAlias?: string;
+    clientNom?: string;
+    clientCategorie?: string;
+    canal?: string;
+  }) {
+    Object.assign(this, params);
+  }
+}

package/src/core/pi_spi_push.ts

@@ -0,0 +1,49 @@
+import { AppNotifications, NotificationExternalEvent } from './notifications';
+
+/**
+ * Point d'intégration pour les notifications push.
+ *
+ * Le SDK n'embarque aucun fournisseur de push (Firebase, APNs, OneSignal,
+ * expo-notifications...) ni la logique d'enregistrement du token auprès du
+ * backend : c'est l'application hôte qui gère sa propre configuration de
+ * push de bout en bout (obtention du token, enregistrement auprès de son
+ * backend). Cette classe ne fait qu'un pont entre un message push déjà
+ * reçu par l'hôte et l'UI du SDK.
+ */
+export class PiSpiPush {
+  /** Constructeur privé : la classe n'est jamais instanciée. */
+  private constructor() {}
+
+  /**
+   * À appeler depuis le handler de message push de l'application hôte
+   * (ex. `messaging().onMessage` / `Notifications.addNotificationReceivedListener`)
+   * lorsque le message concerne PI-SPI. Republie l'événement dans le bus
+   * interne du SDK ({@link AppNotifications.eventStreamController}), ce qui
+   * déclenche le même comportement (toast, rafraîchissement de liste,
+   * badge) que dans l'app de référence.
+   *
+   * `data` correspond au payload "data" du message push (mêmes clés que
+   * l'API notifications : `notificationId`, `idObject`, `type`, `montant`,
+   * `clientAlias`, `clientNom`, `clientCategorie`, `canal`). `title`/`body`
+   * sont pris depuis `data` s'ils n'y sont pas fournis séparément, pour
+   * s'accommoder des fournisseurs qui séparent payload "notification" et
+   * payload "data" (comme FCM).
+   */
+  static handleIncoming(data: Record<string, unknown>, options: { title?: string; body?: string } = {}): void {
+    const str = (v: unknown) => (v == null ? undefined : String(v));
+    const montant = data.montant != null ? parseFloat(String(data.montant)) : undefined;
+    const event = new NotificationExternalEvent({
+      notificationId: str(data.notificationId),
+      idObject: str(data.idObject),
+      type: str(data.type),
+      montant: montant != null && !Number.isNaN(montant) ? montant : undefined,
+      clientAlias: str(data.clientAlias),
+      clientNom: str(data.clientNom),
+      clientCategorie: str(data.clientCategorie),
+      canal: str(data.canal),
+      title: options.title ?? str(data.title),
+      body: options.body ?? str(data.body),
+    });
+    AppNotifications.eventStreamController.add(event);
+  }
+}