@pi-spi/app 0.0.0-stage → 1.2.0

package/src/modules/transactions/domain/models/transaction_send/transaction_confirm_command.ts

@@ -0,0 +1,53 @@
+import { TransactionActions } from './transaction_actions';
+import type { TransactionSendCommandAmount } from './transaction_send_command_amount';
+import type { TransactionSendCommandMotif } from './transaction_send_command_motif';
+
+/** Modèle de confirmation d'un transfert */
+export class TransactionConfirmCommand {
+  static readonly actionSendNow = TransactionActions.actionSendNow;
+  static readonly actionSendSchedule = TransactionActions.actionSendSchedule;
+  static readonly actionReceiveNow = TransactionActions.actionReceiveNow;
+
+  endToendId: string;
+  amount?: TransactionSendCommandAmount;
+  motif?: TransactionSendCommandMotif;
+  /** Position pour les confirmations directes (ex. acceptation RTP) */
+  latitude?: number;
+  longitude?: number;
+  confirmationDate: string;
+  confirmationMethode: string;
+
+  constructor(params: {
+    endToendId: string;
+    confirmationDate: string;
+    confirmationMethode: string;
+    motif?: TransactionSendCommandMotif;
+    amount?: TransactionSendCommandAmount;
+    latitude?: number;
+    longitude?: number;
+  }) {
+    this.endToendId = params.endToendId;
+    this.confirmationDate = params.confirmationDate;
+    this.confirmationMethode = params.confirmationMethode;
+    Object.assign(this, params);
+  }
+
+  isValid(): boolean {
+    this.amount?.isValid();
+    this.motif?.isValid();
+    return this.amount != null && this.amount.isValid() && (this.motif == null || this.motif.isValid());
+  }
+
+  /** Corps JSON de `PUT /transferts/{endToEndId}` */
+  toJson(): Record<string, unknown> {
+    const json: Record<string, unknown> = {
+      montant: this.amount?.value ?? null,
+      confirmationDate: this.confirmationDate,
+      confirmationMethode: this.confirmationMethode,
+    };
+    if (this.motif != null) json.motif = this.motif.value ?? null;
+    if (this.latitude != null) json.latitude = this.latitude;
+    if (this.longitude != null) json.longitude = this.longitude;
+    return json;
+  }
+}

package/src/modules/transactions/domain/models/transaction_send/transaction_send_command.ts

@@ -0,0 +1,168 @@
+import { TransactionCanal } from '../transaction_canal';
+import type { Transaction } from '../transaction';
+import { TransactionActions } from './transaction_actions';
+import { TransactionSendCommandAlias } from './transaction_send_command_alias';
+import { TransactionSendCommandAmount } from './transaction_send_command_amount';
+import type { TransactionSendCommandContact } from './transaction_send_command_contact';
+import type { TransactionSendCommandMotif } from './transaction_send_command_motif';
+import { TransactionSendCommandOthr } from './transaction_send_command_othr';
+import type { TransactionSendCommandSchedule } from './transaction_send_command_schedule';
+import { TransactionSendMethod } from './transaction_send_method';
+
+/** Modèle de demande d'envoi d'un transfert */
+export class TransactionSendCommand {
+  /** paiement immédiat */
+  static readonly actionSendNow = TransactionActions.actionSendNow;
+  /** paiement programmé */
+  static readonly actionSendSchedule = TransactionActions.actionSendSchedule;
+  /** demande de paiement */
+  static readonly actionReceiveNow = TransactionActions.actionReceiveNow;
+
+  /** Envoi, Demande */
+  action: string;
+  /** Méthode d'envoi */
+  method: TransactionSendMethod;
+  /** Solde du client */
+  solde?: number;
+  /** Canal de communication */
+  canal?: string;
+  txId?: string;
+
+  alias?: TransactionSendCommandAlias;
+  othr?: TransactionSendCommandOthr;
+  contact?: TransactionSendCommandContact;
+  amount?: TransactionSendCommandAmount;
+  motif?: TransactionSendCommandMotif;
+  schedule?: TransactionSendCommandSchedule;
+
+  /** Participant payé : code, pays, nom */
+  pspCode?: string;
+  pspPays?: string;
+  pspNom?: string;
+
+  /** Position */
+  latitude?: number;
+  longitude?: number;
+
+  /** Compte payeur */
+  compte: string;
+  /** Alias du client */
+  compteAlias?: string;
+
+  constructor(params: {
+    compte: string;
+    compteAlias?: string;
+    action: string;
+    method: TransactionSendMethod;
+    canal?: string;
+    txId?: string;
+    solde?: number;
+    alias?: TransactionSendCommandAlias;
+    othr?: TransactionSendCommandOthr;
+    contact?: TransactionSendCommandContact;
+    amount?: TransactionSendCommandAmount;
+    motif?: TransactionSendCommandMotif;
+    pspCode?: string;
+    pspPays?: string;
+    pspNom?: string;
+    schedule?: TransactionSendCommandSchedule;
+  }) {
+    this.compte = params.compte;
+    this.action = params.action;
+    this.method = params.method;
+    Object.assign(this, params);
+  }
+
+  isValid(): boolean {
+    this.alias?.isValid();
+    this.amount?.isValid();
+    this.motif?.isValid();
+    this.othr?.isValid();
+    this.schedule?.isValid();
+    return (
+      ((this.alias != null && this.alias.isValid()) ||
+        (this.othr != null && this.othr.isValid() && this.pspCode != null)) &&
+      this.amount != null &&
+      this.amount.isValid() &&
+      (this.schedule == null || this.schedule.isValid()) &&
+      (this.motif == null || this.motif.isValid())
+    );
+  }
+
+  isSoldeValid(frais?: number | null): boolean {
+    return (
+      (this.action === TransactionSendCommand.actionSendNow && (this.solde ?? 0) >= this.amount!.value! + (frais ?? 0)) ||
+      this.action === TransactionSendCommand.actionSendSchedule
+    );
+  }
+
+  /** Corps JSON de `POST /transferts` */
+  toJson(): Record<string, unknown> {
+    const json: Record<string, unknown> = {
+      action: this.action,
+      compte: this.compte,
+      compteAlias: this.compteAlias ?? null,
+      canal: this.canal ?? null,
+      montant: this.amount?.value ?? null,
+      payePSP: this.pspCode ?? null,
+      latitude: this.latitude ?? null,
+      longitude: this.longitude ?? null,
+    };
+    if (this.txId != null) json.txId = this.txId;
+    if (this.motif != null) json.motif = this.motif.value ?? null;
+    if (this.schedule != null) {
+      json.dateDebut = this.schedule.dateDebut;
+      if (this.schedule.frequence != null) {
+        json.frequence = this.schedule.frequence.value;
+        if (this.schedule.frequence.periodicite != null) json.periodicite = this.schedule.frequence.periodicite;
+        if (this.schedule.dateFin != null) json.dateFin = this.schedule.dateFin;
+      }
+    }
+    // Propriétés selon la méthode d'envoi
+    switch (this.method) {
+      case TransactionSendMethod.alias:
+      case TransactionSendMethod.qrcode:
+      case TransactionSendMethod.contact:
+        json.alias = this.alias?.alias() ?? null;
+        break;
+      case TransactionSendMethod.iban:
+        json.iban = this.othr?.compte() ?? null;
+        json.payePSP = this.pspCode ?? null;
+        break;
+      case TransactionSendMethod.othr:
+        json.othr = this.othr?.compte() ?? null;
+        json.payePSP = this.pspCode ?? null;
+        break;
+    }
+    return json;
+  }
+
+  static fromTransaction(
+    transaction: Transaction,
+    action: string,
+    options: { compte?: string; compteAlias?: string } = {},
+  ): TransactionSendCommand {
+    // NB : comme en Dart, la méthode reste `othr` même pour un IBAN valide
+    // (le Dart compare `command.method == iban` au lieu de l'affecter) ;
+    // conservé pour envoyer exactement les mêmes requêtes que le SDK Flutter.
+    return new TransactionSendCommand({
+      action,
+      method: transaction.clientAlias != null ? TransactionSendMethod.alias : TransactionSendMethod.othr,
+      compte: options.compte ?? transaction.compte,
+      compteAlias: options.compteAlias ?? transaction.compteAlias,
+      canal: TransactionCanal.defaultCanal.code,
+      alias:
+        transaction.clientAlias != null
+          ? new TransactionSendCommandAlias({ action, value: transaction.clientAlias })
+          : undefined,
+      othr:
+        transaction.clientAlias == null && transaction.clientCompte != null
+          ? new TransactionSendCommandOthr({ value: transaction.clientCompte })
+          : undefined,
+      pspCode: transaction.clientPSP,
+      pspPays: transaction.clientPays,
+      pspNom: transaction.clientPSPNom,
+      amount: new TransactionSendCommandAmount({ action, value: transaction.montant }),
+    });
+  }
+}

package/src/modules/transactions/domain/models/transaction_send/transaction_send_command_alias.ts

@@ -0,0 +1,46 @@
+import { AliasPI } from '../../../../../shared/models/alias_pi';
+import { TransactionActions } from './transaction_actions';
+
+/** Types d'erreurs possibles sur le champ alias (valeur = codification) */
+export enum TransactionSendCommandAliasError {
+  empty = 'TransactionSendCommandAliasErrorEmpty',
+  invalid = 'TransactionSendCommandAliasErrorInvalid',
+  mbnoForbidden = 'ransactionSendCommandAliasErrorMbnoForbidden',
+  notFound = 'TransactionSendCommandAliasErrorNotFound',
+}
+
+/** Modèles et règles de validation du champ alias */
+export class TransactionSendCommandAlias {
+  action: string;
+  value?: string;
+  error?: TransactionSendCommandAliasError;
+
+  constructor(params: { action: string; value?: string; error?: TransactionSendCommandAliasError }) {
+    this.action = params.action;
+    this.value = params.value;
+    this.error = params.error;
+  }
+
+  alias(): string | undefined {
+    return this.value?.replace(/ /g, '').trim();
+  }
+
+  isValid(): boolean {
+    const alias = this.alias();
+    // lorsque l'identifiant n'est pas renseigné
+    if (this.value == null || this.value.length === 0 || alias == null) {
+      this.error = TransactionSendCommandAliasError.empty;
+    }
+    // L'alias doit être un numéro de téléphone ou un SHID
+    else if (!AliasPI.patternMBNO.test(alias) && !AliasPI.patternSHID.test(alias)) {
+      this.error = TransactionSendCommandAliasError.invalid;
+    }
+    // Une demande de paiement ne peut pas viser un numéro de téléphone
+    else if (this.action === TransactionActions.actionReceiveNow && AliasPI.patternMBNO.test(alias)) {
+      this.error = TransactionSendCommandAliasError.mbnoForbidden;
+    } else {
+      this.error = undefined;
+    }
+    return this.error == null;
+  }
+}

package/src/modules/transactions/domain/models/transaction_send/transaction_send_command_amount.ts

@@ -0,0 +1,46 @@
+import { TransactionActions } from './transaction_actions';
+
+/** Types d'erreurs possibles sur le champ montant (valeur = codification) */
+export enum TransactionSendCommandAmountError {
+  empty = 'TransactionSendCommandAmountErrorEmpty',
+  invalid = 'TransactionSendCommandAmountErrorInvalid',
+  low = 'TransactionSendCommandAmountErrorLow',
+  max = 'TransactionSendCommandAmountErrorMax',
+}
+
+/** Modèles et règles de validation du champ montant */
+export class TransactionSendCommandAmount {
+  action: string;
+  value?: number;
+  solde?: number;
+  error?: TransactionSendCommandAmountError;
+
+  constructor(params: { action: string; value?: number; solde?: number; error?: TransactionSendCommandAmountError }) {
+    this.action = params.action;
+    this.value = params.value;
+    this.solde = params.solde;
+    this.error = params.error;
+  }
+
+  isValid(): boolean {
+    const value = this.value;
+    if (value == null) {
+      this.error = TransactionSendCommandAmountError.empty;
+    }
+    // min transfert 1 franc
+    else if (value < 1) {
+      this.error = TransactionSendCommandAmountError.low;
+    }
+    // Si le solde est insuffisant
+    else if (this.action === TransactionActions.actionSendNow && this.solde != null && value > this.solde) {
+      this.error = TransactionSendCommandAmountError.invalid;
+    }
+    // max transfert 5.000.000 francs
+    else if (value > 5000000) {
+      this.error = TransactionSendCommandAmountError.max;
+    } else {
+      this.error = undefined;
+    }
+    return this.error == null;
+  }
+}

package/src/modules/transactions/domain/models/transaction_send/transaction_send_command_contact.ts

@@ -0,0 +1,13 @@
+/** Modèle du contact destinataire */
+export class TransactionSendCommandContact {
+  name: string;
+  alias: string;
+  /** Photo du contact (URI) */
+  photo?: string;
+
+  constructor(params: { name: string; alias: string; photo?: string }) {
+    this.name = params.name;
+    this.alias = params.alias;
+    this.photo = params.photo;
+  }
+}

package/src/modules/transactions/domain/models/transaction_send/transaction_send_command_motif.ts

@@ -0,0 +1,21 @@
+/** Types d'erreurs possibles sur le champ motif (valeur = codification) */
+export enum TransactionSendCommandMotifError {
+  empty = 'TransactionSendCommandMotifErrorEmpty',
+  invalid = 'TransactionSendCommandMotifErrorInvalid',
+}
+
+/** Modèles et règles de validation du champ motif (104 caractères maximum) */
+export class TransactionSendCommandMotif {
+  value?: string;
+  error?: TransactionSendCommandMotifError;
+
+  constructor(params: { value?: string; error?: TransactionSendCommandMotifError } = {}) {
+    this.value = params.value;
+    this.error = params.error;
+  }
+
+  isValid(): boolean {
+    this.error = this.value != null && this.value.trim().length > 104 ? TransactionSendCommandMotifError.invalid : undefined;
+    return this.error == null;
+  }
+}

package/src/modules/transactions/domain/models/transaction_send/transaction_send_command_othr.ts

@@ -0,0 +1,45 @@
+import { CompteValidator } from '../../../../../shared/models/compte_validator';
+
+/** Types d'erreurs possibles sur le champ compte (valeur = codification) */
+export enum TransactionSendCommandOthrError {
+  empty = 'TransactionSendCommandOthrErrorEmpty',
+  invalid = 'TransactionSendCommandOthrErrorInvalid',
+  invalidMax = 'TransactionSendCommandOthrErrorInvalidMax',
+  invalidIban = 'TransactionSendCommandOthrErrorInvalidIban',
+  invalidPhone = 'TransactionSendCommandOthrErrorInvalidPhone',
+}
+
+/** Modèles et règles de validation du champ compte (IBAN ou autre identifiant) */
+export class TransactionSendCommandOthr {
+  static readonly patternIBAN = /^[A-Z]{2}[0-9]{2}[A-Z0-9]{11,27}$/;
+
+  value?: string;
+  error?: TransactionSendCommandOthrError;
+
+  constructor(params: { value?: string } = {}) {
+    this.value = params.value;
+  }
+
+  compte(): string | undefined {
+    return this.value?.replace(/ /g, '');
+  }
+
+  isValid(): boolean {
+    const compte = this.compte();
+    // `else if` ici : en Dart, l'erreur « vide » était aussitôt écrasée
+    // (et un compte absent faisait planter le test de longueur).
+    if (compte == null || compte.length === 0) {
+      this.error = TransactionSendCommandOthrError.empty;
+    } else if (compte.length > 34) {
+      this.error = TransactionSendCommandOthrError.invalidMax;
+    } else {
+      this.error = undefined;
+    }
+    return this.error == null;
+  }
+
+  /** Vérifie si le compte est un IBAN UEMOA valide (ex. SN08SN0120120103520465350169) */
+  isValidIban(): boolean {
+    return CompteValidator.isUemoaIban(this.compte());
+  }
+}

package/src/modules/transactions/domain/models/transaction_send/transaction_send_command_schedule.ts

@@ -0,0 +1,45 @@
+import type { FrequenceCommand } from '../../../../../shared/models/frequence_command';
+
+export enum TransactionSendCommandScheduleError {
+  debutEmpty = 'debutEmpty',
+}
+
+/** Modèles et règles de validation de la programmation d'un paiement */
+export class TransactionSendCommandSchedule {
+  dateDebut?: Date;
+  dateFin?: Date;
+  frequence?: FrequenceCommand;
+  error?: TransactionSendCommandScheduleError;
+
+  constructor(
+    params: { dateDebut?: Date; dateFin?: Date; frequence?: FrequenceCommand; error?: TransactionSendCommandScheduleError } = {},
+  ) {
+    this.dateDebut = params.dateDebut;
+    this.dateFin = params.dateFin;
+    this.frequence = params.frequence;
+    this.error = params.error;
+  }
+
+  value(): Record<string, unknown> {
+    const json: Record<string, unknown> = {};
+    if (this.dateDebut != null) json.dateDebut = this.dateDebut;
+    if (this.dateFin != null) json.dateFin = this.dateFin;
+    if (this.frequence?.value != null) json.frequence = this.frequence.value;
+    if (this.frequence?.periodicite != null) json.periodicite = this.frequence.periodicite;
+    return json;
+  }
+
+  isValid(): boolean {
+    // lorsque la date de début ou d'exécution n'est pas renseignée
+    this.error = this.dateDebut == null ? TransactionSendCommandScheduleError.debutEmpty : undefined;
+    return this.error == null;
+  }
+
+  toJson(): Record<string, unknown> {
+    const json: Record<string, unknown> = { dateDebut: this.dateDebut!.toISOString() };
+    if (this.frequence?.value != null) json.frequence = this.frequence.value;
+    if (this.frequence?.periodicite != null) json.periodicite = this.frequence.periodicite;
+    if (this.dateFin != null) json.dateFin = this.dateFin.toISOString();
+    return json;
+  }
+}

package/src/modules/transactions/domain/models/transaction_send/transaction_send_method.ts

@@ -0,0 +1,8 @@
+/** Méthode d'envoi (valeur = codification) */
+export enum TransactionSendMethod {
+  alias = 'ALIAS',
+  iban = 'IBAN',
+  othr = 'OTHR',
+  qrcode = 'QRCODE',
+  contact = 'CONTACT',
+}

package/src/modules/transactions/domain/models/transaction_send/transaction_send_response.ts

@@ -0,0 +1,19 @@
+/** Réponse (SSE) à une confirmation de transfert ou de retour de fonds */
+export class TransactionSendResponse {
+  constructor(
+    readonly endToEndId: string,
+    readonly statut: string,
+    /** Date d'irrévocabilité */
+    readonly dateIrrevocabilite?: Date,
+    readonly codeRejet?: string,
+  ) {}
+
+  static fromJson(json: Record<string, any>): TransactionSendResponse {
+    return new TransactionSendResponse(
+      json.endToEndId,
+      json.statut,
+      json.dateIrrevocabilite != null ? new Date(json.dateIrrevocabilite) : undefined,
+      json.codeRejet ?? undefined,
+    );
+  }
+}

package/src/modules/transactions/domain/services/participant_service.ts

@@ -0,0 +1,17 @@
+import type { ParticipantInputPort } from '../../ports/input/participant_input_port';
+import type { ParticipantOutputPort } from '../../ports/output/participant_output_port';
+import type { Participant } from '../models/participant/participant';
+
+export class ParticipantService implements ParticipantInputPort {
+  constructor(readonly participantOutputPort: ParticipantOutputPort) {}
+
+  /** Lister les participants (remote) */
+  search(): Promise<Participant[]> {
+    return this.participantOutputPort.search();
+  }
+
+  /** Lister les participants (local) */
+  list(): Promise<Participant[]> {
+    return this.participantOutputPort.list();
+  }
+}

package/src/modules/transactions/domain/services/transaction_service.ts

@@ -0,0 +1,62 @@
+import type { Stream } from '../../../../core/stream';
+import type { TransactionInputPort } from '../../ports/input/transaction_input_port';
+import type { TransactionListParams, TransactionOutputPort } from '../../ports/output/transaction_output_port';
+import type { Transaction } from '../models/transaction';
+import { TransactionCanal } from '../models/transaction_canal';
+import type { TransactionCancelReason } from '../models/transaction_cancel_reason';
+import type { TransactionListe } from '../models/transaction_liste';
+import type { TransactionRejectReason } from '../models/transaction_reject_reason';
+import type { TransactionConfirmCommand } from '../models/transaction_send/transaction_confirm_command';
+import type { TransactionSendCommand } from '../models/transaction_send/transaction_send_command';
+import type { TransactionSendCommandSchedule } from '../models/transaction_send/transaction_send_command_schedule';
+
+export class TransactionService implements TransactionInputPort {
+  constructor(readonly transactionOutputPort: TransactionOutputPort) {}
+
+  list(params: TransactionListParams): Promise<TransactionListe> {
+    // Comme en Dart, la liste locale n'est pas paginée (page ignorée)
+    return this.transactionOutputPort.list({ ...params, page: undefined });
+  }
+
+  search(params: TransactionListParams): Promise<TransactionListe> {
+    return this.transactionOutputPort.search(params);
+  }
+
+  initiate(command: TransactionSendCommand): Promise<Transaction> {
+    // Définir le canal par défaut s'il n'est pas renseigné
+    command.canal ??= TransactionCanal.defaultCanal.code;
+    return this.transactionOutputPort.initiate(command);
+  }
+
+  schedule(endToEndId: string, command: TransactionSendCommandSchedule): Promise<Transaction> {
+    return this.transactionOutputPort.schedule(endToEndId, command);
+  }
+
+  update(transaction: Transaction): Promise<void> {
+    return this.transactionOutputPort.update(transaction);
+  }
+
+  confirm(command: TransactionConfirmCommand): Promise<Stream<Transaction>> {
+    return this.transactionOutputPort.confirm(command);
+  }
+
+  returnFunds(transaction: Transaction): Promise<Stream<Transaction>> {
+    return this.transactionOutputPort.returnFunds(transaction);
+  }
+
+  cancel(transaction: Transaction, reason: TransactionCancelReason): Promise<Transaction> {
+    return this.transactionOutputPort.cancel(transaction, reason);
+  }
+
+  get(reference: string): Promise<Transaction> {
+    return this.transactionOutputPort.get(reference);
+  }
+
+  fetch(reference: string): Promise<Transaction | null> {
+    return this.transactionOutputPort.fetch(reference);
+  }
+
+  reject(transaction: Transaction, reason: TransactionRejectReason): Promise<Transaction> {
+    return this.transactionOutputPort.reject(transaction, reason);
+  }
+}

package/src/modules/transactions/infra/participant_output_local.ts

@@ -0,0 +1,21 @@
+import { AppStorage } from '../../../core/storage';
+import { Participant } from '../domain/models/participant/participant';
+
+export class ParticipantOutputLocal {
+  static readonly collectionId = 'participants';
+
+  /** Lister les participants à partir des données en local */
+  async list(): Promise<Participant[]> {
+    const liste = await AppStorage.list(ParticipantOutputLocal.collectionId, (json) => Participant.fromJson(json));
+    return liste.sort((a, b) => a.nomMembre.localeCompare(b.nomMembre));
+  }
+
+  /** Enregistre les participants dans la base locale */
+  async save(psps: Participant[]): Promise<void> {
+    await AppStorage.saveList(
+      ParticipantOutputLocal.collectionId,
+      'codeMembre',
+      psps.map((e) => e.toJson()),
+    );
+  }
+}

package/src/modules/transactions/infra/participant_output_remote.ts

@@ -0,0 +1,12 @@
+import { Api } from '../../../core/api';
+import type { Participant } from '../domain/models/participant/participant';
+import { ParticipantListe } from '../domain/models/participant/participant_liste';
+
+export class ParticipantOutputRemote {
+  /** Lister les participants */
+  async list(): Promise<Participant[]> {
+    const response = await Api.get('/participants');
+    const liste = ParticipantListe.fromJson(response.data);
+    return liste.data.sort((a, b) => a.nomMembre.localeCompare(b.nomMembre));
+  }
+}

package/src/modules/transactions/infra/participant_output_repository.ts

@@ -0,0 +1,32 @@
+import { Logger } from '../../../core/logger';
+import type { Participant } from '../domain/models/participant/participant';
+import type { ParticipantOutputPort } from '../ports/output/participant_output_port';
+import { ParticipantOutputLocal } from './participant_output_local';
+import { ParticipantOutputRemote } from './participant_output_remote';
+
+/** Permet d'obtenir la liste des participants dans le cadre d'un transfert */
+export class ParticipantOutputRepository implements ParticipantOutputPort {
+  readonly logger = new Logger();
+  readonly repoRemote = new ParticipantOutputRemote();
+  readonly repoLocal = new ParticipantOutputLocal();
+
+  /** Lister les participants (remote, avec repli sur la copie locale) */
+  async search(): Promise<Participant[]> {
+    try {
+      const liste = await this.repoRemote.list();
+      if (liste.length > 0) {
+        // Sauvegarder la dernière version
+        void this.repoLocal.save(liste);
+      }
+      return liste;
+    } catch (e) {
+      this.logger.e('Impossible de lister les PSPs', { error: e });
+      return this.repoLocal.list();
+    }
+  }
+
+  /** Lister les participants (local) */
+  list(): Promise<Participant[]> {
+    return this.repoLocal.list();
+  }
+}