@silexpert/core 1.1.305 → 1.1.307

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

@@ -0,0 +1,28 @@
+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 {
+  idTypeBrand: number;
+  firstExerciceNonExpresssEndDate: Date;
+  goToClient: Date;
+  idPrestation: number;
+  idVat: number;
+  prestationList: IPrestationList;
+  yearlyAmountNonExpress: number;
+  nextYearlyAmountNonExpress: 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/statistic/QueryInternal.ts

@@ -3,7 +3,7 @@ import {
 } from 'class-validator';
 import { ApiPropertyOptional } from '../../../../utils';
 
-export class QueryInternal {
+export class QueryInternalAccountant {
   @ApiPropertyOptional()
   @IsOptional()
   @IsBoolean()

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';
@@ -627,6 +630,7 @@ export * from './Interface/api/facturation/CreateRebilling';
 export * from './Interface/api/facturation/GoToFacturation';
 export * from './Interface/api/OnBoarding';
 export * from './Interface/api/commercial/QueryGetStats';
+export * from './Interface/api/commercial/QueryGetStatsHistory';
 export * from './Interface/api/commercial/RequiredDocsTypeParams';
 export * from './Interface/api/commercial/QueryFetchDialogDatasInfosOk';
 export * from './Interface/api/commercial/QueryMovePrestationsToNextMonth';

package/ts/utils/payment.ts

@@ -1,4 +1,9 @@
-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';
+import { getPriceGrid } from './prestation';
 
 interface PaymentsWithList extends IPayment {
   type: 'isComptable' | 'isJuridique' | 'isSocial' | 'isOther',
@@ -53,6 +58,199 @@ const groupPaymentsByServiceType = (payments: IPayment[], types: ('isComptable'
   return societyPayment;
 };
 
+const calculateFees = (amount: number, goToClient: Date, paymentDate: Date):number => {
+  const yearlyPriceIncreasing = 1.0275;
+
+  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);
+  }
+  return amount;
+};
+
+/**
+//  * @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 {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 { 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');
+  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, 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
+    //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++) {
+      // 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 ? monthlyAmount : remainingAmountByExercicePrestation;  //TTC
+      
+      listPayments.push({
+        amount: Math.round(100 * amount) / 100,
+        datePayment: paymentDate,
+        idPrestation,
+        idPaymentMethod: PaymentMethod.DIRECT_DEBIT.id,
+        closingDate: exercicePrestation.endDate,
+      });
+      remainingAmountByExercicePrestation -= monthlyAmount; 
+      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 exerciceEndDate = dayjs(firstExerciceNonExpresssEndDate).toDate();
+  
+  //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;
+  let monthlyAmount = remainingAmountByExercicePrestation / countMonthsBeforeExerciceEnd;  //TTC
+
+  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)
+      amount = calculateFees(amount, goToClient, paymentDate);
+      
+      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();
+    }
+    exerciceEndDate = dayjs(exerciceEndDate).startOf('month').add(1, 'year').endOf('month').toDate();
+  }
+
+  remainingAmount = 0;
+
+  // =========================
+  //    JUSQU'EN DECEMBRE
+  // =========================
+  // On applique le taux de tva de la société, si besoin, selon la grille tarifaire
+  remainingAmount += priceWithTaxesIncluded ? nextYearlyAmountNonExpress : getTaxesIncludedAmount(nextYearlyAmountNonExpress, idVat);
+
+  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 || !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);
+
+    listPayments.push({
+      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;
+};
+
 export {
-  groupPaymentsByServiceType,
+  groupPaymentsByServiceType, calculatePaymentsAuto,
 };

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;