@pi-spi/app 0.0.0-stage → 1.2.0

package/src/modules/alias/presentation/bloc/alias_bloc.ts

@@ -0,0 +1,313 @@
+import { ApiError, ApiException } from '../../../../core/api';
+import { Bloc, type Emitter } from '../../../../core/bloc';
+import { Logger } from '../../../../core/logger';
+import {
+  AliasInvalidOtpException,
+  AliasNotAvailableException,
+  AliasRetrieveException,
+} from '../../domain/exceptions/alias_exceptions';
+import { AliasCreateCommand } from '../../domain/models/alias_create_command';
+import { AliasError } from '../../domain/models/alias_error';
+import { AliasType } from '../../domain/models/alias_type';
+import type { AliasInputPort } from '../../ports/input/alias_input_port';
+import {
+  AliasClaimAskEvent,
+  AliasClaimFetchEvent,
+  AliasClaimRespondEvent,
+  AliasDeleteEvent,
+  AskPhoneNumberVerificationEvent,
+  CheckPhoneNumberVerificationEvent,
+  CreateAliasMBNOEvent,
+  CreateAliasMBNOValidationEvent,
+  CreateAliasSHIDEvent,
+  FetchAliasEvent,
+  type AliasEvent,
+} from './alias_event';
+import {
+  AliasClaimAskingErrorState,
+  AliasClaimAskingState,
+  AliasClaimAskingSuccessState,
+  AliasClaimFetchingState,
+  AliasClaimHandlingErrorState,
+  AliasClaimHandlingLoadingState,
+  AliasClaimHandlingOtpSentState,
+  AliasClaimHandlingState,
+  AliasClaimHandlingSuccessState,
+  AliasClaimNotFoundState,
+  AliasCreatingState,
+  AliasCreationErrorState,
+  AliasDeleteErrorState,
+  AliasDeletingState,
+  AliasExistState,
+  AliasFetchErrorState,
+  AliasInitialState,
+  AliasMBNOCreationState,
+  AliasMBNOVerificationState,
+  AliasNotExistState,
+  type AliasState,
+} from './alias_state';
+
+export class AliasBloc extends Bloc<AliasEvent, AliasState> {
+  readonly logger = new Logger();
+
+  constructor(readonly aliasInputPort: AliasInputPort) {
+    super(new AliasInitialState());
+    // Quand on demande la recupération de l'alias
+    this.on(FetchAliasEvent, (e, emit) => this.onFetchAliasEvent(e, emit));
+    // Quand on demande la création d'un alias de type SHID
+    this.on(CreateAliasSHIDEvent, (e, emit) => this.onCreateAliasSHIDEvent(e, emit));
+    // Quand on demande la création d'un alias de type MBNO
+    this.on(CreateAliasMBNOEvent, (e, emit) =>
+      emit(new AliasMBNOCreationState(new AliasCreateCommand({ type: AliasType.mbno, compte: e.compte }))),
+    );
+    // Quand on demande la suppression d'un alias
+    this.on(AliasDeleteEvent, (e, emit) => this.onAliasDeleteEvent(e, emit));
+    // Quand l'utilisateur saisit son numéro de téléphone et que le système
+    // tente de valider le format
+    this.on(CreateAliasMBNOValidationEvent, (e, emit) => {
+      const form = e.values;
+      form.isValid();
+      emit(new AliasMBNOCreationState(form));
+    });
+    // Quand on envoie un code de vérification à un numéro de téléphone
+    this.on(AskPhoneNumberVerificationEvent, (e, emit) => this.onAskPhoneNumberVerificationEvent(e, emit));
+    // Quand on verifie le code de vérification envoyé à un numéro de téléphone
+    this.on(CheckPhoneNumberVerificationEvent, (e, emit) => this.onCheckPhoneNumberVerificationEvent(e, emit));
+    // Revendications
+    this.on(AliasClaimAskEvent, (e, emit) => this.onAliasClaimAskEvent(e, emit));
+    this.on(AliasClaimFetchEvent, (e, emit) => this.onAliasClaimFetchEvent(e, emit));
+    this.on(AliasClaimRespondEvent, (e, emit) => this.onAliasClaimRespondEvent(e, emit));
+  }
+
+  /**
+   * Demande l'alias de [compte] et attend la réponse qui concerne **ce**
+   * compte : `AliasExistState`, `AliasNotExistState` ou
+   * `AliasFetchErrorState`. Les états émis entre-temps pour un autre compte
+   * (ex. réponse tardive d'un swipe précédent dans le carrousel de
+   * l'accueil) sont ignorés.
+   */
+  fetchFor(compte: string): Promise<AliasState> {
+    // Abonnement avant l'ajout de l'événement, pour ne rien rater.
+    const result = new Promise<AliasState>((resolve) => {
+      const unsubscribe = this.stream.listen((state) => {
+        if (
+          (state instanceof AliasExistState && state.alias.compte === compte) ||
+          (state instanceof AliasNotExistState && state.compte === compte) ||
+          (state instanceof AliasFetchErrorState && state.compte === compte)
+        ) {
+          unsubscribe();
+          resolve(state);
+        }
+      });
+    });
+    this.add(new FetchAliasEvent(compte));
+    return result;
+  }
+
+  /** Quand on demande l'alias de l'utilisateur connecte */
+  private async onFetchAliasEvent(event: FetchAliasEvent, emit: Emitter<AliasState>): Promise<void> {
+    try {
+      const alias = await this.aliasInputPort.recuperer(event.compte);
+      // `null` = 404 : le compte n'a vraiment pas d'alias.
+      emit(alias != null ? new AliasExistState(alias) : new AliasNotExistState({ compte: event.compte }));
+    } catch (e) {
+      if (!(e instanceof AliasRetrieveException)) throw e;
+      // Le serveur n'a pas pu répondre (réseau, 5xx...) : on se rabat sur
+      // l'alias en cache s'il y en a un. Sinon, c'est une erreur — surtout
+      // pas "pas d'alias", qui proposerait d'en créer un à un client qui en
+      // a peut-être déjà un.
+      if (e.alias != null) {
+        emit(new AliasExistState(e.alias));
+      } else {
+        emit(
+          new AliasFetchErrorState(
+            event.compte,
+            e.error === ApiError.noInternetConnection || e.error === ApiError.timeOut
+              ? AliasError.connection
+              : AliasError.unknow,
+          ),
+        );
+      }
+    }
+  }
+
+  /** Suppression d'un alias */
+  private async onAliasDeleteEvent(event: AliasDeleteEvent, emit: Emitter<AliasState>): Promise<void> {
+    emit(new AliasDeletingState());
+    try {
+      await this.aliasInputPort.supprimer(event.alias.cle);
+      emit(new AliasNotExistState({ compte: event.alias.compte }));
+    } catch {
+      emit(new AliasDeleteErrorState('Error'));
+      emit(new AliasExistState(event.alias));
+    }
+  }
+
+  /** Quand on demande la création d'un alias de type SHID */
+  private async onCreateAliasSHIDEvent(event: CreateAliasSHIDEvent, emit: Emitter<AliasState>): Promise<void> {
+    const aliasC = new AliasCreateCommand({ type: AliasType.shid, compte: event.compte });
+    emit(new AliasCreatingState(aliasC));
+    try {
+      const alias = await this.aliasInputPort.creer(aliasC);
+      emit(new AliasExistState(alias));
+    } catch (e) {
+      this.logger.e('Erreur création SHID', { error: e });
+      if (e instanceof ApiException) {
+        if (e.error === ApiError.noInternetConnection) {
+          emit(new AliasCreationErrorState(AliasError.connection, aliasC));
+        } else if (e.error === ApiError.forbidden) {
+          if (e.problem?.object != null) {
+            emit(new AliasCreationErrorState(AliasError.aliasAlreadyExist, aliasC));
+          } else {
+            emit(new AliasCreationErrorState(AliasError.limitError, aliasC));
+          }
+        } else {
+          emit(new AliasCreationErrorState(AliasError.unknow, aliasC));
+        }
+      } else {
+        emit(new AliasCreationErrorState(AliasError.unknow, aliasC));
+      }
+    }
+  }
+
+  /**
+   * Quand le client finit d'entrer son numéro de téléphone et qu'il doit
+   * passer à l'étape de vérification
+   */
+  private async onAskPhoneNumberVerificationEvent(
+    event: AskPhoneNumberVerificationEvent,
+    emit: Emitter<AliasState>,
+  ): Promise<void> {
+    emit(new AliasMBNOVerificationState(event.values, [], null));
+    await this.aliasInputPort.creer(
+      new AliasCreateCommand({
+        type: AliasType.mbno,
+        phoneNumber: event.values.phoneNumber!,
+        compte: event.values.compte,
+      }),
+    );
+  }
+
+  /** Quand on verifie le code de vérification envoyé à un numéro de téléphone */
+  private async onCheckPhoneNumberVerificationEvent(
+    event: CheckPhoneNumberVerificationEvent,
+    emit: Emitter<AliasState>,
+  ): Promise<void> {
+    // Valeur du code PIN
+    const otpCode = event.otpCode;
+    if (!otpCode.isValid()) {
+      // Code incomplet => l'utilisateur n'a pas fini de saisir
+      emit(new AliasMBNOVerificationState(event.values, otpCode.value, null));
+      return;
+    }
+    emit(new AliasCreatingState(event.values));
+    try {
+      const alias = await this.aliasInputPort.confirmer(otpCode, event.values);
+      emit(new AliasExistState(alias));
+    } catch (e) {
+      if (e instanceof AliasNotAvailableException) {
+        // Alias déjà pris : réclamer ?
+        emit(new AliasCreationErrorState(AliasError.aliasAlreadyExist, event.values));
+      } else if (e instanceof AliasInvalidOtpException) {
+        // Code OTP invalide
+        emit(new AliasMBNOVerificationState(event.values, otpCode.value, AliasError.invalidOtpCode));
+      } else {
+        emit(new AliasMBNOVerificationState(event.values, otpCode.value, AliasError.unknow));
+      }
+    }
+  }
+
+  /** Quand on veut revendiquer un alias */
+  private async onAliasClaimAskEvent(event: AliasClaimAskEvent, emit: Emitter<AliasState>): Promise<void> {
+    emit(new AliasClaimAskingState());
+    try {
+      await this.aliasInputPort.revendiquer(event.compte, event.phoneNumber);
+      emit(new AliasClaimAskingSuccessState());
+    } catch (e) {
+      if (!(e instanceof ApiException)) throw e;
+      if (e.error === ApiError.forbidden) {
+        // Alias en cours de revendication
+        emit(new AliasClaimAskingErrorState(AliasError.aliasLocked, event.phoneNumber));
+      } else if (e.error === ApiError.notFound) {
+        // L'alias n'existe pas (déjà supprimé dans PI)
+        emit(new AliasClaimAskingErrorState(AliasError.aliasNotExist, event.phoneNumber));
+      } else {
+        this.logger.e('Erreur revendication alias', { error: e });
+        emit(new AliasClaimAskingErrorState(AliasError.unknow, event.phoneNumber));
+      }
+    }
+  }
+
+  /** Quand on veut récupérer une revendication */
+  private async onAliasClaimFetchEvent(event: AliasClaimFetchEvent, emit: Emitter<AliasState>): Promise<void> {
+    // Loading
+    emit(new AliasClaimFetchingState(event.id, event.alias));
+    try {
+      const revendication = await this.aliasInputPort.recupererRevendication(event.id);
+      if (revendication != null) {
+        emit(new AliasClaimHandlingState(event.id, event.alias, revendication, false));
+        emit(new AliasExistState(event.alias, { claim: revendication }));
+      } else {
+        emit(new AliasClaimNotFoundState(event.id, event.alias));
+        emit(new AliasExistState(event.alias));
+      }
+    } catch (e) {
+      this.logger.e('Erreur Fetching details claim => ', { error: e });
+      // Écart volontaire : le SDK Flutter restait ici sur la page de
+      // chargement indéfiniment ; on affiche la même erreur qu'une
+      // revendication introuvable.
+      emit(new AliasClaimNotFoundState(event.id, event.alias));
+      emit(new AliasExistState(event.alias));
+    }
+  }
+
+  /** Quand on veut accepter ou rejeter une revendication */
+  private async onAliasClaimRespondEvent(event: AliasClaimRespondEvent, emit: Emitter<AliasState>): Promise<void> {
+    const rejectingWithOtp = event.otpCode != null;
+    emit(new AliasClaimHandlingLoadingState(event.id, event.alias, event.claim, rejectingWithOtp));
+    try {
+      const claim = await this.aliasInputPort.repondreRevendication(
+        event.id,
+        event.decision,
+        event.otpCode?.join('') ?? null,
+      );
+      if (event.decision) {
+        // Il a accepté
+        emit(new AliasClaimHandlingSuccessState(event.id, event.alias, claim));
+        // Après acceptation l'alias shid est le seul qu'il a
+        emit(new AliasExistState(claim.shid!, { claim }));
+      } else if (event.otpCode == null) {
+        // Il a refusé : un code OTP lui est demandé
+        emit(new AliasClaimHandlingOtpSentState(event.id, event.alias, claim, true));
+      } else {
+        emit(new AliasClaimHandlingSuccessState(event.id, event.alias, claim));
+        // Confirmer qu'il a conservé son alias MBNO
+        emit(new AliasExistState(event.alias, { claim }));
+      }
+    } catch (e) {
+      if (e instanceof AliasInvalidOtpException) {
+        // Code OTP invalide
+        emit(
+          new AliasClaimHandlingErrorState(event.id, event.alias, event.claim, rejectingWithOtp, AliasError.invalidOtpCode),
+        );
+        return;
+      }
+      if (!(e instanceof ApiException)) throw e;
+      if (e.error === ApiError.forbidden) {
+        // revendication terminée ou cloturée
+        emit(new AliasClaimHandlingErrorState(event.id, event.alias, event.claim, rejectingWithOtp, AliasError.claimClosed));
+      }
+      // `else if` ici, alors que le SDK Flutter a un simple `if` : un 403 y
+      // émet « revendication close » puis aussitôt « erreur inconnue ».
+      else if (e.error === ApiError.badRequest) {
+        // Code otp invalide
+        emit(
+          new AliasClaimHandlingErrorState(event.id, event.alias, event.claim, rejectingWithOtp, AliasError.invalidOtpCode),
+        );
+      } else {
+        this.logger.e('Erreur acceptation revendication alias', { error: e });
+        emit(new AliasClaimHandlingErrorState(event.id, event.alias, event.claim, rejectingWithOtp, AliasError.unknow));
+      }
+    }
+  }
+}

package/src/modules/alias/presentation/bloc/alias_event.ts

@@ -0,0 +1,104 @@
+import type { Alias } from '../../domain/models/alias';
+import type { AliasCreateCommand, AliasCreateCommandPhoneNumber } from '../../domain/models/alias_create_command';
+import type { AliasMbnoOtpCommand } from '../../domain/models/alias_mbno_otp_command';
+import type { AliasRevendication } from '../../domain/models/alias_revendication';
+
+export abstract class AliasEvent {}
+
+/** Quand on souhaite recupérer l'alias de compte */
+export class FetchAliasEvent extends AliasEvent {
+  constructor(readonly compte: string) {
+    super();
+  }
+}
+
+// ---------------------
+// Address alias
+// ---------------------
+
+/** Quand on souhaite créer un alias de type SHID */
+export class CreateAliasSHIDEvent extends AliasEvent {
+  constructor(readonly compte: string) {
+    super();
+  }
+}
+
+// ---------------------
+// Phone number alias
+// ---------------------
+export class CreateAliasMBNOEvent extends AliasEvent {
+  constructor(readonly compte: string) {
+    super();
+  }
+}
+
+export class CreateAliasMBNOValidationEvent extends AliasEvent {
+  constructor(readonly values: AliasCreateCommand) {
+    super();
+  }
+}
+
+/** Quand on souhaite envoyer un code otp */
+export class AskPhoneNumberVerificationEvent extends AliasEvent {
+  constructor(readonly values: AliasCreateCommand) {
+    super();
+  }
+}
+
+/** Quand on souhaite verifier un code otp envoyé sur un numéro */
+export class CheckPhoneNumberVerificationEvent extends AliasEvent {
+  constructor(
+    /** Alias */
+    readonly values: AliasCreateCommand,
+    /** Numero selectionne */
+    readonly digit: number,
+    /** Position du numéro */
+    readonly position: number,
+    /** Code otp */
+    readonly otpCode: AliasMbnoOtpCommand,
+  ) {
+    super();
+  }
+}
+
+/** Quand on souhaite supprimer un alias */
+export class AliasDeleteEvent extends AliasEvent {
+  constructor(readonly alias: Alias) {
+    super();
+  }
+}
+
+/** Quand on veut revendiquer un alias */
+export class AliasClaimAskEvent extends AliasEvent {
+  readonly compte: string;
+  phoneNumber: AliasCreateCommandPhoneNumber;
+
+  constructor(params: { compte: string; phoneNumber: AliasCreateCommandPhoneNumber }) {
+    super();
+    this.compte = params.compte;
+    this.phoneNumber = params.phoneNumber;
+  }
+}
+
+/** Quand on souhaite recuperer une revendication d'alias */
+export class AliasClaimFetchEvent extends AliasEvent {
+  constructor(
+    readonly id: string,
+    readonly alias: Alias,
+  ) {
+    super();
+  }
+}
+
+/** Quand on souhaite accepter ou rejeter une revendication */
+export class AliasClaimRespondEvent extends AliasEvent {
+  constructor(
+    readonly id: string,
+    readonly alias: Alias,
+    readonly claim: AliasRevendication,
+    readonly decision: boolean,
+    readonly otpCode: number[] | null,
+  ) {
+    super();
+  }
+}

package/src/modules/alias/presentation/bloc/alias_state.ts

@@ -0,0 +1,192 @@
+import type { Alias } from '../../domain/models/alias';
+import type { AliasCreateCommand, AliasCreateCommandPhoneNumber } from '../../domain/models/alias_create_command';
+import type { AliasError } from '../../domain/models/alias_error';
+import type { AliasRevendication } from '../../domain/models/alias_revendication';
+
+export abstract class AliasState {}
+
+export class AliasInitialState extends AliasState {}
+
+/** Etat quand on a pu recupérer l'alias */
+export class AliasExistState extends AliasState {
+  readonly error?: AliasError;
+  /** revendication sur cet alias */
+  readonly claim?: AliasRevendication;
+
+  constructor(
+    readonly alias: Alias,
+    options: { claim?: AliasRevendication; error?: AliasError } = {},
+  ) {
+    super();
+    this.claim = options.claim;
+    this.error = options.error;
+  }
+}
+
+/** Etat quand l'alias n'existe pas */
+export class AliasNotExistState extends AliasState {
+  /** Compte concerné (voir `AliasBloc.fetchFor`). */
+  readonly compte?: string;
+
+  constructor(options: { compte?: string } = {}) {
+    super();
+    this.compte = options.compte;
+  }
+}
+
+/** Etat quand on initie la creation d'un alias */
+export class AliasCreatingState extends AliasState {
+  constructor(readonly values: AliasCreateCommand) {
+    super();
+  }
+}
+
+/** Etat quand la récupération d'un alias à échoué */
+export class AliasFetchErrorState extends AliasState {
+  constructor(
+    readonly compte: string,
+    readonly error: AliasError | null,
+  ) {
+    super();
+  }
+}
+
+/** Etat quand la creation d'un alias à reussie */
+export class AliasCreationSuccessState extends AliasState {}
+
+/** Etat quand la creation d'un alias à échouée */
+export class AliasCreationErrorState extends AliasState {
+  constructor(
+    readonly error: AliasError | null,
+    readonly values: AliasCreateCommand,
+  ) {
+    super();
+  }
+}
+
+/** Etat quand on est entrain de créer un alias de type MBNO */
+export class AliasMBNOCreationState extends AliasState {
+  constructor(readonly values: AliasCreateCommand) {
+    super();
+  }
+}
+
+/** Etat quand on lance l'envoi du code pin */
+export class AliasMBNOVerificationState extends AliasState {
+  constructor(
+    readonly values: AliasCreateCommand,
+    /** Code PIN */
+    readonly otpCode: number[],
+    readonly error: AliasError | null,
+  ) {
+    super();
+  }
+}
+
+/** Etat quand initie la vérification du code otp */
+export class AliasMBNOVerificationLoadingState extends AliasState {}
+
+/** Etat quand on initie la suppression d'un alias */
+export class AliasDeletingState extends AliasState {}
+
+/** Etat quand la suppression d'un alias à échouée */
+export class AliasDeleteErrorState extends AliasState {
+  constructor(readonly error: string) {
+    super();
+  }
+}
+
+/** Etat quand on est entrain d'envoyer la demande de revendication */
+export class AliasClaimAskingState extends AliasState {}
+
+/** Etat quand la demande de revendication est envoyée avec succès */
+export class AliasClaimAskingSuccessState extends AliasState {}
+
+/** Etat quand la demande de revendication n'est pas envoyée avec succès */
+export class AliasClaimAskingErrorState extends AliasState {
+  constructor(
+    readonly error: AliasError | null,
+    readonly phoneNumber: AliasCreateCommandPhoneNumber,
+  ) {
+    super();
+  }
+}
+
+/** Etat quand on recherche une demande de revendication */
+export class AliasClaimFetchingState extends AliasState {
+  constructor(
+    readonly id: string,
+    readonly alias: Alias,
+  ) {
+    super();
+  }
+}
+
+/** Etat quand on traite une demande de revendication */
+export class AliasClaimHandlingState extends AliasState {
+  constructor(
+    readonly id: string,
+    readonly alias: Alias,
+    readonly claim: AliasRevendication,
+    readonly rejecting: boolean,
+  ) {
+    super();
+  }
+}
+
+/** Etat quand on trouve pas une demande de revendication */
+export class AliasClaimNotFoundState extends AliasState {
+  constructor(
+    readonly id: string,
+    readonly alias: Alias,
+  ) {
+    super();
+  }
+}
+
+export class AliasClaimHandlingLoadingState extends AliasState {
+  constructor(
+    readonly id: string,
+    readonly alias: Alias,
+    readonly claim: AliasRevendication,
+    /** Il est entrain de rejeter la demande */
+    readonly rejecting: boolean,
+  ) {
+    super();
+  }
+}
+
+export class AliasClaimHandlingOtpSentState extends AliasState {
+  constructor(
+    readonly id: string,
+    readonly alias: Alias,
+    readonly claim: AliasRevendication,
+    readonly rejecting: boolean,
+  ) {
+    super();
+  }
+}
+
+export class AliasClaimHandlingErrorState extends AliasState {
+  constructor(
+    readonly id: string,
+    readonly alias: Alias,
+    readonly claim: AliasRevendication,
+    /** Il est entrain de rejeter la demande */
+    readonly rejecting: boolean,
+    readonly error: AliasError | null,
+  ) {
+    super();
+  }
+}
+
+/** Etat quand la demande de revendication est acceptée ou rejetée avec succès */
+export class AliasClaimHandlingSuccessState extends AliasState {
+  constructor(
+    readonly id: string,
+    readonly alias: Alias,
+    readonly claim: AliasRevendication,
+  ) {
+    super();
+  }
+}