@pi-spi/app 0.0.0-stage → 1.2.0

package/src/modules/transactions/presentation/bloc/transaction_send/transaction_send_bloc.ts

@@ -0,0 +1,376 @@
+import { ApiError, ApiException } from '../../../../../core/api';
+import { Bloc, type Emitter } from '../../../../../core/bloc';
+import { getPositionOrAsk, type Position } from '../../../../../core/location';
+import { Logger } from '../../../../../core/logger';
+import { AppNotifications } from '../../../../../core/notifications';
+import { TimeoutException } from '../../../../../core/sse';
+import type { Unsubscribe } from '../../../../../core/stream';
+import { CompteValidator } from '../../../../../shared/models/compte_validator';
+import type { CompteInputPort } from '../../../../compte/ports/input/compte_input_port';
+import { PermissionType } from '../../../../permission/domain/models/permission_type';
+import type { PermissionInputPort } from '../../../../permission/ports/input/permission_input_port';
+import type { Participant } from '../../../domain/models/participant/participant';
+import { TransactionStatut, type Transaction } from '../../../domain/models/transaction';
+import { TransactionError } from '../../../domain/models/transaction_error';
+import { TransactionConfirmCommand } from '../../../domain/models/transaction_send/transaction_confirm_command';
+import { TransactionSendCommand } from '../../../domain/models/transaction_send/transaction_send_command';
+import { TransactionSendMethod } from '../../../domain/models/transaction_send/transaction_send_method';
+import type { ParticipantInputPort } from '../../../ports/input/participant_input_port';
+import type { TransactionInputPort } from '../../../ports/input/transaction_input_port';
+import {
+  TransactionSendConfirmEvent,
+  TransactionSendDisplayFormEvent,
+  TransactionSendErrorEvent,
+  TransactionSendFormChangedEvent,
+  TransactionSendInitiateEvent,
+  TransactionSendListRecentsEvent,
+  TransactionSendRejectEvent,
+  TransactionSendResponseEvent,
+  TransactionSendScheduleEvent,
+  TransactionSendSplitSendEvent,
+  TransactionSendUpdateStateEvent,
+  type TransactionSendEvent,
+} from './transaction_send_event';
+import {
+  TransactionSendFormErrorState,
+  TransactionSendFormInputState,
+  TransactionSendFormScheduleState,
+  TransactionSendFormSendingState,
+  TransactionSendFormSuccessState,
+  TransactionSendFormVerificationAskingState,
+  TransactionSendFormVerificationLoadingState,
+  TransactionSendInitialState,
+  type TransactionSendData,
+  type TransactionSendState,
+} from './transaction_send_state';
+
+/**
+ * Parcours d'envoi (et de demande) d'argent : formulaire, initiation,
+ * vérification, confirmation (réponse par SSE), programmation et partage
+ * de dépense. Fourni à tout le SDK par `PiSpiSdkEntry`.
+ */
+export class TransactionSendBloc extends Bloc<TransactionSendEvent, TransactionSendState> {
+  readonly logger = new Logger();
+  private soldeSubscription?: Unsubscribe;
+
+  constructor(
+    /** Service transaction */
+    readonly transactionsInputPort: TransactionInputPort,
+    /** Info compte solde */
+    readonly compteInputPort: CompteInputPort,
+    /** Pour obtenir la liste des participants */
+    readonly participantInputPort: ParticipantInputPort,
+    /** Pour demander des permissions */
+    readonly permissionInputPort: PermissionInputPort,
+  ) {
+    super(new TransactionSendInitialState());
+    // Pour mettre à jour l'état
+    this.on(TransactionSendUpdateStateEvent, (e, emit) => this.onUpdateState(e, emit));
+    // Pour obtenir la liste des transferts récents
+    this.on(TransactionSendListRecentsEvent, (e, emit) => this.onListRecents(e, emit));
+    // Pour afficher le formulaire de transaction
+    this.on(TransactionSendDisplayFormEvent, (e, emit) => this.onDisplayForm(e, emit));
+    // Pour vérifier l'état de validation du formulaire
+    this.on(TransactionSendFormChangedEvent, (e, emit) => this.onFormChanged(e, emit));
+    // Pour initier la transaction
+    this.on(TransactionSendInitiateEvent, (e, emit) => this.onInitiate(e, emit));
+    // Pour confirmer la transaction
+    this.on(TransactionSendConfirmEvent, (e, emit) => this.onConfirm(e, emit));
+    // Pour rejeter la transaction
+    this.on(TransactionSendRejectEvent, (_e, emit) =>
+      emit(new TransactionSendInitialState({ transactions: this.state.transactions, ...this.data() })),
+    );
+    // À la réception d'une réponse
+    this.on(TransactionSendResponseEvent, (e, emit) => this.onResponse(e, emit));
+    this.on(TransactionSendErrorEvent, (e, emit) => this.emitError(emit, e.command, e.error));
+    // Pour programmer une transaction
+    this.on(TransactionSendScheduleEvent, (e, emit) => {
+      e.command.isValid();
+      emit(new TransactionSendFormScheduleState(e.command, e.transaction, this.data()));
+    });
+    // Pour partager un paiement
+    this.on(TransactionSendSplitSendEvent, (e, emit) => this.onSplitSend(e, emit));
+  }
+
+  override close(): void {
+    this.soldeSubscription?.();
+    super.close();
+  }
+
+  private data(): TransactionSendData {
+    return { solde: this.state.solde, participants: this.state.participants };
+  }
+
+  /**
+   * Comme en Flutter, l'état courant est modifié sur place ; on en
+   * réémet une copie pour que les écrans voient la mise à jour (Flutter
+   * ignore l'émission du même objet).
+   */
+  private emitUpdated(emit: Emitter<TransactionSendState>): void {
+    emit(Object.assign(Object.create(Object.getPrototypeOf(this.state)), this.state));
+  }
+
+  /** Pour mettre à jour l'état (solde, participants) */
+  private async onUpdateState(event: TransactionSendUpdateStateEvent, emit: Emitter<TransactionSendState>) {
+    try {
+      const { solde, participants } = event.params;
+      if (solde != null) this.state.solde = solde;
+      if (participants != null && participants.length > 0) {
+        this.state.participants = participants;
+      } else if (this.state.participants == null || this.state.participants.length === 0) {
+        const local = await this.participantInputPort.list();
+        if (local.length > 0) {
+          this.state.participants = local;
+          this.emitUpdated(emit);
+        }
+        this.state.participants = await this.participantInputPort.search();
+      }
+      this.emitUpdated(emit);
+    } catch {
+      // On garde l'état courant
+    }
+  }
+
+  /** Pour obtenir la liste des transferts récents */
+  private async onListRecents(event: TransactionSendListRecentsEvent, emit: Emitter<TransactionSendState>) {
+    const transactions = await this.transactionsInputPort.list({ compte: event.compte, limit: 2 });
+    emit(new TransactionSendInitialState({ transactions, ...this.data() }));
+  }
+
+  /** Récupère les données de référence permettant d'effectuer des transferts */
+  private async onDisplayForm(event: TransactionSendDisplayFormEvent, emit: Emitter<TransactionSendState>) {
+    emit(new TransactionSendFormInputState(event.command, this.data()));
+    const form = event.command;
+    // Récupérer le solde
+    form.solde = this.state.solde ?? undefined;
+    // Récupérer le nom du PSP
+    if (form.pspCode != null) {
+      const psp = (this.state.participants ?? []).find((p) => p.codeMembre === form.pspCode);
+      if (psp != null) form.pspNom = psp.nomMembre;
+    }
+    emit(new TransactionSendFormInputState(form, this.data()));
+
+    // Actualiser le solde et la liste de participants
+    try {
+      const [psps, streamSolde] = await Promise.all([
+        this.participantInputPort.search(),
+        this.compteInputPort.getSolde(form.compte),
+      ]);
+      this.soldeSubscription?.();
+      this.soldeSubscription = streamSolde.listen((solde) => {
+        if (!this.isClosed) this.add(new TransactionSendUpdateStateEvent({ solde: solde ?? 0, participants: psps }));
+      });
+    } catch (e) {
+      this.logger.e('Actualisation du solde et des participants', { error: e });
+    }
+  }
+
+  /** À chaque fois que les données entrées changent (formulaire réactif) */
+  private onFormChanged(event: TransactionSendFormChangedEvent, emit: Emitter<TransactionSendState>) {
+    const form = event.command;
+    form.solde = this.state.solde ?? undefined;
+    if (form.othr != null) {
+      form.method = form.othr.isValidIban() ? TransactionSendMethod.iban : TransactionSendMethod.othr;
+    }
+    form.isValid();
+
+    const participants = this.state.participants ?? [];
+    // Si IBAN, déterminer le participant
+    if (form.method === TransactionSendMethod.iban) {
+      this.getPsp(form, form.othr!.compte()!.substring(4, 9), participants);
+    }
+    // Si autre compte valide
+    else if (form.method === TransactionSendMethod.othr && form.othr != null && form.othr.isValid()) {
+      if (CompteValidator.isUemoaRib(form.othr.compte())) {
+        this.getPsp(form, form.othr.compte()!.substring(0, 5), participants);
+      } else if (form.pspCode != null && this.state.participants != null) {
+        const matches = this.state.participants.filter((p) => p.codeMembre === form.pspCode);
+        if (matches.length === 1) form.pspNom = matches[0].nomMembre;
+      }
+    }
+    emit(new TransactionSendFormInputState(form, this.data()));
+  }
+
+  private getPsp(form: TransactionSendCommand, codeBanque: string, participants: Participant[]) {
+    form.pspCode = undefined;
+    form.pspPays = undefined;
+    form.pspNom = undefined;
+    const matches = participants.filter((p) => p.codeBanque === codeBanque);
+    if (matches.length === 1) {
+      const psp = matches[0];
+      form.pspCode = psp.codeMembre;
+      form.pspPays = psp.codeMembre.substring(0, 2);
+      form.pspNom = psp.nomMembre;
+    }
+  }
+
+  /** Initier la transaction (recherche d'alias, QR code, vérification) */
+  private async onInitiate(event: TransactionSendInitiateEvent, emit: Emitter<TransactionSendState>) {
+    emit(new TransactionSendFormVerificationLoadingState(event.command, this.data()));
+    // Récupérer la position GPS
+    const position = await this.getPosition();
+    if (position == null) {
+      this.emitError(emit, event.command, TransactionError.location);
+      return;
+    }
+    // Ajouter la position dans les données du transfert
+    event.command.latitude = position.latitude;
+    event.command.longitude = position.longitude;
+    try {
+      const transaction = await this.transactionsInputPort.initiate(event.command);
+      if (event.command.action === TransactionSendCommand.actionReceiveNow) {
+        // La demande est envoyée
+        emit(new TransactionSendFormSuccessState(event.command, transaction, this.data()));
+      } else {
+        // Afficher la page de demande de vérification
+        emit(new TransactionSendFormVerificationAskingState(event.command, transaction, this.data()));
+      }
+    } catch (e) {
+      if (e instanceof ApiException) {
+        this.handleApiException(e, emit, event.command);
+      } else {
+        this.logger.e('Unexpected error during transaction send', { error: e });
+        this.emitError(emit, event.command, TransactionError.unknow);
+      }
+    }
+  }
+
+  /** Confirmer le transfert (ou le programmer) */
+  private async onConfirm(event: TransactionSendConfirmEvent, emit: Emitter<TransactionSendState>) {
+    let transaction = event.transaction;
+    emit(new TransactionSendFormSendingState(event.command, transaction, this.data()));
+
+    if (event.command.schedule != null) {
+      // Just schedule
+      try {
+        transaction = await this.transactionsInputPort.schedule(transaction.endToEndId, event.command.schedule);
+        emit(new TransactionSendFormSuccessState(event.command, transaction, this.data()));
+      } catch (e) {
+        if (e instanceof ApiException) this.handleApiException(e, emit, event.command);
+        else this.emitError(emit, event.command, TransactionError.unknow);
+      }
+      return;
+    }
+
+    // Send Now
+    try {
+      const stream = await this.transactionsInputPort.confirm(
+        new TransactionConfirmCommand({
+          endToendId: transaction.endToEndId,
+          confirmationDate: `${new Date().toISOString().substring(0, 23)}Z`,
+          confirmationMethode: event.method,
+          amount: event.command.amount,
+          motif: event.command.motif,
+          latitude: event.command.latitude,
+          longitude: event.command.longitude,
+        }),
+      );
+      stream.listen(
+        (trans) => {
+          if (!this.isClosed) this.add(new TransactionSendResponseEvent(event.command, trans));
+        },
+        (error) => {
+          if (this.isClosed) return;
+          let txError = TransactionError.unknow;
+          if (error instanceof TimeoutException) txError = TransactionError.toujoursInitier;
+          else if (error instanceof ApiException && error.error === ApiError.noInternetConnection) {
+            txError = TransactionError.connection;
+          }
+          this.add(new TransactionSendErrorEvent(event.command, transaction, txError));
+        },
+      );
+    } catch (e) {
+      // (Flutter laisse l'écran en attente dans ce cas.)
+      this.logger.e('Confirmation du transfert', { error: e });
+      this.emitError(emit, event.command, TransactionError.unknow);
+    }
+  }
+
+  /** Lorsqu'une réponse est reçue après l'envoi d'une transaction */
+  private onResponse(event: TransactionSendResponseEvent, emit: Emitter<TransactionSendState>) {
+    const transaction = event.transaction;
+    if (transaction.statut === TransactionStatut.irrevocable) {
+      emit(new TransactionSendFormSuccessState(event.command, transaction, this.data()));
+      try {
+        AppNotifications.transfertEmisStreamController.add({
+          montant: transaction.montant,
+          compte: transaction.compte,
+          alias: transaction.compteAlias,
+        });
+      } catch (e) {
+        this.logger.e('Error adding transfert emis to stream', { error: e });
+      }
+    } else if (transaction.statut === TransactionStatut.initie) {
+      this.emitError(emit, event.command, TransactionError.toujoursInitier);
+    } else if (transaction.statutRaison != null) {
+      this.emitError(emit, event.command, TransactionError.fromCode(transaction.statutRaison));
+    } else {
+      this.emitError(emit, event.command, TransactionError.unknow);
+    }
+  }
+
+  /** Partage de dépense : une demande de paiement par contact */
+  private async onSplitSend(event: TransactionSendSplitSendEvent, emit: Emitter<TransactionSendState>) {
+    emit(new TransactionSendFormVerificationLoadingState(event.commands[0], this.data()));
+    const position = await this.getPosition();
+    if (position == null) {
+      emit(new TransactionSendInitialState());
+      return;
+    }
+    const transactions: Transaction[] = [];
+    const errors: string[] = [];
+    for (const command of event.commands) {
+      command.latitude = position.latitude;
+      command.longitude = position.longitude;
+      try {
+        const transaction = await this.transactionsInputPort.initiate(command);
+        transaction.motif = command.motif?.value;
+        transactions.push(transaction);
+      } catch (e) {
+        this.logger.e(`Erreur d'envoie du paiement partagé à ${command.alias?.value}`, { error: e });
+        errors.push(String(e));
+      }
+    }
+    if (errors.length === 0) {
+      emit(new TransactionSendFormSuccessState(event.commands[0], transactions[0], this.data()));
+    } else {
+      emit(new TransactionSendFormErrorState(event.commands[0], errors.join(', '), this.data()));
+    }
+  }
+
+  /** Centralise l'émission d'une erreur */
+  private emitError(emit: Emitter<TransactionSendState>, command: TransactionSendCommand, error: TransactionError) {
+    emit(new TransactionSendFormErrorState(command, error, this.data()));
+  }
+
+  /** Gère toutes les erreurs API possibles */
+  private handleApiException(e: ApiException, emit: Emitter<TransactionSendState>, command: TransactionSendCommand) {
+    if (e.error === ApiError.noInternetConnection) {
+      return this.emitError(emit, command, TransactionError.connection);
+    }
+    if (e.error === ApiError.notFound) {
+      return this.emitError(emit, command, TransactionError.beneficiaryNotFound);
+    }
+    if (e.error === ApiError.forbidden && e.problem?.invalidParams != null) {
+      switch (e.problem.invalidParams.name) {
+        case 'solde':
+          return this.emitError(emit, command, TransactionError.reservationError);
+        case 'participantPayeur':
+          return this.emitError(emit, command, TransactionError.pspPayeurIndisponible);
+        case 'participantPaye':
+          return this.emitError(emit, command, TransactionError.pspPayeIndisponible);
+        default:
+          return this.emitError(emit, command, TransactionError.unknow);
+      }
+    }
+    if (e.error === ApiError.badRequest && e.problem?.invalidParams?.name === 'client') {
+      return this.emitError(emit, command, TransactionError.invalidBeneficiary);
+    }
+    return this.emitError(emit, command, TransactionError.unknow);
+  }
+
+  /** Position GPS ; demande la permission si besoin, `null` si indisponible */
+  private getPosition(): Promise<Position | null> {
+    return getPositionOrAsk(() => this.permissionInputPort.grantPermission(PermissionType.localisationGPS));
+  }
+}

package/src/modules/transactions/presentation/bloc/transaction_send/transaction_send_event.ts

@@ -0,0 +1,107 @@
+import type { Participant } from '../../../domain/models/participant/participant';
+import type { Transaction } from '../../../domain/models/transaction';
+import type { TransactionError } from '../../../domain/models/transaction_error';
+import type { TransactionSendCommand } from '../../../domain/models/transaction_send/transaction_send_command';
+
+export abstract class TransactionSendEvent {}
+
+export class TransactionSendUpdateStateEvent extends TransactionSendEvent {
+  constructor(readonly params: { solde?: number | null; participants?: Participant[] | null } = {}) {
+    super();
+  }
+}
+
+/** Lister les dernières transactions à afficher */
+export class TransactionSendListRecentsEvent extends TransactionSendEvent {
+  constructor(readonly compte: string) {
+    super();
+  }
+}
+
+/** Recherche par le nom ou l'alias ou dans les contacts */
+export class TransactionSendSearchEvent extends TransactionSendEvent {}
+
+/** Pour afficher le formulaire de transaction */
+export class TransactionSendDisplayFormEvent extends TransactionSendEvent {
+  constructor(readonly command: TransactionSendCommand) {
+    super();
+  }
+}
+
+/** Pour demander le solde du client pour vérification du montant quand c'est un transfert */
+export class TransactionSendCheckSoldeEvent extends TransactionSendEvent {
+  constructor(readonly command: TransactionSendCommand) {
+    super();
+  }
+}
+
+/** Pour valider le formulaire */
+export class TransactionSendFormChangedEvent extends TransactionSendEvent {
+  constructor(readonly command: TransactionSendCommand) {
+    super();
+  }
+}
+
+/** Quand l'utilisateur veut continuer (initier le transfert) */
+export class TransactionSendInitiateEvent extends TransactionSendEvent {
+  constructor(readonly command: TransactionSendCommand) {
+    super();
+  }
+}
+
+/** Quand l'utilisateur veut programmer le transfert */
+export class TransactionSendScheduleEvent extends TransactionSendEvent {
+  constructor(
+    readonly command: TransactionSendCommand,
+    readonly transaction: Transaction,
+  ) {
+    super();
+  }
+}
+
+/** Quand l'utilisateur veut rejeter le transfert */
+export class TransactionSendRejectEvent extends TransactionSendEvent {
+  constructor(readonly command: TransactionSendCommand) {
+    super();
+  }
+}
+
+/** Quand l'utilisateur veut confirmer le transfert */
+export class TransactionSendConfirmEvent extends TransactionSendEvent {
+  constructor(
+    readonly command: TransactionSendCommand,
+    readonly transaction: Transaction,
+    readonly method: string,
+  ) {
+    super();
+  }
+}
+
+/** Quand une réponse à un transfert est reçue */
+export class TransactionSendResponseEvent extends TransactionSendEvent {
+  constructor(
+    readonly command: TransactionSendCommand,
+    readonly transaction: Transaction,
+  ) {
+    super();
+  }
+}
+
+export class TransactionSendErrorEvent extends TransactionSendEvent {
+  constructor(
+    readonly command: TransactionSendCommand,
+    readonly transaction: Transaction,
+    readonly error: TransactionError,
+  ) {
+    super();
+  }
+}
+
+export class TransactionSendSplitSendEvent extends TransactionSendEvent {
+  constructor(
+    readonly commands: TransactionSendCommand[],
+    readonly method: string,
+  ) {
+    super();
+  }
+}

package/src/modules/transactions/presentation/bloc/transaction_send/transaction_send_state.ts

@@ -0,0 +1,111 @@
+import type { PhoneContact } from '../../../../contacts/domain/phone_contact';
+import type { Participant } from '../../../domain/models/participant/participant';
+import type { Transaction } from '../../../domain/models/transaction';
+import type { TransactionListe } from '../../../domain/models/transaction_liste';
+import type { TransactionSendCommand } from '../../../domain/models/transaction_send/transaction_send_command';
+
+export type TransactionSendData = { solde?: number | null; participants?: Participant[] | null };
+
+/**
+ * État du parcours d'envoi. Comme en Flutter, `transactions`,
+ * `participants` et `solde` sont modifiables : ils sont mis à jour en
+ * arrière-plan et conservés d'un état à l'autre.
+ */
+export class TransactionSendState {
+  /** Liste des dernières transactions affichées */
+  transactions?: TransactionListe | null;
+  /** Liste des participants */
+  participants?: Participant[] | null;
+  /** Le solde du client */
+  solde?: number | null;
+
+  constructor(params: TransactionSendData & { transactions?: TransactionListe | null } = {}) {
+    this.transactions = params.transactions;
+    this.participants = params.participants;
+    this.solde = params.solde;
+  }
+}
+
+export class TransactionSendInitialState extends TransactionSendState {
+  readonly contacts?: PhoneContact[] | null;
+
+  constructor(params: TransactionSendData & { transactions?: TransactionListe | null; contacts?: PhoneContact[] | null } = {}) {
+    super(params);
+    this.contacts = params.contacts;
+  }
+}
+
+/** Affiche le formulaire d'envoi d'une transaction */
+export class TransactionSendFormInputState extends TransactionSendState {
+  constructor(
+    readonly command: TransactionSendCommand,
+    data: TransactionSendData = {},
+  ) {
+    super(data);
+  }
+}
+
+/** Pendant que l'on recherche les données à vérifier */
+export class TransactionSendFormVerificationLoadingState extends TransactionSendState {
+  constructor(
+    readonly command: TransactionSendCommand,
+    data: TransactionSendData = {},
+  ) {
+    super(data);
+  }
+}
+
+/** Affiche les données de vérification */
+export class TransactionSendFormVerificationAskingState extends TransactionSendState {
+  constructor(
+    readonly command: TransactionSendCommand,
+    readonly transaction: Transaction,
+    data: TransactionSendData = {},
+  ) {
+    super(data);
+  }
+}
+
+/** Affiche le formulaire de programmation d'une transaction */
+export class TransactionSendFormScheduleState extends TransactionSendState {
+  constructor(
+    readonly command: TransactionSendCommand,
+    readonly transaction: Transaction,
+    data: TransactionSendData = {},
+  ) {
+    super(data);
+  }
+}
+
+/** Pendant que l'on confirme la transaction */
+export class TransactionSendFormSendingState extends TransactionSendState {
+  constructor(
+    readonly command: TransactionSendCommand,
+    readonly transaction: Transaction,
+    data: TransactionSendData = {},
+  ) {
+    super(data);
+  }
+}
+
+/** Transaction réussie */
+export class TransactionSendFormSuccessState extends TransactionSendState {
+  constructor(
+    readonly command: TransactionSendCommand,
+    readonly transaction: Transaction,
+    data: TransactionSendData = {},
+  ) {
+    super(data);
+  }
+}
+
+/** Transaction échouée */
+export class TransactionSendFormErrorState extends TransactionSendState {
+  constructor(
+    readonly command: TransactionSendCommand,
+    readonly error: string,
+    data: TransactionSendData = {},
+  ) {
+    super(data);
+  }
+}