@silexpert/core 1.1.304 → 1.1.306

package/ts/api/resources/IntermediateManagementRebate.ts

@@ -12,7 +12,12 @@ export class IntermediateManagementRebate extends Resource {
   }
 
   getFile(idExercice: number): Promise<Buffer> {
-    return this.axios.$get(`/exercices/${idExercice}/intermediate-management-rebates/file`);
+    return this.axios.$get(`/exercices/${idExercice}/intermediate-management-rebates/file`, {
+      responseType: 'arraybuffer',
+      headers: {
+        Accept: 'application/pdf',
+      },
+    });
   }
 
 }

package/ts/api/resources/Payment.ts

@@ -1,5 +1,5 @@
 import { Resource } from '../Resource';
-import { CreateNotifyCustomer, IPayment, QueryMonthlyPayment, QueryPayment, QueryPaymentCsv, QuerySocietyUnpaid, ReadPaid, ReadStatPrestation, ReadStatsSocietyUnpaid } from '../../types';
+import { CreateNotifyCustomer, CreatePaymentsAutoBilling, IPayment, QueryMonthlyPayment, QueryPayment, QueryPaymentCsv, QuerySocietyUnpaid, ReadPaid, ReadStatPrestation, ReadStatsSocietyUnpaid } from '../../types';
 
 export class Payment extends Resource {
   getMonthlyCsv(query: QueryMonthlyPayment): Promise<void> {
@@ -53,4 +53,8 @@ export class Payment extends Resource {
       params: payload,
     });
   }
+
+  generateForAutoBilling(payload: CreatePaymentsAutoBilling): Promise<ReadStatsSocietyUnpaid[]> {
+    return this.axios.$post('payment/auto-billing', payload);
+  }
 }

package/ts/types/Enum/JobTitle.ts

@@ -31,6 +31,7 @@ export enum JobTitle {
   TERMINATION = 30,
   LITIGE = 31,
   DATA_OFFICER = 32,
+  PROJECT_MANAGER = 33,
 }
 
 export const JobTitleList: Array<{ id: JobTitle; menText: string, womenText: string }> = [
@@ -194,4 +195,9 @@ export const JobTitleList: Array<{ id: JobTitle; menText: string, womenText: str
     menText: 'Aide Comptable',
     womenText: 'Aide Comptable',
   },
+  {
+    id: JobTitle.PROJECT_MANAGER,
+    menText: 'Chef de projet',
+    womenText: 'Cheffe de projet',
+  },
 ];

package/ts/types/Interface/api/authentification/ConnectFromSSO.ts

@@ -0,0 +1,8 @@
+import { IsInt } from 'class-validator';
+import { ApiProperty } from '../../../../utils';
+
+export class ConnectFromSSO {
+  @ApiProperty()
+  @IsInt()
+    idUser: number;
+}

package/ts/types/Interface/api/exercice/QueryExercice.ts

@@ -28,4 +28,12 @@ export class QueryExercice {
   @ToBoolean()
   @IsOptional()
     close?: boolean;
+}
+
+export class QuerySocietyExercice {
+  @ApiPropertyOptional()
+  @IsBoolean()
+  @ToBoolean()
+  @IsOptional()
+    paranoid?: boolean;
 }

package/ts/types/Interface/api/exercice/UpdateExercice.ts

@@ -89,4 +89,10 @@ export class UpdateExercice {
   @ToBoolean()
   @IsOptional()
     isDefault?: boolean;
+
+  @ApiPropertyOptional()
+  @IsBoolean()
+  @ToBoolean()
+  @IsOptional()
+    close?: boolean;
 }

package/ts/types/Interface/api/payment/Params.ts

@@ -0,0 +1,9 @@
+import { IsInt, IsOptional } from 'class-validator';
+import { ApiPropertyOptional } from '../../../../utils';
+
+export class CreatePaymentsAutoBilling {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsInt()
+    idSociety?: number;
+}

package/ts/types/Interface/api/payment/Util.ts

@@ -0,0 +1,26 @@
+import { IPrestationList, IRegulation } from '../../..';
+
+export interface PartialExercicePrestationExpress {
+  startDate: Date;
+  endDate: Date;
+  countExpressMonthlyPayment: number | null;    // if null, non express | if not null, express
+  totalAmount: number
+}
+export interface ParamsForPaymentsAuto {
+  firstExerciceNonExpresssEndDate: Date;
+  goToClient: Date;
+  idPrestation: number;
+  idVat: number;
+  prestationList: IPrestationList;
+  yearlyAmountNonExpress: number;
+  listPartialExercicePrestationExpress: PartialExercicePrestationExpress[];
+  listRegulations: IRegulation[];
+}
+
+export interface PaymentAuto {
+  amount: number;
+  datePayment: Date;
+  idPrestation: number;
+  idPaymentMethod: number;
+  closingDate: Date;
+}

package/ts/types/Interface/api/society/QueryPaginatedSociety.ts

@@ -30,4 +30,10 @@ export class QueryPaginatedSociety {
   @IsOptional()
   @IsNumber()
     page?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  @ToBoolean()
+    onlyOwners? = true;
 }

package/ts/types/Interface/api/user/ParamsGetAllUserWithRoles.ts

@@ -25,7 +25,7 @@ export class ParamsGetAllUserWithRoles {
   @IsString({
     each: true,
   })
-  @IsIn(['permissions'], { each: true })
+  @IsIn(['permissions', 'businessPartners'], { each: true })
     includes?: string[];
 
   @ApiPropertyOptional()

package/ts/types/Interface/models/IExercicePrestation.ts

@@ -12,6 +12,7 @@ export interface IExercicePrestation {
   amountSocial: number | null;
   monthOffers: number | null;
   isInCA: boolean;
+  countExpressMonthlyPayment: number | null;
   idBalanceSheet: number | null;
   createdAt?: Date | null;
   updatedAt?: Date | null;

package/ts/types/Interface/models/ISociety.ts

@@ -53,6 +53,7 @@ import {
   IAccountingFile,
   IThirdPartySociety,
   ICalendarEvent,
+  IRegulation,
 } from '../..';
 import { IBrandType } from './IBrandType';
 import { IFile } from './IFile';
@@ -222,6 +223,7 @@ export interface ISociety {
   userPermission?: IUserSocietyPermission;
   usersPermissions?: IUserSocietyPermission[];
   regulates?: IRegulate[];
+  regulations?: IRegulation[];
   brandType?: IBrandType;
   partneredAccountantCompaniesServices?: IPartneredAccountantCompanyService[];
   partneredAccountantRelated?: IPartneredAccountantToSociety;

package/ts/types/index.ts

@@ -548,6 +548,7 @@ export * from './Interface/api/adjustment/Query';
 export * from './Interface/api/adjustment/Read';
 export * from './Interface/api/vatDeclaration/ReadVatDeclaration';
 export * from './Interface/api/adjustment/Create';
+export * from './Interface/api/authentification/ConnectFromSSO';
 export * from './Interface/api/partnerTransactionType/ReadPartnerTransactionType';
 export * from './Interface/api/jeDeclare/ReadJeDeclare';
 export * from './Interface/api/aspone/ReadInterchange';
@@ -564,6 +565,8 @@ export * from './Interface/api/immobilization/ReadFormattedImmobilization';
 export * from './Interface/api/immobilization/CreateImmobilization';
 export * from './Interface/api/payment/QueryMonthlyPayment';
 export * from './Interface/api/payment/QueryPayment';
+export * from './Interface/api/payment/Params';
+export * from './Interface/api/payment/Util';
 export * from './Interface/api/payment/ReadPayment';
 export * from './Interface/api/payment/CreateNotifyCustomer';
 export * from './Interface/api/payment/CreateNotifyCustomerInvoice';

package/ts/utils/payment.ts

@@ -1,4 +1,8 @@
-import { IPayment } from '../types';
+'use strict';
+
+import { IPayment, IRegulation, ParamsForPaymentsAuto, PaymentMethod, PaymentAuto, getTaxesIncludedAmount } from '../types';
+import * as dayjs from 'dayjs';
+import { PartialExercicePrestationExpress } from '../types/Interface/api/payment/Util';
 
 interface PaymentsWithList extends IPayment {
   type: 'isComptable' | 'isJuridique' | 'isSocial' | 'isOther',
@@ -53,6 +57,194 @@ const groupPaymentsByServiceType = (payments: IPayment[], types: ('isComptable'
   return societyPayment;
 };
 
+const calculateFees = (amount: number, goToClient: Date, paymentDate: Date, nbExoNonExpressGenerated: number, idVat: number):number => {
+  const yearlyPriceIncreasing = 1.0275;
+  const appCost = getTaxesIncludedAmount(14.9, idVat);
+
+  const oneYearLessIfIn3LastMonthsOfYear = dayjs(goToClient).month() >= 9 ? 1 : 0;
+
+  if (dayjs(paymentDate).year() - dayjs().year() > 0) {
+    const nbYearsMore = dayjs(paymentDate).year() - dayjs().year() - oneYearLessIfIn3LastMonthsOfYear;
+    // on applique X fois l'augmentation
+    // ex. : si on lance l'appel en 2024, et qu'on génére un paiement pour 2026, on applique 2 fois l'augmentation
+    // soit amount * yearlyPriceIncreasing * yearlyPriceIncreasing
+    // 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;
+};
+
+/**
+//  * @param {number} firstPaymentAmount - amount of the first payment (first regulation of the customer)
+ * @param {Date} firstExerciceNonExpresssEndDate - end date of the first exercice non express
+ * @param {number} idPrestation - prestation id
+ * @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 {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 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();
+
+  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');
+  if (listPartialExercicePrestationExpress.length && listPartialExercicePrestationExpress?.some((ep: PartialExercicePrestationExpress) => !ep?.startDate)) throw new Error('Start date of some exercice are missing');
+  if (!listRegulations?.every((r: IRegulation) => !!r?.amount || !!r?.amountUsed)) throw new Error('Amount and amountUsed are missing for regulations');
+
+  const nbExoExpress = listPartialExercicePrestationExpress.length;
+  const listPayments:PaymentAuto[] = [];
+
+  // on récupère le/les premiers réglements effectués, non alloués
+  const sumRegulations = listRegulations.reduce((acc: number, r:IRegulation) => acc + r.amount - r.amountUsed, 0);
+  let remainingAmount = -sumRegulations;  //TTC
+  let paymentDate = initializedPaymentDate;
+
+  //On order les exercicePrestation par startDate ASC et id ASC
+  listPartialExercicePrestationExpress.sort((a, b) => {
+    const aStartDate = a?.startDate as Date;
+    const bStartDate = b?.startDate as Date;
+    return dayjs(aStartDate).diff(bStartDate);
+  });
+
+  //On ajoute un paiement initial correspondant à la somme des régulations
+  if (sumRegulations) {
+    listPayments.push({
+      amount:sumRegulations,  //TTC
+      datePayment: dayjs().toDate(),
+      idPrestation,
+      idPaymentMethod: PaymentMethod.DIRECT_DEBIT.id,
+      closingDate: listPartialExercicePrestationExpress?.length ? listPartialExercicePrestationExpress[0].endDate : firstExerciceNonExpresssEndDate,
+    });
+  }
+  
+  // =========================
+  //          EXPRESS
+  // =========================
+  listPartialExercicePrestationExpress.forEach((exercicePrestation:PartialExercicePrestationExpress) => {
+    remainingAmount += getTaxesIncludedAmount(exercicePrestation.totalAmount, idVat); //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
+    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
+      
+      listPayments.push({
+        amount,
+        datePayment: paymentDate,
+        idPrestation,
+        idPaymentMethod: PaymentMethod.DIRECT_DEBIT.id,
+        closingDate: exercicePrestation.endDate,
+      });
+      remainingAmountByExercicePrestation -= monthlyAmountRounded; 
+      paymentDate = dayjs(paymentDate).add(1, 'month').startOf('month').toDate();
+    }
+    remainingAmount = 0;
+  });
+
+  // =========================
+  //       NON EXPRESS
+  // =========================
+  // on lisse sur le nb de mois restants (avec au minimum 3 mensualités)
+  // 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);
+
+    let remainingAmountByExercicePrestation = remainingAmount;
+    const monthlyAmountRounded = Math.round(100 * remainingAmountByExercicePrestation / countMonthsBeforeExerciceEnd) / 100;  //TTC
+
+    if (monthlyAmountRounded > 0) {
+      for (let index = 1; index <= countMonthsBeforeExerciceEnd; index++) {
+        let amount = index < countMonthsBeforeExerciceEnd ? monthlyAmountRounded : Math.round(100 * remainingAmountByExercicePrestation) / 100;
+      
+        // 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);
+      
+        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();
+    }
+    nbExoNonExpressGenerated += 1;
+
+    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;
+
+  remainingAmount += yearlyAmountNonExpress;
+  const remainingAmountByExercicePrestation = remainingAmount;
+  const monthlyAmountRounded = Math.round(100 * remainingAmountByExercicePrestation / 12) / 100;
+  
+  // 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;
+      
+    // 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);
+
+    listPayments.push({
+      amount,
+      datePayment: paymentDate,
+      idPrestation,
+      idPaymentMethod: PaymentMethod.DIRECT_DEBIT.id,
+      closingDate: exerciceEndDate,
+    });
+    paymentDate = dayjs(paymentDate).add(1, 'month').startOf('month').toDate();
+  }
+
+  return listPayments;
+};
+
 export {
-  groupPaymentsByServiceType,
+  groupPaymentsByServiceType, calculatePaymentsAuto,
 };