@silexpert/core 1.1.306 → 1.1.308

package/ts/utils/payment.ts

@@ -3,6 +3,7 @@
 import { IPayment, IRegulation, ParamsForPaymentsAuto, PaymentMethod, PaymentAuto, getTaxesIncludedAmount } from '../types';
 import * as dayjs from 'dayjs';
 import { PartialExercicePrestationExpress } from '../types/Interface/api/payment/Util';
+import { getPriceGrid } from './prestation';
 
 interface PaymentsWithList extends IPayment {
   type: 'isComptable' | 'isJuridique' | 'isSocial' | 'isOther',
@@ -57,9 +58,8 @@ const groupPaymentsByServiceType = (payments: IPayment[], types: ('isComptable'
   return societyPayment;
 };
 
-const calculateFees = (amount: number, goToClient: Date, paymentDate: Date, nbExoNonExpressGenerated: number, idVat: number):number => {
+const calculateFees = (amount: number, goToClient: Date, paymentDate: Date):number => {
   const yearlyPriceIncreasing = 1.0275;
-  const appCost = getTaxesIncludedAmount(14.9, idVat);
 
   const oneYearLessIfIn3LastMonthsOfYear = dayjs(goToClient).month() >= 9 ? 1 : 0;
 
@@ -71,12 +71,7 @@ const calculateFees = (amount: number, goToClient: Date, paymentDate: Date, nbEx
     // soit amount * yearlyPriceIncreasing ^ nbYearsMore
     amount = amount * Math.pow(yearlyPriceIncreasing, nbYearsMore);
   }
-
-  // À partir du second exercice non express, on applique le coût de l'application (14,9€ HT)
-  if (nbExoNonExpressGenerated >= 2) {
-    amount += appCost;
-  }
-  return Math.round(100 * amount) / 100;
+  return amount;
 };
 
 /**
@@ -86,15 +81,25 @@ const calculateFees = (amount: number, goToClient: Date, paymentDate: Date, nbEx
  * @param {IPrestationList} prestationList - type of prestation (hidden: 0, isCatalog: 1, isComptable: 1)
  * @param {number} idVat - vat id of society linked
  * @param {number} yearlyAmountNonExpress - yearly amount of non express prestation (HT)
+ * @param {number} nextYearlyAmountNonExpress - yearly amount of non express prestation for next years (HT)
  * @param {PartialExercicePrestationExpress[]} listPartialExercicePrestationExpress - list of exercicePrestation linked to idPrestation -> used to get express
  * @param {IRegulation[]} listRegulations - list of regulations linked to idPrestation (TTC)
  * @returns { IPayment[] } list of payment to create for billing auto, after each presta go to onBoarding
  */
 const calculatePaymentsAuto = (params: ParamsForPaymentsAuto):PaymentAuto[] => {
-  const { goToClient, firstExerciceNonExpresssEndDate, idPrestation, prestationList, idVat, yearlyAmountNonExpress, listPartialExercicePrestationExpress, listRegulations } = params;
+  const { idTypeBrand, goToClient, firstExerciceNonExpresssEndDate, idPrestation, prestationList, idVat, yearlyAmountNonExpress, nextYearlyAmountNonExpress, listPartialExercicePrestationExpress, listRegulations } = params;
   const initializedPaymentDate = dayjs().endOf('month').diff(dayjs(), 'day') < 3/*  || dayjs().date() >= 15 */
     ? dayjs().add(2, 'month').startOf('month').toDate()
     : dayjs().add(1, 'month').startOf('month').toDate();
+  let isApplicationAlreadyPaid = false;
+
+  // On récupère la grille tarifaire pour savoir si les tarifs sont HT ou TTC 
+  // et pour connaitre le montant du coût de l'app
+  if (!prestationList.id) throw new Error('idPrestationList manquant');
+  const priceGrid = getPriceGrid(idTypeBrand, prestationList.id);
+  if (!priceGrid) throw new Error('Impossible de trouver la grille tarifaire correspondante');
+  const { applicationCost, priceWithTaxesIncluded } = priceGrid;
+  const applicationCostTotalTTC = (priceWithTaxesIncluded ? applicationCost : getTaxesIncludedAmount(applicationCost, idVat)) * 12;
 
   if (prestationList?.isCatalog || !prestationList?.isComptable) throw new Error('Ce type de prestation ne correspond pas aux conditions attendues.');
   // if (!listRegulations?.length) throw new Error('List of regulations can not be empty');
@@ -120,6 +125,7 @@ const calculatePaymentsAuto = (params: ParamsForPaymentsAuto):PaymentAuto[] => {
   if (sumRegulations) {
     listPayments.push({
       amount:sumRegulations,  //TTC
+      isPaid: true,
       datePayment: dayjs().toDate(),
       idPrestation,
       idPaymentMethod: PaymentMethod.DIRECT_DEBIT.id,
@@ -130,31 +136,33 @@ const calculatePaymentsAuto = (params: ParamsForPaymentsAuto):PaymentAuto[] => {
   // =========================
   //          EXPRESS
   // =========================
-  listPartialExercicePrestationExpress.forEach((exercicePrestation:PartialExercicePrestationExpress) => {
-    remainingAmount += getTaxesIncludedAmount(exercicePrestation.totalAmount, idVat); //TTC
+  listPartialExercicePrestationExpress.forEach((exercicePrestation:PartialExercicePrestationExpress, indexEP: number) => {
+    remainingAmount += !priceWithTaxesIncluded 
+      ? getTaxesIncludedAmount(exercicePrestation.totalAmount, idVat) 
+      : exercicePrestation.totalAmount; //TTC
     //Si le premier règlement couvre le coût de cet exercicePrestation, on passe au suivant
     if (remainingAmount <= 0) return;
     
     //express : on étale en countExpressMonthlyPayment (nb de mensualités)
     let remainingAmountByExercicePrestation = remainingAmount; //TTC
     let countExpressMonthlyPayment = exercicePrestation?.countExpressMonthlyPayment ?? 3; //TTC
-    const monthlyAmountRounded = Math.round(100 * remainingAmountByExercicePrestation / countExpressMonthlyPayment) / 100; //TTC
+    //Si un premier règlement est généré avec le montant des regulations, on le considère comme une mensualité (unioquement pour le premier express et la première mensualité)
+    if (indexEP === 0 && sumRegulations > 0) countExpressMonthlyPayment -= 1;
+
+    const monthlyAmount = remainingAmountByExercicePrestation / countExpressMonthlyPayment; //TTC
     for (let index = 1; index <= countExpressMonthlyPayment; index++) {
-      //Si un premier règlement est généré avec le montant des regulations, on le considère comme une mensualité
-      if (index === 1 && sumRegulations) countExpressMonthlyPayment -= 1;
-      
       // On arrondis les 11 premières mensualités, mais on récupère le reste  pour la dernière mensualité, pour éviter les centimes perdus en arrondis
       // et on applique le taux de tva de la société
-      const amount = index < countExpressMonthlyPayment ? monthlyAmountRounded : remainingAmountByExercicePrestation;  //TTC
+      const amount = index < countExpressMonthlyPayment ? monthlyAmount : remainingAmountByExercicePrestation;  //TTC
       
       listPayments.push({
-        amount,
+        amount: Math.round(100 * amount) / 100,
         datePayment: paymentDate,
         idPrestation,
         idPaymentMethod: PaymentMethod.DIRECT_DEBIT.id,
         closingDate: exercicePrestation.endDate,
       });
-      remainingAmountByExercicePrestation -= monthlyAmountRounded; 
+      remainingAmountByExercicePrestation -= monthlyAmount; 
       paymentDate = dayjs(paymentDate).add(1, 'month').startOf('month').toDate();
     }
     remainingAmount = 0;
@@ -167,79 +175,78 @@ const calculatePaymentsAuto = (params: ParamsForPaymentsAuto):PaymentAuto[] => {
   // Si un seul exo express, alors on met les paiements de l'exo actuel en parallèle
   // sinon, ils sont à la suite des express
   if (nbExoExpress <= 1) paymentDate = initializedPaymentDate;
-  let nbExoNonExpressGenerated = 1;
   let exerciceEndDate = dayjs(firstExerciceNonExpresssEndDate).toDate();
   
-  //On génère au minimum 2 exercices plein
-  while (nbExoNonExpressGenerated <= 2) {
-    //On compte le nb de mois restants entre la date à laquelle le paiement va être créé et la date de fin d'exercice
-    let countMonthsBeforeExerciceEnd = Math.ceil(dayjs(exerciceEndDate).diff(paymentDate, 'months', true));
-    if (countMonthsBeforeExerciceEnd < 3) countMonthsBeforeExerciceEnd = 3;
-
-    remainingAmount += getTaxesIncludedAmount(yearlyAmountNonExpress, idVat);
+  //On génère un seul exercices plein, non express
+  //On compte le nb de mois restants entre la date à laquelle le paiement va être créé et la date de fin d'exercice
+  let countMonthsBeforeExerciceEnd = Math.ceil(dayjs(exerciceEndDate).diff(paymentDate, 'months', true));
+  if (countMonthsBeforeExerciceEnd < 3) countMonthsBeforeExerciceEnd = 3;
+  
+  const exoAmount = yearlyAmountNonExpress;
+  remainingAmount += priceWithTaxesIncluded ? exoAmount : getTaxesIncludedAmount(exoAmount, idVat);
 
-    let remainingAmountByExercicePrestation = remainingAmount;
-    const monthlyAmountRounded = Math.round(100 * remainingAmountByExercicePrestation / countMonthsBeforeExerciceEnd) / 100;  //TTC
+  let remainingAmountByExercicePrestation = remainingAmount;
+  let monthlyAmount = remainingAmountByExercicePrestation / countMonthsBeforeExerciceEnd;  //TTC
 
-    if (monthlyAmountRounded > 0) {
-      for (let index = 1; index <= countMonthsBeforeExerciceEnd; index++) {
-        let amount = index < countMonthsBeforeExerciceEnd ? monthlyAmountRounded : Math.round(100 * remainingAmountByExercicePrestation) / 100;
+  if (monthlyAmount > 0) {
+    for (let index = 1; index <= countMonthsBeforeExerciceEnd; index++) {
+      let amount = index < countMonthsBeforeExerciceEnd ? monthlyAmount : remainingAmountByExercicePrestation;
       
-        // Si besoin, on applique les frais nécessaires :
-        // - 2,75% d'augmentation chaque année, sauf si souscriptiuon dans les 3 derniers mois de l'année civile)
-        // - frais d'application dès les second exo non express
-        amount = calculateFees(amount, goToClient, paymentDate, nbExoNonExpressGenerated, idVat);
+      // Si besoin, on applique les frais nécessaires :
+      // - 2,75% d'augmentation chaque année, sauf si souscriptiuon dans les 3 derniers mois de l'année civile)
+      amount = calculateFees(amount, goToClient, paymentDate);
       
-        listPayments.push({
-          amount,
-          datePayment: paymentDate,
-          idPrestation,
-          idPaymentMethod: PaymentMethod.DIRECT_DEBIT.id,
-          closingDate: exerciceEndDate,
-        });
-        remainingAmountByExercicePrestation -= monthlyAmountRounded; 
-        paymentDate = dayjs(paymentDate).add(1, 'month').startOf('month').toDate();
-      }
-      exerciceEndDate = dayjs(exerciceEndDate).startOf('month').add(1, 'year').endOf('month').toDate();
+      listPayments.push({
+        amount: Math.round(100 * amount) / 100,
+        datePayment: paymentDate,
+        idPrestation,
+        idPaymentMethod: PaymentMethod.DIRECT_DEBIT.id,
+        closingDate: exerciceEndDate,
+      });
+      remainingAmountByExercicePrestation -= monthlyAmount; 
+      paymentDate = dayjs(paymentDate).add(1, 'month').startOf('month').toDate();
     }
-    nbExoNonExpressGenerated += 1;
-
-    remainingAmount = 0;
+    exerciceEndDate = dayjs(exerciceEndDate).startOf('month').add(1, 'year').endOf('month').toDate();
   }
 
+  remainingAmount = 0;
+
   // =========================
   //    JUSQU'EN DECEMBRE
   // =========================
-  //On compte le nb d'exercices restants entre la date à laquelle le paiement va être créé et la date de fin d'exercice
-  // let countMonthsBeforeExerciceEnd = Math.ceil(dayjs(exerciceEndDate).diff(paymentDate, 'months', true)); //Logiquement, 12
-  // if (countMonthsBeforeExerciceEnd < 3) countMonthsBeforeExerciceEnd = 3;
+  // On applique le taux de tva de la société, si besoin, selon la grille tarifaire
+  remainingAmount += priceWithTaxesIncluded ? nextYearlyAmountNonExpress : getTaxesIncludedAmount(nextYearlyAmountNonExpress, idVat);
 
-  remainingAmount += yearlyAmountNonExpress;
-  const remainingAmountByExercicePrestation = remainingAmount;
-  const monthlyAmountRounded = Math.round(100 * remainingAmountByExercicePrestation / 12) / 100;
+  remainingAmountByExercicePrestation = remainingAmount;
+  //On compte le nb de mois restants entre la date à laquelle le paiement va être créé et la date de fin d'exercice
+  countMonthsBeforeExerciceEnd = Math.ceil(dayjs(exerciceEndDate).diff(paymentDate, 'months', true));
+  if (countMonthsBeforeExerciceEnd < 3) countMonthsBeforeExerciceEnd = 3;
+
+  // - frais d'application dès les second exo non express
+  remainingAmountByExercicePrestation += applicationCostTotalTTC;
+  
+  monthlyAmount = remainingAmountByExercicePrestation / countMonthsBeforeExerciceEnd;
   
   // Si aucun paiement généré, on stoppe là
   if (!listPayments.length) return [];
 
-  while (dayjs(listPayments.slice(-1)[0].datePayment).month() < 11) {
-    let amount = monthlyAmountRounded;
-      
+  while (dayjs(listPayments.slice(-1)[0].datePayment).month() < 11 || !isApplicationAlreadyPaid) {
+    let amount = monthlyAmount;
+
     // Si besoin, on applique les frais nécessaires :
     // - 2,75% d'augmentation chaque année, sauf si souscriptiuon dans les 3 derniers mois de l'année civile)
     // - frais d'application dès les second exo non express
-    amount = calculateFees(amount, goToClient, paymentDate, nbExoNonExpressGenerated, idVat);
-    
-    // On applique le taux de tva de la société
-    amount = getTaxesIncludedAmount(amount, idVat);
+    amount = calculateFees(amount, goToClient, paymentDate);
 
     listPayments.push({
-      amount,
+      amount: Math.round(100 * amount) / 100,
       datePayment: paymentDate,
       idPrestation,
       idPaymentMethod: PaymentMethod.DIRECT_DEBIT.id,
       closingDate: exerciceEndDate,
     });
     paymentDate = dayjs(paymentDate).add(1, 'month').startOf('month').toDate();
+    isApplicationAlreadyPaid = true;
   }
 
   return listPayments;

package/ts/utils/prestation.ts

@@ -19,6 +19,8 @@ type priceGridBrand = {
 
 type priceGrid = {
   idPrestationList: number[],
+  priceWithTaxesIncluded: boolean,
+  applicationCost: number,
   monthlyNbr?: monthlyNbr[],
   exerciceNbr?: exerciceNbr[],
   turnoverCreatedYear?: turnover[],
@@ -136,7 +138,7 @@ const calculateScoringOfPrestation = (idPrestationType: PrestationType, prestati
   return numberPoint;
 };
 
-const getPriceGrid = (idTypeBrand: number, idPrestationList: number): priceGrid | undefined => {
+export const getPriceGrid = (idTypeBrand: number, idPrestationList: number): priceGrid | undefined => {
   let currentBrandPriceGrid: priceGridBrand | undefined;
   let currentPriceGrid: priceGrid | undefined;
 

package/ts/utils/tests/payment.spec.ts

@@ -10,6 +10,7 @@ describe('Payment', () => {
     const idPrestation = 1;
     const idSociety = 1;
     const yearlyAmountNonExpress = 1800;
+    const nextYearlyAmountNonExpress = 1800;
     const appCost = 14.9;
 
     const firstExerciceNonExpresssEndDate = dayjs().add(11, 'month').endOf('month').toDate(); 
@@ -78,7 +79,8 @@ describe('Payment', () => {
       try {
         prestationList.hidden = true;
         calculatePaymentsAuto({ 
-          goToClient: dayjs().toDate(),
+          idTypeBrand: 1,
+          goToClient: dayjs('2024-06-06').toDate(),
           firstExerciceNonExpresssEndDate, 
           idPrestation,
           prestationList: {
@@ -88,7 +90,8 @@ describe('Payment', () => {
           idVat,
           listPartialExercicePrestationExpress,
           listRegulations,
-          yearlyAmountNonExpress });
+          yearlyAmountNonExpress,
+          nextYearlyAmountNonExpress });
       } catch (error) {
         expect(error).toBeInstanceOf(Error);
         // @ts-ignore
@@ -99,14 +102,16 @@ describe('Payment', () => {
       expect.assertions(2);
       try {
         calculatePaymentsAuto({ 
-          goToClient: dayjs().toDate(),
+          idTypeBrand: 1,
+          goToClient: dayjs('2024-06-06').toDate(),
           firstExerciceNonExpresssEndDate, 
           idPrestation,
           prestationList,
           idVat,
           listPartialExercicePrestationExpress,
           listRegulations: [],
-          yearlyAmountNonExpress });
+          yearlyAmountNonExpress,
+          nextYearlyAmountNonExpress });
       } catch (error) {
         expect(error).toBeInstanceOf(Error);
         // @ts-ignore
@@ -117,14 +122,16 @@ describe('Payment', () => {
       expect.assertions(2);
       try {
         calculatePaymentsAuto({ 
-          goToClient: dayjs().toDate(),
+          idTypeBrand: 1,
+          goToClient: dayjs('2024-06-06').toDate(),
           firstExerciceNonExpresssEndDate, 
           idPrestation,
           prestationList,
           idVat,
           listPartialExercicePrestationExpress,
           listRegulations: [{ processed: true } as IRegulation],
-          yearlyAmountNonExpress });
+          yearlyAmountNonExpress,
+          nextYearlyAmountNonExpress });
       } catch (error) {
         expect(error).toBeInstanceOf(Error);
         // @ts-ignore
@@ -138,14 +145,16 @@ describe('Payment', () => {
     // express
     test('if only one express, monthly payments of actual exo should be in parallel of express monthly payments, smoothed in number of remaining months (mini 3 months) (if not in 3 last month)', async () => {
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
         idVat,
         listPartialExercicePrestationExpress: [listPartialExercicePrestationExpress[0]],
         listRegulations,
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
 
       const firstExpressDatePayment = payments.filter(p => dayjs(p.closingDate).diff(firstExerciceNonExpresssEndDate) < 0)[0].datePayment;
       const firstNonExpressDatePayment = payments.filter(p => dayjs(p.closingDate).diff(firstExerciceNonExpresssEndDate) === 0)[0].datePayment;
@@ -153,14 +162,16 @@ describe('Payment', () => {
     });
     test('if more than one express, monthly payments of actual exo should be in a row of express monthly payments and smoothed, smoothed in number of remaining months after express monthly payments (mini 3 months) (if in 3 last month of exercice)', async () => {
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
         idVat,
         listPartialExercicePrestationExpress,
         listRegulations,
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
 
       const lastExpressDatePayment = payments.filter(p => dayjs(p.closingDate).diff(firstExerciceNonExpresssEndDate) < 0).splice(-1)?.[0]?.datePayment;
       const firstNonExpressDatePayment = payments.filter(p => dayjs(p.closingDate).diff(firstExerciceNonExpresssEndDate) === 0)?.[0]?.datePayment;
@@ -175,7 +186,8 @@ describe('Payment', () => {
       const newFirstExerciceNonExpresssEndDate = dayjs().add(nbMonthDelay, 'month').endOf('month').toDate();
 
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
@@ -185,7 +197,8 @@ describe('Payment', () => {
           amount: 50,
           amountUsed: 0,
         } as IRegulation],
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
 
       // const listNonExpressPayments = payments.filter(p => p.closingDate === newFirstExerciceNonExpresssEndDate);
       const listNonExpressPayments = payments.filter(p => dayjs(p.closingDate).diff(newFirstExerciceNonExpresssEndDate) === 0);
@@ -198,7 +211,8 @@ describe('Payment', () => {
       const newFirstExerciceNonExpresssEndDate = dayjs().add(nbMonthDelay, 'month').endOf('month').toDate();
 
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
@@ -208,7 +222,8 @@ describe('Payment', () => {
           amount: 50,
           amountUsed: 0,
         } as IRegulation],
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
 
       const listNonExpressPayments = payments.filter(p => dayjs(p.closingDate).diff(newFirstExerciceNonExpresssEndDate) === 0);
       expect(listNonExpressPayments.length).toStrictEqual(3);
@@ -224,14 +239,16 @@ describe('Payment', () => {
         amountUsed: 0,
       } as IRegulation];
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
         idVat,
         listPartialExercicePrestationExpress: [],
         listRegulations: newListRegulations,
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
         
       const diff = yearlyAmountNonExpress - newListRegulations.reduce((acc, r:IRegulation) => acc + r.amount - r.amountUsed, 0);
       const amount = Math.round(100 * diff / nbMonthDelay) / 100;
@@ -248,14 +265,16 @@ describe('Payment', () => {
         amountUsed: 0,
       } as IRegulation];
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
         idVat,
         listPartialExercicePrestationExpress: [],
         listRegulations: newListRegulations,
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
 
       const diff = yearlyAmountNonExpress - newListRegulations.reduce((acc, r:IRegulation) => acc + r.amount - r.amountUsed, 0);
       const amount = Math.round(100 * diff / 3) / 100;
@@ -270,7 +289,8 @@ describe('Payment', () => {
       const newFirstExerciceNonExpresssEndDate = dayjs().add(11, 'month').endOf('month').toDate();
 
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
@@ -280,7 +300,8 @@ describe('Payment', () => {
           amount: 50,
           amountUsed: 0,
         } as IRegulation],
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
 
       const listNonExpressPayments = payments.filter(p => dayjs(p.closingDate).diff(newFirstExerciceNonExpresssEndDate) === 0);
       expect(Math.round(100 * listNonExpressPayments[0].amount * 1.0275) / 100).toStrictEqual(listNonExpressPayments.splice(-2)[0].amount);
@@ -294,7 +315,8 @@ describe('Payment', () => {
       const newFirstExerciceNonExpresssEndDate = dayjs().add(11, 'month').endOf('month').toDate();
   
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
@@ -304,7 +326,8 @@ describe('Payment', () => {
           amount: 50,
           amountUsed: 0,
         } as IRegulation],
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
   
       const listNonExpressPayments = payments.filter(p => dayjs(p.datePayment).diff(dayjs('2025-06-01')) === 0);
       expect(listNonExpressPayments[0].amount).toStrictEqual(listNonExpressPayments.splice(-2)[0].amount);
@@ -319,7 +342,8 @@ describe('Payment', () => {
       const newFirstExerciceNonExpresssEndDate = dayjs().add(12, 'month').endOf('month').toDate();
   
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
@@ -329,7 +353,8 @@ describe('Payment', () => {
           amount: 50,
           amountUsed: 50,
         } as IRegulation],
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
   
       const paymentsOfFirstExo = payments.filter(p => dayjs(p.datePayment).diff(dayjs('2025-06-01')) === 0).splice(-1)[0].amount ?? 0;
       const paymentsOfSecondExo = payments.filter(p => dayjs(p.datePayment).diff(dayjs('2025-07-01')) === 0).splice(-1)[0].amount ?? 0;
@@ -350,14 +375,16 @@ describe('Payment', () => {
         startDate: dayjs().startOf('month').toDate(), 
       };
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
         idVat,
         listPartialExercicePrestationExpress: listPartialExercicePrestationExpressCloned,
         listRegulations,
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
       expect(payments.length).toBeGreaterThanOrEqual(4);
       expect(dayjs(payments[payments.length - 1].datePayment).diff(dayjs(payments?.[0]?.datePayment), 'month')).toBeGreaterThan(0);
     });
@@ -366,7 +393,8 @@ describe('Payment', () => {
       MockDate.set(mockedDate);
 
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
@@ -380,7 +408,8 @@ describe('Payment', () => {
           idPaymentMethod: PaymentMethod.BANK_CARD.id,
           idSociety,
         }],
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
       expect(payments.length).toBeGreaterThanOrEqual(2);
       expect(payments[0]).toMatchObject(
         {
@@ -403,14 +432,16 @@ describe('Payment', () => {
       MockDate.set(mockedDate);
 
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
         idVat,
         listPartialExercicePrestationExpress,
         listRegulations,
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
       expect(payments.length).toBeGreaterThanOrEqual(4);
       expect(payments?.[0]?.datePayment).toStrictEqual(dayjs(mockedDate).add(2, 'month').startOf('month').toDate());
       MockDate.reset();
@@ -420,32 +451,37 @@ describe('Payment', () => {
       MockDate.set(mockedDate);
 
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
         idVat,
         listPartialExercicePrestationExpress,
         listRegulations,
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
       expect(payments.length).toBeGreaterThanOrEqual(4);
       expect(dayjs(payments[payments.length - 1].datePayment).month()).toStrictEqual(11);
     });
     test('first payment and last payment should have at least one year difference (ex. : 23 - 24)', async () => {
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate, 
         idPrestation,
         prestationList,
         idVat,
         listPartialExercicePrestationExpress: [],
         listRegulations,
-        yearlyAmountNonExpress });
+        yearlyAmountNonExpress,
+        nextYearlyAmountNonExpress });
       expect(dayjs(payments.slice(-1)?.[0]?.datePayment).diff(dayjs(payments?.[0]?.datePayment), 'year', true)).toBeGreaterThan(1);
     });
     test('real case : idSociety 114440', async () => {
       const payments = calculatePaymentsAuto({ 
-        goToClient: dayjs().toDate(),
+        idTypeBrand: 1,
+        goToClient: dayjs('2024-06-06').toDate(),
         firstExerciceNonExpresssEndDate: dayjs('2024-12-31').toDate(), 
         idPrestation,
         prestationList,
@@ -459,7 +495,7 @@ describe('Payment', () => {
           idPaymentMethod: PaymentMethod.BANK_CARD.id,
           idSociety,
         }],
-        yearlyAmountNonExpress: 1433 });
+        yearlyAmountNonExpress: 1433, nextYearlyAmountNonExpress: 1433 });
       expect(dayjs(payments.slice(-1)?.[0]?.datePayment).diff(dayjs(payments?.[0]?.datePayment), 'year', true)).toBeGreaterThan(1);
     });
   });