@pi-spi/app 0.0.0-stage → 1.2.1

package/src/modules/transactions/presentation/bloc/transaction_cancel/transaction_cancel_bloc.ts

@@ -0,0 +1,174 @@
+import { ApiError, ApiException } from '../../../../../core/api';
+import { Bloc, type Emitter } from '../../../../../core/bloc';
+import { Logger } from '../../../../../core/logger';
+import { TimeoutException } from '../../../../../core/sse';
+import type { Unsubscribe } from '../../../../../core/stream';
+import type { CompteInputPort } from '../../../../compte/ports/input/compte_input_port';
+import { TransactionStatut, type Transaction } from '../../../domain/models/transaction';
+import { TransactionError } from '../../../domain/models/transaction_error';
+import { TransactionRejectReason } from '../../../domain/models/transaction_reject_reason';
+import type { TransactionInputPort } from '../../../ports/input/transaction_input_port';
+import {
+  TransactionCancelAcceptErrorEvent,
+  TransactionCancelAcceptEvent,
+  TransactionCancelAcceptResponseEvent,
+  TransactionCancelFetchEvent,
+  TransactionCancelRefreshSoldeEvent,
+  TransactionCancelRejectEvent,
+  type TransactionCancelEvent,
+} from './transaction_cancel_event';
+import {
+  TransactionCancelDetailsState,
+  TransactionCancelInitialState,
+  TransactionCancelLoadingState,
+  TransactionCancelReponseState,
+  type TransactionCancelState,
+} from './transaction_cancel_state';
+
+/** Demande d'annulation reçue sur un transfert : l'accepter (retour des fonds) ou la rejeter. */
+export class TransactionCancelBloc extends Bloc<TransactionCancelEvent, TransactionCancelState> {
+  readonly logger = new Logger();
+  private soldeSubscription?: Unsubscribe;
+
+  constructor(
+    readonly transactionInputPort: TransactionInputPort,
+    /** Info compte solde */
+    readonly compteInputPort: CompteInputPort,
+    readonly compte: string,
+    readonly endToEndId: string,
+  ) {
+    super(new TransactionCancelInitialState(endToEndId, 0));
+    // Pour récupérer une demande d'annulation
+    this.on(TransactionCancelFetchEvent, (_e, emit) => this.onFetch(emit));
+    this.on(TransactionCancelRefreshSoldeEvent, (e, emit) =>
+      emit(new TransactionCancelDetailsState(this.endToEndId, e.transaction, e.solde)),
+    );
+    // Pour accepter une demande d'annulation
+    this.on(TransactionCancelAcceptEvent, (e, emit) => this.onAccept(e, emit));
+    this.on(TransactionCancelAcceptResponseEvent, (e, emit) => {
+      const tx = e.transaction;
+      if (tx.retourStatutRaison != null) this.emitCancelError(emit, tx, TransactionError.fromCode(tx.retourStatutRaison));
+      else emit(new TransactionCancelReponseState(tx.endToEndId, tx, this.state.solde));
+    });
+    this.on(TransactionCancelAcceptErrorEvent, (e, emit) => this.emitCancelError(emit, e.transaction, e.error));
+    // Pour rejeter une demande d'annulation
+    this.on(TransactionCancelRejectEvent, (e, emit) => this.onReject(e, emit));
+  }
+
+  override close(): void {
+    this.soldeSubscription?.();
+    super.close();
+  }
+
+  /** Pour récupérer les infos sur la demande d'annulation */
+  private async onFetch(emit: Emitter<TransactionCancelState>): Promise<void> {
+    emit(new TransactionCancelInitialState(this.endToEndId, this.state.solde));
+    try {
+      const tx = await this.transactionInputPort.get(this.endToEndId);
+      if (
+        tx.annulationStatut === TransactionStatut.initie &&
+        (tx.retourStatut == null || tx.retourStatut !== TransactionStatut.irrevocable)
+      ) {
+        // Le solde est nécessaire pour accepter (retourner les fonds)
+        const streamSolde = await this.compteInputPort.getSolde(this.compte);
+        this.soldeSubscription?.();
+        this.soldeSubscription = streamSolde.listen((solde) => {
+          if (!this.isClosed && solde != null) this.add(new TransactionCancelRefreshSoldeEvent(solde, tx));
+        });
+      } else {
+        emit(new TransactionCancelDetailsState(this.endToEndId, tx, this.state.solde));
+      }
+    } catch (e) {
+      this.logger.e('Erreur Fetching details canceletion => ', { error: e });
+      emit(new TransactionCancelDetailsState(this.endToEndId, null, this.state.solde));
+    }
+  }
+
+  /** Pour rejeter la demande d'annulation */
+  private async onReject(event: TransactionCancelRejectEvent, emit: Emitter<TransactionCancelState>): Promise<void> {
+    let tx = event.transaction;
+    emit(new TransactionCancelLoadingState(tx.endToEndId, tx, this.state.solde));
+    try {
+      tx = await this.transactionInputPort.reject(tx, TransactionRejectReason.autre);
+      emit(new TransactionCancelReponseState(tx.endToEndId, tx, this.state.solde));
+    } catch (e) {
+      if (e instanceof ApiException) this.handleCancelApiException(e, emit, tx);
+      else {
+        this.logger.e('Unexpected error during return funds', { error: e });
+        this.emitCancelError(emit, tx, TransactionError.unknow);
+      }
+    }
+  }
+
+  /** Pour accepter la demande d'annulation : retour des fonds */
+  private async onAccept(event: TransactionCancelAcceptEvent, emit: Emitter<TransactionCancelState>): Promise<void> {
+    const tx = event.transaction;
+    emit(new TransactionCancelLoadingState(event.endToEndId, tx, this.state.solde));
+    try {
+      const stream = await this.transactionInputPort.returnFunds(tx);
+      stream.listen(
+        (trans) => {
+          if (!this.isClosed) this.add(new TransactionCancelAcceptResponseEvent(trans));
+        },
+        (error) => {
+          if (this.isClosed) return;
+          // Écart volontaire : le refus du serveur (403 solde insuffisant,
+          // délai dépassé, déjà retourné...) arrive par le flux ; le SDK
+          // Flutter l'affichait comme une erreur inconnue.
+          this.add(
+            new TransactionCancelAcceptErrorEvent(
+              tx,
+              error instanceof TimeoutException
+                ? TransactionError.toujoursInitier
+                : error instanceof ApiException
+                  ? this.apiExceptionError(error)
+                  : TransactionError.unknow,
+            ),
+          );
+        },
+      );
+    } catch (e) {
+      if (e instanceof ApiException) this.handleCancelApiException(e, emit, tx);
+      else {
+        this.logger.e('Unexpected error during return funds', { error: e });
+        this.emitCancelError(emit, tx, TransactionError.unknow);
+      }
+    }
+  }
+
+  /** Centralise l'émission d'une erreur */
+  private emitCancelError(emit: Emitter<TransactionCancelState>, transaction: Transaction, error: TransactionError): void {
+    emit(new TransactionCancelReponseState(transaction.endToEndId, transaction, this.state.solde, error));
+  }
+
+  /** Gère toutes les erreurs API possibles pour un retour de fonds */
+  private handleCancelApiException(e: ApiException, emit: Emitter<TransactionCancelState>, transaction: Transaction): void {
+    this.emitCancelError(emit, transaction, this.apiExceptionError(e));
+  }
+
+  /** Erreur à afficher pour une erreur API d'un retour de fonds */
+  private apiExceptionError(e: ApiException): TransactionError {
+    if (e.error === ApiError.noInternetConnection) return TransactionError.connection;
+    if (e.error === ApiError.notFound) return TransactionError.beneficiaryNotFound;
+    if (e.error === ApiError.forbidden && e.problem?.invalidParams != null) {
+      switch (e.problem.invalidParams.name) {
+        case 'solde':
+          return TransactionError.reservationError;
+        case 'date':
+          return TransactionError.delaiDepasse;
+        case 'statut':
+          return TransactionError.dejaRetourne;
+        case 'participantPayeur':
+          return TransactionError.pspPayeurIndisponible;
+        case 'participantPaye':
+          return TransactionError.pspPayeIndisponible;
+        default:
+          return TransactionError.unknow;
+      }
+    }
+    if (e.error === ApiError.badRequest && e.problem?.invalidParams?.client != null) {
+      return TransactionError.invalidBeneficiary;
+    }
+    return TransactionError.unknow;
+  }
+}

package/src/modules/transactions/presentation/bloc/transaction_cancel/transaction_cancel_event.ts

@@ -0,0 +1,51 @@
+import type { Transaction } from '../../../domain/models/transaction';
+import type { TransactionError } from '../../../domain/models/transaction_error';
+
+export abstract class TransactionCancelEvent {}
+
+export class TransactionCancelFetchEvent extends TransactionCancelEvent {
+  constructor(readonly endToEndId: string) {
+    super();
+  }
+}
+
+export class TransactionCancelRefreshSoldeEvent extends TransactionCancelEvent {
+  constructor(
+    readonly solde: number,
+    readonly transaction: Transaction,
+  ) {
+    super();
+  }
+}
+
+/** Accepter la demande d'annulation (retour des fonds) */
+export class TransactionCancelAcceptEvent extends TransactionCancelEvent {
+  constructor(
+    readonly endToEndId: string,
+    readonly transaction: Transaction,
+  ) {
+    super();
+  }
+}
+
+export class TransactionCancelAcceptResponseEvent extends TransactionCancelEvent {
+  constructor(readonly transaction: Transaction) {
+    super();
+  }
+}
+
+export class TransactionCancelAcceptErrorEvent extends TransactionCancelEvent {
+  constructor(
+    readonly transaction: Transaction,
+    readonly error: TransactionError,
+  ) {
+    super();
+  }
+}
+
+/** Rejeter la demande d'annulation */
+export class TransactionCancelRejectEvent extends TransactionCancelEvent {
+  constructor(readonly transaction: Transaction) {
+    super();
+  }
+}

package/src/modules/transactions/presentation/bloc/transaction_cancel/transaction_cancel_state.ts

@@ -0,0 +1,42 @@
+import type { Transaction } from '../../../domain/models/transaction';
+import type { TransactionError } from '../../../domain/models/transaction_error';
+
+export abstract class TransactionCancelState {
+  constructor(
+    readonly endToEndId: string,
+    readonly solde: number,
+  ) {}
+}
+
+export class TransactionCancelInitialState extends TransactionCancelState {}
+
+export class TransactionCancelDetailsState extends TransactionCancelState {
+  constructor(
+    endToEndId: string,
+    readonly transaction: Transaction | null,
+    solde: number,
+  ) {
+    super(endToEndId, solde);
+  }
+}
+
+export class TransactionCancelLoadingState extends TransactionCancelState {
+  constructor(
+    endToEndId: string,
+    readonly transaction: Transaction,
+    solde: number,
+  ) {
+    super(endToEndId, solde);
+  }
+}
+
+export class TransactionCancelReponseState extends TransactionCancelState {
+  constructor(
+    endToEndId: string,
+    readonly transaction: Transaction,
+    solde: number,
+    readonly error: TransactionError | null = null,
+  ) {
+    super(endToEndId, solde);
+  }
+}

package/src/modules/transactions/presentation/bloc/transaction_details/transaction_details_bloc.ts

@@ -0,0 +1,221 @@
+import { ApiError, ApiException } from '../../../../../core/api';
+import { Bloc, type Emitter } from '../../../../../core/bloc';
+import { Logger } from '../../../../../core/logger';
+import { TimeoutException } from '../../../../../core/sse';
+import type { Unsubscribe } from '../../../../../core/stream';
+import type { CompteInputPort } from '../../../../compte/ports/input/compte_input_port';
+import { TransactionSens, type Transaction } from '../../../domain/models/transaction';
+import { TransactionError } from '../../../domain/models/transaction_error';
+import type { ParticipantInputPort } from '../../../ports/input/participant_input_port';
+import type { TransactionInputPort } from '../../../ports/input/transaction_input_port';
+import {
+  TransactionCancelSendEvent,
+  TransactionCategorieUpdateEvent,
+  TransactionDetailsFetchEvent,
+  TransactionDetailsRefreshSoldeEvent,
+  TransactionReturnErrorEvent,
+  TransactionReturnResponseEvent,
+  TransactionReturnSendEvent,
+  type TransactionDetailsEvent,
+} from './transaction_details_event';
+import {
+  TransactionDetailsCancelLoadingState,
+  TransactionDetailsCancelState,
+  TransactionDetailsDisplayState,
+  TransactionDetailsInitialState,
+  TransactionDetailsReturnLoadingState,
+  TransactionDetailsReturnState,
+  type TransactionDetailsData,
+  type TransactionDetailsState,
+} from './transaction_details_state';
+
+/**
+ * Détail d'une transaction : affichage (local puis serveur), catégorie,
+ * retour des fonds d'un transfert reçu et demande d'annulation.
+ */
+export class TransactionDetailsBloc extends Bloc<TransactionDetailsEvent, TransactionDetailsState> {
+  readonly logger = new Logger();
+  private soldeSubscription?: Unsubscribe;
+
+  constructor(
+    readonly transactionInputPort: TransactionInputPort,
+    readonly participantInputPort: ParticipantInputPort,
+    /** Info compte solde */
+    readonly compteInputPort: CompteInputPort,
+    readonly compte: string,
+  ) {
+    super(new TransactionDetailsInitialState(null, { solde: 0, participants: [] }));
+    // Pour récupérer les détails d'une transaction
+    this.on(TransactionDetailsFetchEvent, (e, emit) => this.onFetch(e, emit));
+    this.on(TransactionDetailsRefreshSoldeEvent, (e, emit) =>
+      emit(new TransactionDetailsDisplayState(this.state.transaction, { ...this.data(), solde: e.solde })),
+    );
+    // Modifier la catégorie
+    this.on(TransactionCategorieUpdateEvent, (e, emit) => this.onCategorieUpdate(e, emit));
+    // Retourner les fonds d'un transfert reçu
+    this.on(TransactionReturnSendEvent, (e, emit) => this.onReturnSend(e, emit));
+    this.on(TransactionReturnResponseEvent, (e, emit) => this.onReturnResponse(e, emit));
+    this.on(TransactionReturnErrorEvent, (e, emit) => this.emitReturnError(emit, e.transaction, e.error));
+    // Demander l'annulation
+    this.on(TransactionCancelSendEvent, (e, emit) => this.onCancelSend(e, emit));
+  }
+
+  override close(): void {
+    this.soldeSubscription?.();
+    super.close();
+  }
+
+  private data(): TransactionDetailsData {
+    return { solde: this.state.solde, participants: this.state.participants };
+  }
+
+  /** Pour récupérer les infos sur la transaction : en local, puis sur le serveur */
+  private async onFetch(event: TransactionDetailsFetchEvent, emit: Emitter<TransactionDetailsState>): Promise<void> {
+    let transaction: Transaction | null = null;
+    emit(new TransactionDetailsInitialState(this.state.transaction, this.data()));
+    try {
+      const id = event.transaction?.endToEndId ?? event.endToEndId;
+      if (event.transaction != null) {
+        transaction = event.transaction;
+        emit(new TransactionDetailsDisplayState(event.transaction, this.data()));
+      }
+
+      // Récupérer en local
+      const [txLocal, participantsLocal] = await Promise.all([
+        this.transactionInputPort.fetch(id),
+        this.participantInputPort.list(),
+      ]);
+      if (txLocal != null) {
+        transaction = txLocal;
+        emit(new TransactionDetailsDisplayState(txLocal, { solde: this.state.solde, participants: participantsLocal }));
+      }
+
+      // Récupérer en remote
+      try {
+        const [txRemote, participants] = await Promise.all([
+          this.transactionInputPort.get(id),
+          this.participantInputPort.search(),
+        ]);
+        transaction = txRemote;
+        emit(new TransactionDetailsDisplayState(txRemote, { solde: this.state.solde, participants }));
+      } catch {
+        // On garde la version locale
+      }
+
+      // Solde nécessaire au retour des fonds d'un transfert reçu
+      if (transaction != null && transaction.sens === TransactionSens.credit && !transaction.isRetourOk()) {
+        const streamSolde = await this.compteInputPort.getSolde(this.compte);
+        this.soldeSubscription?.();
+        this.soldeSubscription = streamSolde.listen((solde) => {
+          if (!this.isClosed && solde != null) this.add(new TransactionDetailsRefreshSoldeEvent(solde));
+        });
+      }
+    } catch (e) {
+      this.logger.e('Erreur recuperation transafert => ', { error: e });
+      emit(new TransactionDetailsDisplayState(transaction, this.data()));
+    }
+  }
+
+  /** Pour mettre à jour la catégorie de transaction */
+  private async onCategorieUpdate(event: TransactionCategorieUpdateEvent, emit: Emitter<TransactionDetailsState>) {
+    const tx = event.transaction;
+    tx.categorie = event.categorie.id;
+    await this.transactionInputPort.update(tx);
+    emit(new TransactionDetailsDisplayState(tx, this.data()));
+  }
+
+  /** Quand on confirme l'envoi du retour de fonds */
+  private async onReturnSend(event: TransactionReturnSendEvent, emit: Emitter<TransactionDetailsState>) {
+    const tx = event.transaction;
+    emit(new TransactionDetailsReturnLoadingState(tx, this.data()));
+    try {
+      const stream = await this.transactionInputPort.returnFunds(tx);
+      stream.listen(
+        (trans) => {
+          if (!this.isClosed) this.add(new TransactionReturnResponseEvent(trans));
+        },
+        (error) => {
+          if (this.isClosed) return;
+          if (error instanceof TimeoutException) {
+            this.add(new TransactionReturnErrorEvent(tx, TransactionError.toujoursInitier));
+          } else if (error instanceof ApiException && error.error === ApiError.noInternetConnection) {
+            this.add(new TransactionReturnErrorEvent(tx, TransactionError.connection));
+          } else {
+            this.add(new TransactionReturnErrorEvent(tx, TransactionError.unknow));
+          }
+        },
+      );
+    } catch (e) {
+      if (e instanceof ApiException) {
+        this.handleReturnApiException(e, emit, tx);
+      } else {
+        this.logger.e('Unexpected error during return funds', { error: e });
+        this.emitReturnError(emit, tx, TransactionError.unknow);
+      }
+    }
+  }
+
+  /** Quand on reçoit la réponse d'un retour de fonds */
+  private onReturnResponse(event: TransactionReturnResponseEvent, emit: Emitter<TransactionDetailsState>) {
+    const tx = event.transaction;
+    if (tx.retourDate != null) {
+      emit(new TransactionDetailsReturnState(tx, null, this.data()));
+    } else if (tx.retourStatutRaison != null) {
+      this.emitReturnError(emit, tx, TransactionError.fromCode(tx.retourStatutRaison));
+    } else {
+      this.emitReturnError(emit, tx, TransactionError.unknow);
+    }
+  }
+
+  /** Quand on confirme l'envoi de la demande d'annulation */
+  private async onCancelSend(event: TransactionCancelSendEvent, emit: Emitter<TransactionDetailsState>) {
+    let tx = event.transaction;
+    emit(new TransactionDetailsCancelLoadingState(tx, this.data()));
+    try {
+      tx = await this.transactionInputPort.cancel(tx, event.reason);
+      emit(new TransactionDetailsCancelState(tx, null, this.data()));
+    } catch (e) {
+      if (e instanceof ApiException && e.error === ApiError.noInternetConnection) {
+        emit(new TransactionDetailsCancelState(tx, TransactionError.connection, this.data()));
+      } else {
+        if (!(e instanceof ApiException)) this.logger.e('Unexpected error during cancel', { error: e });
+        emit(new TransactionDetailsCancelState(tx, TransactionError.unknow, this.data()));
+      }
+    }
+  }
+
+  /** Centralise l'émission d'une erreur de retour */
+  private emitReturnError(emit: Emitter<TransactionDetailsState>, transaction: Transaction, error: TransactionError) {
+    emit(new TransactionDetailsReturnState(transaction, error, this.data()));
+  }
+
+  /** Gère toutes les erreurs API possibles pour un retour de fonds */
+  private handleReturnApiException(e: ApiException, emit: Emitter<TransactionDetailsState>, transaction: Transaction) {
+    if (e.error === ApiError.noInternetConnection) {
+      return this.emitReturnError(emit, transaction, TransactionError.connection);
+    }
+    if (e.error === ApiError.notFound) {
+      return this.emitReturnError(emit, transaction, TransactionError.beneficiaryNotFound);
+    }
+    if (e.error === ApiError.forbidden && e.problem?.invalidParams != null) {
+      switch (e.problem.invalidParams.name) {
+        case 'solde':
+          return this.emitReturnError(emit, transaction, TransactionError.reservationError);
+        case 'date':
+          return this.emitReturnError(emit, transaction, TransactionError.delaiDepasse);
+        case 'statut':
+          return this.emitReturnError(emit, transaction, TransactionError.dejaRetourne);
+        case 'participantPayeur':
+          return this.emitReturnError(emit, transaction, TransactionError.pspPayeurIndisponible);
+        case 'participantPaye':
+          return this.emitReturnError(emit, transaction, TransactionError.pspPayeIndisponible);
+        default:
+          return this.emitReturnError(emit, transaction, TransactionError.unknow);
+      }
+    }
+    if (e.error === ApiError.badRequest && e.problem?.invalidParams?.client != null) {
+      return this.emitReturnError(emit, transaction, TransactionError.invalidBeneficiary);
+    }
+    return this.emitReturnError(emit, transaction, TransactionError.unknow);
+  }
+}

package/src/modules/transactions/presentation/bloc/transaction_details/transaction_details_event.ts

@@ -0,0 +1,61 @@
+import type { Categorie } from '../../../../categorie/domain/models/categorie';
+import type { Transaction } from '../../../domain/models/transaction';
+import type { TransactionCancelReason } from '../../../domain/models/transaction_cancel_reason';
+import type { TransactionError } from '../../../domain/models/transaction_error';
+
+export abstract class TransactionDetailsEvent {}
+
+export class TransactionDetailsFetchEvent extends TransactionDetailsEvent {
+  constructor(
+    readonly endToEndId: string,
+    readonly transaction: Transaction | null,
+  ) {
+    super();
+  }
+}
+
+export class TransactionDetailsRefreshSoldeEvent extends TransactionDetailsEvent {
+  constructor(readonly solde: number) {
+    super();
+  }
+}
+
+export class TransactionCategorieUpdateEvent extends TransactionDetailsEvent {
+  constructor(
+    readonly transaction: Transaction,
+    readonly categorie: Categorie,
+  ) {
+    super();
+  }
+}
+
+export class TransactionReturnSendEvent extends TransactionDetailsEvent {
+  constructor(readonly transaction: Transaction) {
+    super();
+  }
+}
+
+export class TransactionReturnResponseEvent extends TransactionDetailsEvent {
+  constructor(readonly transaction: Transaction) {
+    super();
+  }
+}
+
+/** Demande d'annulation */
+export class TransactionCancelSendEvent extends TransactionDetailsEvent {
+  constructor(
+    readonly transaction: Transaction,
+    readonly reason: TransactionCancelReason,
+  ) {
+    super();
+  }
+}
+
+export class TransactionReturnErrorEvent extends TransactionDetailsEvent {
+  constructor(
+    readonly transaction: Transaction,
+    readonly error: TransactionError,
+  ) {
+    super();
+  }
+}

package/src/modules/transactions/presentation/bloc/transaction_details/transaction_details_state.ts

@@ -0,0 +1,46 @@
+import type { Participant } from '../../../domain/models/participant/participant';
+import type { Transaction } from '../../../domain/models/transaction';
+import type { TransactionError } from '../../../domain/models/transaction_error';
+
+export type TransactionDetailsData = { solde: number; participants: Participant[] };
+
+export abstract class TransactionDetailsState {
+  readonly solde: number;
+  readonly participants: Participant[];
+
+  constructor(
+    readonly transaction: Transaction | null,
+    data: TransactionDetailsData,
+  ) {
+    this.solde = data.solde;
+    this.participants = data.participants;
+  }
+}
+
+export class TransactionDetailsInitialState extends TransactionDetailsState {}
+
+export class TransactionDetailsDisplayState extends TransactionDetailsState {}
+
+export class TransactionDetailsReturnLoadingState extends TransactionDetailsState {}
+
+export class TransactionDetailsReturnState extends TransactionDetailsState {
+  constructor(
+    transaction: Transaction | null,
+    readonly error: TransactionError | null,
+    data: TransactionDetailsData,
+  ) {
+    super(transaction, data);
+  }
+}
+
+export class TransactionDetailsCancelLoadingState extends TransactionDetailsState {}
+
+export class TransactionDetailsCancelState extends TransactionDetailsState {
+  constructor(
+    transaction: Transaction | null,
+    readonly error: TransactionError | null,
+    data: TransactionDetailsData,
+  ) {
+    super(transaction, data);
+  }
+}

package/src/modules/transactions/presentation/bloc/transaction_recents/transaction_recents_bloc.ts

@@ -0,0 +1,66 @@
+import { Bloc, type Emitter } from '../../../../../core/bloc';
+import { Logger } from '../../../../../core/logger';
+import { AppNotifications } from '../../../../../core/notifications';
+import type { Unsubscribe } from '../../../../../core/stream';
+import { ListeMeta } from '../../../../../shared/models/liste_meta';
+import type { ConfigBloc } from '../../../../config/adapters/ui/bloc/config_bloc';
+import { ConfigKey } from '../../../../config/domain/models/config_keys';
+import { NotificationType } from '../../../../notification/domain/models/notification_type';
+import { TransactionListe } from '../../../domain/models/transaction_liste';
+import type { TransactionInputPort } from '../../../ports/input/transaction_input_port';
+import { TransactionRecentsListEvent, type TransactionRecentsEvent } from './transaction_recents_event';
+import {
+  TransactionRecentsInitialState,
+  TransactionRecentsListState,
+  type TransactionRecentsState,
+} from './transaction_recents_state';
+
+/** Dernières transactions du compte (d'abord la copie locale, puis le serveur). */
+export class TransactionRecentsBloc extends Bloc<TransactionRecentsEvent, TransactionRecentsState> {
+  readonly logger = new Logger();
+  readonly defaultSize = 3;
+  private readonly notificationSubscription: Unsubscribe;
+
+  constructor(
+    /** Bloc de gestion de la config */
+    readonly configBloc: ConfigBloc,
+    readonly transactionsInputPort: TransactionInputPort,
+    /** le compte de l'utilisateur */
+    readonly compte: string,
+  ) {
+    super(new TransactionRecentsInitialState(new TransactionListe([], new ListeMeta({ total: 0, limit: 3 }))));
+    // Pour récupérer la liste
+    this.on(TransactionRecentsListEvent, (_e, emit) => this.onTransactionRecentsListEvent(emit));
+
+    // Rafraîchir à chaque transfert reçu ou émis
+    this.notificationSubscription = AppNotifications.eventStreamController.stream.listen((event) => {
+      if (event.type === NotificationType.transfertRecu || event.type === NotificationType.transfertEmis) {
+        if (!this.isClosed) this.add(new TransactionRecentsListEvent());
+      }
+    });
+  }
+
+  close(): void {
+    this.notificationSubscription();
+    super.close();
+  }
+
+  /** Quand on demande la liste des transactions */
+  private async onTransactionRecentsListEvent(emit: Emitter<TransactionRecentsState>): Promise<void> {
+    try {
+      // Nombre de transactions récentes à afficher (paramètre)
+      const nbItemsParam = this.configBloc.getParamValue(ConfigKey.transactionsRecentNbItems);
+      const nbItems = nbItemsParam != null ? parseInt(nbItemsParam, 10) : this.defaultSize;
+
+      // Les derniers éléments enregistrés en local
+      const liste = await this.transactionsInputPort.list({ compte: this.compte, limit: nbItems });
+      emit(new TransactionRecentsListState(liste));
+
+      // Puis les nouvelles transactions du serveur
+      const recents = await this.transactionsInputPort.search({ compte: this.compte, limit: nbItems });
+      emit(new TransactionRecentsListState(recents));
+    } catch (e) {
+      this.logger.e('Recuperer liste transaction recents error =>', { error: e });
+    }
+  }
+}

package/src/modules/transactions/presentation/bloc/transaction_recents/transaction_recents_event.ts

@@ -0,0 +1,3 @@
+export class TransactionRecentsEvent {}
+
+export class TransactionRecentsListEvent extends TransactionRecentsEvent {}

package/src/modules/transactions/presentation/bloc/transaction_recents/transaction_recents_state.ts

@@ -0,0 +1,11 @@
+import type { TransactionListe } from '../../../domain/models/transaction_liste';
+
+export class TransactionRecentsState {
+  constructor(readonly transactions: TransactionListe) {}
+}
+
+export class TransactionRecentsInitialState extends TransactionRecentsState {}
+
+export class TransactionRecentsLoadingState extends TransactionRecentsState {}
+
+export class TransactionRecentsListState extends TransactionRecentsState {}