@pi-spi/app 0.0.0-stage → 1.2.1

package/src/modules/transactions/domain/models/transaction.ts

@@ -0,0 +1,341 @@
+import { Frequence } from '../../../../shared/models/frequence_command';
+import { TransactionCanal } from './transaction_canal';
+import { TransactionCancelReason } from './transaction_cancel_reason';
+
+export enum TransactionSens {
+  debit = 'debit',
+  credit = 'credit',
+}
+
+export enum TransactionStatut {
+  irrevocable = 'irrevocable',
+  rejete = 'rejete',
+  initie = 'initie',
+  desactive = 'desactive',
+}
+
+type Json = Record<string, any>;
+
+export class Transaction {
+  /** Compte du client */
+  readonly compte: string;
+  /** Alias du compte du client */
+  readonly compteAlias?: string;
+  readonly montant: number;
+  readonly montantFrais?: number;
+  readonly sens: TransactionSens;
+  motif?: string;
+  readonly canal?: string;
+  /** Si sens = débit, le client est le payeur ; si crédit, le payé */
+  readonly clientNom: string;
+  readonly clientPays: string;
+  /** PSP du client payé si iban ou other */
+  readonly clientPSP?: string;
+  /** Nom du PSP du client payé */
+  readonly clientPSPNom?: string;
+  /** IBAN ou Other */
+  readonly clientCompte?: string;
+  /** Alias du client */
+  readonly clientAlias?: string;
+  readonly endToEndId: string;
+  /** Après recherche d'alias on a l'info normalement si c'est défini */
+  readonly clientPhoto?: string;
+
+  /** Date d'irrévocabilité */
+  dateOperation?: Date;
+  /** Statut de la transaction */
+  statut?: TransactionStatut;
+  statutRaison?: string;
+  rejetDate?: Date;
+  /** Date de la première exécution du paiement programmé */
+  dateDebut?: Date;
+  /** Date de la dernière exécution du paiement programmé */
+  dateFin?: Date;
+  /** Fréquence de paiement définie par le client */
+  frequence?: Frequence;
+  /** Périodicité du paiement >= 2 */
+  periodicite?: number;
+  facture?: string;
+  /** Date d'expiration de la demande ou date limite de retour ou annulation */
+  dateExpiration?: Date;
+  /** La référence du payé qui correspond au TxId */
+  readonly txId?: string;
+  /** Contient l'échéance de la tontine */
+  instructionId?: string;
+  subscriptionId?: string;
+
+  // Retour de fonds
+  retourDate?: Date;
+  retourStatut?: TransactionStatut;
+  retourStatutRaison?: string;
+
+  // Demande d'annulation
+  annulationDate?: Date;
+  annulationStatut?: TransactionStatut;
+  annulationStatutRaison?: string;
+  annulationRaison?: TransactionCancelReason;
+
+  // Demande de paiement
+  dateDemande?: Date;
+  /** Date limite de réponse au RTP */
+  dateReponse?: Date;
+  /** Remise appliquée */
+  remise?: number;
+  /** Retrait PICO ou PICASH */
+  retraitAchat?: number;
+  retraitMontant?: number;
+  retraitFrais?: number;
+  /** Débit différé */
+  differe?: boolean;
+  /** Fréquence de paiement proposée */
+  differeFrequence?: Frequence;
+  differeOccurence?: number;
+  differeMontant?: number;
+  /** Clé de chiffrement du rapport du tirage (tontine) */
+  signature?: string;
+
+  /** Local only : catégorie */
+  categorie?: string;
+
+  constructor(params: Partial<Transaction> & {
+    compte: string;
+    montant: number;
+    sens: TransactionSens;
+    clientNom: string;
+    clientPays: string;
+    endToEndId: string;
+  }) {
+    this.compte = params.compte;
+    this.montant = params.montant;
+    this.sens = params.sens;
+    this.clientNom = params.clientNom;
+    this.clientPays = params.clientPays;
+    this.endToEndId = params.endToEndId;
+    Object.assign(this, params);
+  }
+
+  /** Est-ce un retour de fonds ? */
+  isRetour(): boolean {
+    return this.endToEndId.startsWith('R');
+  }
+
+  /** Le retour de fonds est-il passé ? */
+  isRetourOk(): boolean {
+    return this.retourDate != null && this.retourStatut === TransactionStatut.irrevocable;
+  }
+
+  isRejet(): boolean {
+    return (
+      (this.statut === TransactionStatut.rejete && this.statutRaison != null) ||
+      (this.retourStatut === TransactionStatut.rejete && this.retourStatutRaison != null)
+    );
+  }
+
+  /** Est-ce une demande de paiement ? */
+  isRTP(): boolean {
+    return (
+      this.canal != null &&
+      [
+        TransactionCanal.transfertParRequestToPay.code,
+        TransactionCanal.paiementParRequestToPaySite.code,
+        TransactionCanal.paiementParRequestToPayEcommerceImmediat.code,
+        TransactionCanal.paiementParRequestToPayEcommerceLivraison.code,
+        TransactionCanal.paiementParRequestToPayAutresFactures.code,
+      ].includes(this.canal)
+    );
+  }
+
+  /** Est-ce une transaction liée à un partage de dépense ? */
+  isSplit(): boolean {
+    return (
+      this.canal === TransactionCanal.transfertParRequestToPay.code && this.motif != null && this.motif.startsWith('@SPLIT')
+    );
+  }
+
+  /** Est-ce qu'on peut programmer ? */
+  canSchedule(): boolean {
+    return (
+      (this.canal == null ||
+        [
+          TransactionCanal.transfertParRequestToPay.code,
+          TransactionCanal.paiementParRequestToPayEcommerceLivraison.code,
+          TransactionCanal.paiementParRequestToPayAutresFactures.code,
+        ].includes(this.canal)) &&
+      (this.dateExpiration == null || this.dateExpiration.getTime() > Date.now())
+    );
+  }
+
+  canCancel(): boolean {
+    return (
+      !(this.annulationStatut === TransactionStatut.initie || this.annulationStatut === TransactionStatut.irrevocable) &&
+      !this.isRetourOk()
+    );
+  }
+
+  /** Est-ce un retrait avec achat ? */
+  isPICO(): boolean {
+    return this.retraitAchat != null && this.retraitAchat > 0;
+  }
+
+  /** Est-ce un retrait ? */
+  isPICASH(): boolean {
+    return this.retraitAchat == null || this.retraitAchat === 0;
+  }
+
+  /** Décode un motif de partage : "@SPLIT_100000_SN_Business Services_2024-08-18T14:15:22.999Z@". */
+  decodeMotif(): string[] {
+    if (this.motif == null) return [];
+    let parts: string[] = [];
+    if (this.motif.startsWith('@SPLIT')) {
+      parts = this.motif.replace('@SPLIT', '').replace('@', '').split('_');
+    }
+    return parts.filter((p) => p.length > 0);
+  }
+
+  // ─── Sérialisation ────────────────────────────────────────────────
+
+  static fromJson(json: Json): Transaction {
+    return new Transaction({
+      compte: json.compte,
+      compteAlias: json.compteAlias ?? undefined,
+      montant: parseDouble(json.montant)!,
+      montantFrais: parseDouble(json.montantFrais),
+      sens: json.sens === 'debit' ? TransactionSens.debit : TransactionSens.credit,
+      motif: json.motif ?? undefined,
+      canal: json.canal ?? undefined,
+      clientNom: json.clientNom,
+      clientPays: json.clientPays,
+      clientPhoto: json.clientPhoto ?? undefined,
+      clientPSP: json.clientPSP ?? undefined,
+      clientPSPNom: json.clientPSPNom ?? undefined,
+      clientCompte: json.clientCompte ?? undefined,
+      clientAlias: json.clientAlias ?? undefined,
+      endToEndId: json.endToEndId,
+      txId: json.txId ?? undefined,
+      instructionId: json.instructionId ?? undefined,
+      subscriptionId: json.subscriptionId ?? undefined,
+      categorie: json.categorie ?? undefined,
+      facture: json.facture ?? undefined,
+      signature: json.signature ?? undefined,
+      dateOperation: parseDate(json.dateOperation),
+      dateExpiration: parseDate(json.dateExpiration),
+      dateDebut: parseDate(json.dateDebut),
+      dateFin: parseDate(json.dateFin),
+      dateDemande: parseDate(json.dateDemande),
+      dateReponse: parseDate(json.dateReponse),
+      statut: parseStatut(json.statut),
+      statutRaison: json.statutRaison ?? undefined,
+      rejetDate: parseDate(json.rejetDate),
+      frequence: parseFrequence(json.frequence),
+      periodicite: parseInteger(json.periodicite),
+      remise: parseDouble(json.remise),
+      retourDate: parseDate(json.retourDate),
+      retourStatut: parseStatut(json.retourStatut),
+      retourStatutRaison: json.retourStatutRaison ?? undefined,
+      annulationRaison: TransactionCancelReason.fromCode(json.annulationRaison),
+      annulationDate: parseDate(json.annulationDate),
+      annulationStatut: parseStatut(json.annulationStatut),
+      annulationStatutRaison: json.annulationStatutRaison ?? undefined,
+      retraitAchat: parseDouble(json.retraitAchat),
+      retraitMontant: parseDouble(json.retraitMontant),
+      retraitFrais: parseDouble(json.retraitFrais),
+      differe: json.differe != null ? String(json.differe) === 'true' : undefined,
+      differeFrequence: parseFrequence(json.differeFrequence),
+      differeOccurence: parseInteger(json.differeOccurence),
+      differeMontant: parseDouble(json.differeMontant),
+    });
+  }
+
+  toJson(): Json {
+    const iso = (d?: Date) => d?.toISOString() ?? null;
+    const str = (n?: number) => (n != null ? String(n) : null);
+    return {
+      compte: this.compte,
+      compteAlias: this.compteAlias ?? null,
+      montant: String(this.montant),
+      montantFrais: str(this.montantFrais),
+      sens: this.sens,
+      motif: this.motif ?? null,
+      canal: this.canal ?? null,
+      clientNom: this.clientNom,
+      clientPays: this.clientPays,
+      clientPSP: this.clientPSP ?? null,
+      clientPSPNom: this.clientPSPNom ?? null,
+      clientPhoto: this.clientPhoto ?? null,
+      clientCompte: this.clientCompte ?? null,
+      clientAlias: this.clientAlias ?? null,
+      endToEndId: this.endToEndId,
+      txId: this.txId ?? null,
+      instructionId: this.instructionId ?? null,
+      subscriptionId: this.subscriptionId ?? null,
+      categorie: this.categorie ?? null,
+      facture: this.facture ?? null,
+      signature: this.signature ?? null,
+      dateOperation: iso(this.dateOperation),
+      dateExpiration: iso(this.dateExpiration),
+      dateDebut: iso(this.dateDebut),
+      dateFin: iso(this.dateFin),
+      dateDemande: iso(this.dateDemande),
+      dateReponse: iso(this.dateReponse),
+      statut: this.statut ?? null,
+      statutRaison: this.statutRaison ?? null,
+      rejetDate: iso(this.rejetDate),
+      frequence: this.frequence ?? null,
+      periodicite: str(this.periodicite),
+      remise: str(this.remise),
+      retourDate: iso(this.retourDate),
+      retourStatut: this.retourStatut ?? null,
+      retourStatutRaison: this.retourStatutRaison ?? null,
+      annulationRaison: this.annulationRaison ?? null,
+      annulationDate: iso(this.annulationDate),
+      annulationStatut: this.annulationStatut ?? null,
+      annulationStatutRaison: this.annulationStatutRaison ?? null,
+      retraitAchat: str(this.retraitAchat),
+      retraitMontant: str(this.retraitMontant),
+      retraitFrais: str(this.retraitFrais),
+      differe: this.differe ?? null,
+      differeFrequence: this.differeFrequence ?? null,
+      differeOccurence: str(this.differeOccurence),
+      differeMontant: str(this.differeMontant),
+    };
+  }
+
+  /** Représentation texte (utilisée par la recherche locale par mot-clé, comme en Dart). */
+  toString(): string {
+    return `Transaction {${Object.entries(this.toJson())
+      .map(([k, v]) => `${k}: ${v}`)
+      .join(', ')}}`;
+  }
+}
+
+function parseStatut(value: unknown): TransactionStatut | undefined {
+  if (value == null) return undefined;
+  switch (String(value).toLowerCase()) {
+    case 'irrevocable':
+      return TransactionStatut.irrevocable;
+    case 'rejete':
+      return TransactionStatut.rejete;
+    case 'initie':
+      return TransactionStatut.initie;
+    case 'desactive':
+      return TransactionStatut.desactive;
+    default:
+      return undefined;
+  }
+}
+
+function parseDouble(value: unknown): number | undefined {
+  return value != null ? parseFloat(String(value)) : undefined;
+}
+
+function parseInteger(value: unknown): number | undefined {
+  return value != null ? parseInt(String(value), 10) : undefined;
+}
+
+function parseDate(value: unknown): Date | undefined {
+  return value != null ? new Date(String(value)) : undefined;
+}
+
+function parseFrequence(value: unknown): Frequence | undefined {
+  return value != null ? Frequence.get(String(value)) : undefined;
+}

package/src/modules/transactions/domain/models/transaction_canal.ts

@@ -0,0 +1,63 @@
+/**
+ * Canal de communication. Correspond au champ localInstrument des
+ * messages pacs.008 et pain.013. Plusieurs canaux partagent le même code
+ * (633), d'où des instances nommées plutôt qu'un `enum` TypeScript.
+ */
+export class TransactionCanal {
+  private constructor(
+    readonly name: string,
+    /** Codification du paramètre */
+    readonly code: string,
+  ) {}
+
+  /** Transfert par QR Code 731 */
+  static readonly transfertParQrcode = new TransactionCanal('transfertParQrcode', '731');
+  /** Transfert par Telephone 633 */
+  static readonly transfertParTelephone = new TransactionCanal('transfertParTelephone', '633');
+  /** Transfert par adresse de paiement 633 */
+  static readonly transfertParSHID = new TransactionCanal('transfertParSHID', '633');
+  /** Transfert par compte 633 */
+  static readonly transfertParCompte = new TransactionCanal('transfertParCompte', '633');
+  /** Ordre de transfert bancaire 999 */
+  static readonly ordreDeTransfertBancaire = new TransactionCanal('ordreDeTransfertBancaire', '999');
+  /** Paiement par QR Code Statique 000 */
+  static readonly paiementParQrcodeStatique = new TransactionCanal('paiementParQrcodeStatique', '000');
+  /** Paiement par QR Code Dynamique 400 */
+  static readonly paiementParQrcodeDynamique = new TransactionCanal('paiementParQrcodeDynamique', '400');
+  /** Transfert par request to pay 631 */
+  static readonly transfertParRequestToPay = new TransactionCanal('transfertParRequestToPay', '631');
+  /** Paiement par Request To Pay sur site 500 */
+  static readonly paiementParRequestToPaySite = new TransactionCanal('paiementParRequestToPaySite', '500');
+  /** Demande de Paiement e-commerce immédiat 521 */
+  static readonly paiementParRequestToPayEcommerceImmediat = new TransactionCanal(
+    'paiementParRequestToPayEcommerceImmediat',
+    '521',
+  );
+  /** Demande de Paiement e-commerce à la livraison 520 */
+  static readonly paiementParRequestToPayEcommerceLivraison = new TransactionCanal(
+    'paiementParRequestToPayEcommerceLivraison',
+    '520',
+  );
+  /** Autres Demande de Paiement 401 */
+  static readonly paiementParRequestToPayAutresFactures = new TransactionCanal('paiementParRequestToPayAutresFactures', '401');
+  /** Tout autre type de canal 633 */
+  static readonly defaultCanal = new TransactionCanal('defaultCanal', '633');
+
+  static values(): TransactionCanal[] {
+    return [
+      TransactionCanal.transfertParQrcode,
+      TransactionCanal.transfertParTelephone,
+      TransactionCanal.transfertParSHID,
+      TransactionCanal.transfertParCompte,
+      TransactionCanal.ordreDeTransfertBancaire,
+      TransactionCanal.paiementParQrcodeStatique,
+      TransactionCanal.paiementParQrcodeDynamique,
+      TransactionCanal.transfertParRequestToPay,
+      TransactionCanal.paiementParRequestToPaySite,
+      TransactionCanal.paiementParRequestToPayEcommerceImmediat,
+      TransactionCanal.paiementParRequestToPayEcommerceLivraison,
+      TransactionCanal.paiementParRequestToPayAutresFactures,
+      TransactionCanal.defaultCanal,
+    ];
+  }
+}

package/src/modules/transactions/domain/models/transaction_cancel_reason.ts

@@ -0,0 +1,26 @@
+/** Raisons d'une demande d'annulation (valeur = codification) */
+export enum TransactionCancelReason {
+  erreurDestinataire = 'AC03',
+  erreurMontant = 'AM09',
+  serviceNonRendu = 'SVNR',
+  dejaPaye = 'DUPL',
+  fraude = 'FRAD',
+}
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace TransactionCancelReason {
+  export function values(): TransactionCancelReason[] {
+    return [
+      TransactionCancelReason.erreurDestinataire,
+      TransactionCancelReason.erreurMontant,
+      TransactionCancelReason.serviceNonRendu,
+      TransactionCancelReason.dejaPaye,
+      TransactionCancelReason.fraude,
+    ];
+  }
+
+  /** Raison correspondant à [code] (`undefined` si inconnu). */
+  export function fromCode(code: string | null | undefined): TransactionCancelReason | undefined {
+    return values().find((r) => r === code);
+  }
+}

package/src/modules/transactions/domain/models/transaction_error.ts

@@ -0,0 +1,85 @@
+/** Types d'erreurs possibles dans la gestion des transactions */
+export enum TransactionError {
+  unknow = 'unknow',
+  connection = 'connection',
+  location = 'location',
+  timeOut = 'timeOut',
+  // Transferts
+  /** Le bénéficiaire doit être une personne physique non commerçante */
+  invalidBeneficiary = 'invalidBeneficiary',
+  /** Le bénéficiaire n'existe pas */
+  beneficiaryNotFound = 'beneficiaryNotFound',
+  reservationError = 'reservationError',
+  /** Participant payé indisponible */
+  pspPayeIndisponible = 'pspPayeIndisponible',
+  /** Participant payeur indisponible */
+  pspPayeurIndisponible = 'pspPayeurIndisponible',
+  /** timeout au niveau du psp */
+  timeoutInterne = 'timeoutInterne',
+  /** Erreur chez le psp */
+  errorInterne = 'errorInterne',
+  /** Transaction toujours à l'état initié */
+  toujoursInitier = 'toujoursInitier',
+  /** Vous ne pouvez pas vous envoyer un transfert à vous même */
+  interdit = 'interdit',
+  /** Le numéro de compte du bénéficiaire est invalide */
+  clientPayeCompteInvalid = 'clientPayeCompteInvalid',
+  /** Le numéro de compte de l'expéditeur est clôturé */
+  clientPayeurCompteCloture = 'clientPayeurCompteCloture',
+  /** Le numéro de compte du bénéficiaire est clôturé */
+  clientPayeCompteCloture = 'clientPayeCompteCloture',
+  /** Le numéro de compte du bénéficiaire est bloqué */
+  clientPayeCompteBloque = 'clientPayeCompteBloque',
+  /** Le montant dépasse la limite que ce bénéficiaire peut recevoir */
+  clientPayeCompteLimite = 'clientPayeCompteLimite',
+  /** Ce bénéficiaire ne peut pas recevoir de fonds (restrictions réglementaires) */
+  clientPayeCompteInterdit = 'clientPayeCompteInterdit',
+  /** Transaction interdite sur ce type de compte */
+  clientPayeCompteTransactionInterdit = 'clientPayeCompteTransactionInterdit',
+  // Annulations
+  dejaRetourne = 'dejaRetourne',
+  delaiDepasse = 'delaiDepasse',
+  // RTP
+  dejaPaye = 'dejaPaye',
+}
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace TransactionError {
+  /** Erreur correspondant à un code de rejet ISO 20022. */
+  export function fromCode(code: string): TransactionError {
+    switch (code) {
+      case 'AG11':
+      case 'AB09':
+        return TransactionError.pspPayeIndisponible;
+      case 'AG07':
+        return TransactionError.reservationError;
+      case 'AB03':
+        return TransactionError.timeOut;
+      case 'AG10':
+      case 'AM04':
+        return TransactionError.pspPayeurIndisponible;
+      case 'AB11':
+        return TransactionError.timeoutInterne;
+      case 'FF10':
+        return TransactionError.errorInterne;
+      case 'AG12':
+        return TransactionError.interdit;
+      case 'AC03':
+        return TransactionError.clientPayeCompteInvalid;
+      case 'AC04':
+        return TransactionError.clientPayeurCompteCloture;
+      case 'AC07':
+        return TransactionError.clientPayeCompteCloture;
+      case 'AC06':
+        return TransactionError.clientPayeCompteBloque;
+      case 'AM21':
+        return TransactionError.clientPayeCompteLimite;
+      case 'RR04':
+        return TransactionError.clientPayeCompteInterdit;
+      case 'AG01':
+        return TransactionError.clientPayeCompteTransactionInterdit;
+      default:
+        return TransactionError.unknow;
+    }
+  }
+}

package/src/modules/transactions/domain/models/transaction_liste.ts

@@ -0,0 +1,32 @@
+import { ListeMeta } from '../../../../shared/models/liste_meta';
+import { Transaction } from './transaction';
+
+export class TransactionListe {
+  constructor(
+    readonly data: Transaction[],
+    readonly meta: ListeMeta,
+  ) {}
+
+  static fromJson(json: Record<string, any>): TransactionListe {
+    return new TransactionListe(
+      (json.data as Record<string, any>[]).map((e) => Transaction.fromJson(e)),
+      ListeMeta.fromJson(json.meta),
+    );
+  }
+
+  get isEmpty(): boolean {
+    return this.data.length === 0;
+  }
+
+  get isNotEmpty(): boolean {
+    return this.data.length > 0;
+  }
+
+  addTransactions(transactions: Transaction[]): void {
+    this.data.push(...transactions);
+  }
+
+  toJson(): Record<string, any> {
+    return { meta: this.meta.toJson(), data: this.data.map((e) => e.toJson()) };
+  }
+}

package/src/modules/transactions/domain/models/transaction_reject_reason.ts

@@ -0,0 +1,23 @@
+/** Raisons d'un rejet (valeur = codification) */
+export enum TransactionRejectReason {
+  erreurDestinataire = 'BE05',
+  erreurMontant = 'AM09',
+  dejaPaye = 'APAR',
+  facture = 'RR07',
+  fraude = 'FR01',
+  autre = 'CUST',
+}
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace TransactionRejectReason {
+  export function values(): TransactionRejectReason[] {
+    return [
+      TransactionRejectReason.erreurDestinataire,
+      TransactionRejectReason.erreurMontant,
+      TransactionRejectReason.dejaPaye,
+      TransactionRejectReason.facture,
+      TransactionRejectReason.fraude,
+      TransactionRejectReason.autre,
+    ];
+  }
+}

package/src/modules/transactions/domain/models/transaction_search/transaction_search_command.ts

@@ -0,0 +1,36 @@
+import type { TransactionSearchFilter } from './transaction_search_filter';
+
+export class TransactionSearchCommand {
+  static readonly defaultLimit = 40;
+
+  filters: TransactionSearchFilter;
+  compte?: string;
+  keyWord?: string;
+  limit: number;
+  /** Numéro de page (number) ou curseur (string) */
+  index?: number | string | null;
+  total: number;
+
+  constructor(params: {
+    filters: TransactionSearchFilter;
+    compte?: string;
+    keyWord?: string;
+    limit?: number;
+    index?: number | string | null;
+    total?: number;
+  }) {
+    this.filters = params.filters;
+    this.compte = params.compte;
+    this.keyWord = params.keyWord;
+    this.limit = params.limit ?? TransactionSearchCommand.defaultLimit;
+    this.index = params.index;
+    this.total = params.total ?? 0;
+  }
+
+  /** Peut-on charger la page suivante ? */
+  canLoadMore(): boolean {
+    if (typeof this.index === 'number') return this.index * this.limit < this.total;
+    if (typeof this.index === 'string') return this.index.length > 0;
+    return false;
+  }
+}

package/src/modules/transactions/domain/models/transaction_search/transaction_search_filter.ts

@@ -0,0 +1,28 @@
+import type { TransactionSens } from '../transaction';
+
+export type DateTimeRange = { start: Date; end: Date };
+
+export class TransactionSearchFilter {
+  dateDebut?: Date;
+  dateFin?: Date;
+  categories: string[];
+  sens: TransactionSens[];
+  subscriptionId?: string;
+
+  constructor(params: { dateDebut?: Date; dateFin?: Date; sens: TransactionSens[]; categories: string[]; subscriptionId?: string }) {
+    this.dateDebut = params.dateDebut;
+    this.dateFin = params.dateFin;
+    this.sens = params.sens;
+    this.categories = params.categories;
+    this.subscriptionId = params.subscriptionId;
+  }
+
+  /** Période du filtre, du début du premier jour à la fin du dernier. */
+  dates(): DateTimeRange | null {
+    const startOf = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate(), 0, 0, 0, 0);
+    const endOf = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate(), 23, 59, 59, 59);
+    if (this.dateDebut != null && this.dateFin != null) return { start: startOf(this.dateDebut), end: endOf(this.dateFin) };
+    if (this.dateDebut != null) return { start: startOf(this.dateDebut), end: endOf(this.dateDebut) };
+    return null;
+  }
+}

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

@@ -0,0 +1,9 @@
+/** Types d'opérations transactionnelles possibles (communs aux commandes d'envoi et de confirmation). */
+export const TransactionActions = {
+  /** paiement immédiat */
+  actionSendNow: 'send_now',
+  /** paiement programmé */
+  actionSendSchedule: 'send_schedule',
+  /** demande de paiement */
+  actionReceiveNow: 'receive_now',
+} as const;