@silexpert/core 1.1.304 → 1.1.306

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

@@ -0,0 +1,466 @@
+import * as dayjs from 'dayjs';
+import { IRegulation, Vat, PaymentMethod } from '../../types';
+import MockDate from 'mockdate';
+
+import { calculatePaymentsAuto } from '../payment';
+import { PartialExercicePrestationExpress } from '../../types/Interface/api/payment/Util';
+
+describe('Payment', () => {
+  describe('calculatePayments', () => {
+    const idPrestation = 1;
+    const idSociety = 1;
+    const yearlyAmountNonExpress = 1800;
+    const appCost = 14.9;
+
+    const firstExerciceNonExpresssEndDate = dayjs().add(11, 'month').endOf('month').toDate(); 
+    const prestationList = {
+      id: 34,
+      name: 'Compta Pro',
+      isComptable: true,
+      isJuridique: false,
+      isSocial: false,
+      isAttestation: false,
+      inAverageCart: true,
+      isBack: false,
+      minimumPrice: null,
+      price: null,
+      isCatalog: false,
+      isPlannable: false,
+      hidden: false,
+      isComplementary: false,
+      signaturePosition: '400,54,569,90',
+      signaturePage: 7,
+    };
+    const idVat = Vat.TX_10.id;
+    const vatRate = Object.values(Vat).find(v => v.id === idVat)?.value ?? 20;
+    const listPartialExercicePrestationExpress:PartialExercicePrestationExpress[] = [
+      {
+        startDate: dayjs().subtract(2, 'year').startOf('month').toDate(), 
+        endDate: dayjs().subtract(13, 'month').endOf('month').toDate(), 
+        countExpressMonthlyPayment: 2,
+        totalAmount: 1200,
+      },
+      {
+        startDate: dayjs().subtract(1, 'year').startOf('month').toDate(), 
+        endDate: dayjs().subtract(1, 'month').endOf('month').toDate(), 
+        countExpressMonthlyPayment: 2,
+        totalAmount: 1800,
+      },
+    ];
+    const listRegulations:IRegulation[] = [{
+      amount: 600,
+      amountUsed: 0,
+      date: new Date(),
+      processed: true,
+      idPaymentMethod: PaymentMethod.BANK_CARD.id,
+      idSociety,
+    }, {
+      amount: 300,
+      amountUsed: 0,
+      date: new Date(),
+      processed: true,
+      idPaymentMethod: PaymentMethod.BANK_CARD.id,
+      idSociety,
+    }, {
+      amount: 300,
+      amountUsed: 300,
+      date: new Date(),
+      processed: true,
+      idPaymentMethod: PaymentMethod.BANK_CARD.id,
+      idSociety,
+    }];
+
+    // =====================
+    // errors handling
+    // =====================
+    test('should return error if prestationList doesn\'t correspond (!hidden, isCatalog, isComptable)', () => {
+      expect.assertions(2);
+      try {
+        prestationList.hidden = true;
+        calculatePaymentsAuto({ 
+          goToClient: dayjs().toDate(),
+          firstExerciceNonExpresssEndDate, 
+          idPrestation,
+          prestationList: {
+            ...prestationList,
+            isCatalog: true,
+          },
+          idVat,
+          listPartialExercicePrestationExpress,
+          listRegulations,
+          yearlyAmountNonExpress });
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        // @ts-ignore
+        expect(error.message).toStrictEqual('Ce type de prestation ne correspond pas aux conditions attendues.');
+      }
+    });
+    test('should return error if listRegulations is empty', () => {
+      expect.assertions(2);
+      try {
+        calculatePaymentsAuto({ 
+          goToClient: dayjs().toDate(),
+          firstExerciceNonExpresssEndDate, 
+          idPrestation,
+          prestationList,
+          idVat,
+          listPartialExercicePrestationExpress,
+          listRegulations: [],
+          yearlyAmountNonExpress });
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        // @ts-ignore
+        expect(error.message).toStrictEqual('List of regulations can not be empty');
+      }
+    });
+    test('should listRegulations contain amount and amountUsed', () => {
+      expect.assertions(2);
+      try {
+        calculatePaymentsAuto({ 
+          goToClient: dayjs().toDate(),
+          firstExerciceNonExpresssEndDate, 
+          idPrestation,
+          prestationList,
+          idVat,
+          listPartialExercicePrestationExpress,
+          listRegulations: [{ processed: true } as IRegulation],
+          yearlyAmountNonExpress });
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        // @ts-ignore
+        expect(error.message).toStrictEqual('Amount and amountUsed are missing for regulations');
+      }
+    });
+
+    // =====================
+    // logical
+    // =====================
+    // 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(),
+        firstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: [listPartialExercicePrestationExpress[0]],
+        listRegulations,
+        yearlyAmountNonExpress });
+
+      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;
+      expect(dayjs(firstNonExpressDatePayment).diff(firstExpressDatePayment, 'month')).toStrictEqual(0);
+    });
+    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(),
+        firstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress,
+        listRegulations,
+        yearlyAmountNonExpress });
+
+      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;
+      expect(dayjs(firstNonExpressDatePayment).diff(lastExpressDatePayment, 'month')).toStrictEqual(1);
+    });
+    // non express
+    test('should return a number of payments equal to nb of remaining months in exercice (if not in 3 last months)', async () => {
+      const mockedDate = dayjs('2024-05-15').toDate();
+      MockDate.set(mockedDate);
+      
+      const nbMonthDelay = 6;
+      const newFirstExerciceNonExpresssEndDate = dayjs().add(nbMonthDelay, 'month').endOf('month').toDate();
+
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: [],
+        listRegulations: [{
+          amount: 50,
+          amountUsed: 0,
+        } as IRegulation],
+        yearlyAmountNonExpress });
+
+      // const listNonExpressPayments = payments.filter(p => p.closingDate === newFirstExerciceNonExpresssEndDate);
+      const listNonExpressPayments = payments.filter(p => dayjs(p.closingDate).diff(newFirstExerciceNonExpresssEndDate) === 0);
+      expect(listNonExpressPayments.length).toStrictEqual(nbMonthDelay);
+      
+      MockDate.reset();
+    });
+    test('should return a number of payments equal to 3 (if in 3 last month of exercice)', async () => {
+      const nbMonthDelay = 1;
+      const newFirstExerciceNonExpresssEndDate = dayjs().add(nbMonthDelay, 'month').endOf('month').toDate();
+
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: [],
+        listRegulations: [{
+          amount: 50,
+          amountUsed: 0,
+        } as IRegulation],
+        yearlyAmountNonExpress });
+
+      const listNonExpressPayments = payments.filter(p => dayjs(p.closingDate).diff(newFirstExerciceNonExpresssEndDate) === 0);
+      expect(listNonExpressPayments.length).toStrictEqual(3);
+    });
+    test('should (yearlyAmountNonExpress - sum of listRegulations) / count of monthly payments be equal to monthly payment amount (if not in 3 last month)', async () => {
+      const mockedDate = dayjs('2024-05-15').toDate();
+      MockDate.set(mockedDate);
+      
+      const nbMonthDelay = 6;
+      const newFirstExerciceNonExpresssEndDate = dayjs().add(nbMonthDelay, 'month').endOf('month').toDate();
+      const newListRegulations = [{
+        amount: 50,
+        amountUsed: 0,
+      } as IRegulation];
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: [],
+        listRegulations: newListRegulations,
+        yearlyAmountNonExpress });
+        
+      const diff = yearlyAmountNonExpress - newListRegulations.reduce((acc, r:IRegulation) => acc + r.amount - r.amountUsed, 0);
+      const amount = Math.round(100 * diff / nbMonthDelay) / 100;
+
+      expect(payments[0].amount).toStrictEqual(Math.round(100 * amount * ((100 + vatRate) / 100)) / 100);
+      
+      MockDate.reset();
+    });
+    test('should (totalAmount - firstPaymentAmount) / 3 be equal to monthly payment amount (if in 3 last month of exercice)', async () => {
+      const nbMonthDelay = 1;
+      const newFirstExerciceNonExpresssEndDate = dayjs().add(nbMonthDelay, 'month').endOf('month').toDate();
+      const newListRegulations = [{
+        amount: 50,
+        amountUsed: 0,
+      } as IRegulation];
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: [],
+        listRegulations: newListRegulations,
+        yearlyAmountNonExpress });
+
+      const diff = yearlyAmountNonExpress - newListRegulations.reduce((acc, r:IRegulation) => acc + r.amount - r.amountUsed, 0);
+      const amount = Math.round(100 * diff / 3) / 100;
+
+      expect(payments[0].amount).toStrictEqual(Math.round(100 * amount * ((100 + vatRate) / 100)) / 100);
+    });
+    // annual price increase
+    test('should apply annual price increase (2,75%) if signed before last 3 months of civil year', async () => {
+      const mockedDate = dayjs('2024-08-15').toDate();
+      MockDate.set(mockedDate);
+
+      const newFirstExerciceNonExpresssEndDate = dayjs().add(11, 'month').endOf('month').toDate();
+
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: [],
+        listRegulations: [{
+          amount: 50,
+          amountUsed: 0,
+        } as IRegulation],
+        yearlyAmountNonExpress });
+
+      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);
+
+      MockDate.reset();
+    });
+    test('should not apply annual price increase (2,75%) if signed in last 3 months of civil year', async () => {
+      const mockedDate = dayjs('2024-11-15').toDate();
+      MockDate.set(mockedDate);
+  
+      const newFirstExerciceNonExpresssEndDate = dayjs().add(11, 'month').endOf('month').toDate();
+  
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: [],
+        listRegulations: [{
+          amount: 50,
+          amountUsed: 0,
+        } as IRegulation],
+        yearlyAmountNonExpress });
+  
+      const listNonExpressPayments = payments.filter(p => dayjs(p.datePayment).diff(dayjs('2025-06-01')) === 0);
+      expect(listNonExpressPayments[0].amount).toStrictEqual(listNonExpressPayments.splice(-2)[0].amount);
+  
+      MockDate.reset();
+    });
+
+    test('should apply 14,9€ HT increase for the second exercice created (only offered on first exo) (no rules for 3 last months)', async () => {
+      const mockedDate = dayjs('2024-06-15').toDate();
+      MockDate.set(mockedDate);
+  
+      const newFirstExerciceNonExpresssEndDate = dayjs().add(12, 'month').endOf('month').toDate();
+  
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate: newFirstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: [],
+        listRegulations: [{
+          amount: 50,
+          amountUsed: 50,
+        } as IRegulation],
+        yearlyAmountNonExpress });
+  
+      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;
+      expect(paymentsOfFirstExo + appCost * ((100 + vatRate) / 100)).toStrictEqual(paymentsOfSecondExo);
+  
+      MockDate.reset();
+    });
+    
+    // misc
+    test('should payments been generated sorted by exercices start date', async () => {
+      const listPartialExercicePrestationExpressCloned = [...listPartialExercicePrestationExpress];
+      listPartialExercicePrestationExpressCloned[0] = { 
+        ...listPartialExercicePrestationExpress[0],
+        startDate: dayjs().add(1, 'year').startOf('month').toDate(), 
+      };
+      listPartialExercicePrestationExpressCloned[1] = { 
+        ...listPartialExercicePrestationExpress[1],
+        startDate: dayjs().startOf('month').toDate(), 
+      };
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: listPartialExercicePrestationExpressCloned,
+        listRegulations,
+        yearlyAmountNonExpress });
+      expect(payments.length).toBeGreaterThanOrEqual(4);
+      expect(dayjs(payments[payments.length - 1].datePayment).diff(dayjs(payments?.[0]?.datePayment), 'month')).toBeGreaterThan(0);
+    });
+    test('if regulations are bigger than sum exercice prestation amounts, should pass some exercice payments', async () => {
+      const mockedDate = dayjs('2024-03-15').toDate();
+      MockDate.set(mockedDate);
+
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress,
+        listRegulations: [{
+          amount: 2000,
+          amountUsed: 0,
+          date: new Date(),
+          processed: true,
+          idPaymentMethod: PaymentMethod.BANK_CARD.id,
+          idSociety,
+        }],
+        yearlyAmountNonExpress });
+      expect(payments.length).toBeGreaterThanOrEqual(2);
+      expect(payments[0]).toMatchObject(
+        {
+          amount: 550,
+          datePayment: dayjs(mockedDate).add(1, 'month').startOf('month').toDate(),
+          idPrestation: 1,
+          idPaymentMethod: 1,
+        });
+      expect(payments[1]).toMatchObject(
+        {
+          amount: 550,
+          datePayment: dayjs(mockedDate).add(2, 'month').startOf('month').toDate(),
+          idPrestation: 1,
+          idPaymentMethod: 1,
+        });
+      MockDate.reset();
+    });
+    test('should not consider actual month if signed in last 3 days of month', async () => {
+      const mockedDate = dayjs('2024-03-29').toDate();
+      MockDate.set(mockedDate);
+
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress,
+        listRegulations,
+        yearlyAmountNonExpress });
+      expect(payments.length).toBeGreaterThanOrEqual(4);
+      expect(payments?.[0]?.datePayment).toStrictEqual(dayjs(mockedDate).add(2, 'month').startOf('month').toDate());
+      MockDate.reset();
+    });
+    test('last payment returned should be last of a year (12/XX)', async () => {
+      const mockedDate = dayjs('2024-03-29').toDate();
+      MockDate.set(mockedDate);
+
+      const payments = calculatePaymentsAuto({ 
+        goToClient: dayjs().toDate(),
+        firstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress,
+        listRegulations,
+        yearlyAmountNonExpress });
+      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(),
+        firstExerciceNonExpresssEndDate, 
+        idPrestation,
+        prestationList,
+        idVat,
+        listPartialExercicePrestationExpress: [],
+        listRegulations,
+        yearlyAmountNonExpress });
+      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(),
+        firstExerciceNonExpresssEndDate: dayjs('2024-12-31').toDate(), 
+        idPrestation,
+        prestationList,
+        idVat: Vat.TX_20.id,
+        listPartialExercicePrestationExpress: [],
+        listRegulations: [{
+          amount: 1006.8,
+          amountUsed: 0,
+          date: dayjs('2024-06-06').toDate(), 
+          processed: false,
+          idPaymentMethod: PaymentMethod.BANK_CARD.id,
+          idSociety,
+        }],
+        yearlyAmountNonExpress: 1433 });
+      expect(dayjs(payments.slice(-1)?.[0]?.datePayment).diff(dayjs(payments?.[0]?.datePayment), 'year', true)).toBeGreaterThan(1);
+    });
+  });
+});

package/ts/utils/vat/utils.ts

@@ -58,4 +58,20 @@ export function textFormatting(value: any, length: number | null = null): string
     return formattedValue;
   }
   return null;
+}
+
+export function getTaxesIncludedAmount(amountHt: number, idVat: number, isRounded = true) {
+  const vatRate = Object.values(Vat).find(v => v.id === idVat)?.value ?? 20;
+  const amountNotRounded = amountHt * ((100 + vatRate) / 100);
+  
+  if (!isRounded) return amountNotRounded;
+  return Math.round(amountNotRounded * 100) / 100 ?? 0;
+}
+
+export function getTaxesExcludedAmount(amountTtc: number, idVat: number, isRounded = true) {
+  const vatRate = Object.values(Vat).find(v => v.id === idVat)?.value ?? 20;
+  const amountNotRounded = amountTtc / ((100 + vatRate) / 100);
+  
+  if (!isRounded) return amountNotRounded;
+  return Math.round(amountNotRounded * 100) / 100 ?? 0;
 }