@silexpert/core 2.0.125 → 2.0.126

package/ts/utils/date.ts

@@ -1,12 +1,12 @@
+import dayjs from 'dayjs';
+import timezone from 'dayjs/plugin/timezone.js';
+
 /**
  * @param dateStart Date format YYYY-MM-DD HH:mm:ss
  * @param dateEnd Date format YYYY-MM-DD HH:mm:ss
  * @returns object of time (09:00-10:00, 12:00-13:00 et 14:00-17:00)
  */
 import { DateInterval, TimeInterval } from '../types/index.js';
-import dayjs from 'dayjs';
-
-import timezone from 'dayjs/plugin/timezone.js';
 dayjs.extend(timezone);
 
 // TODO:UT

package/ts/utils/decorators/isE164PhoneNumber.decorator.ts

@@ -3,7 +3,9 @@ import { parsePhoneNumberFromString } from 'libphonenumber-js';
 
 @ValidatorConstraint({ name: 'isE164Phone', async: false })
 export class IsE164PhoneNumber implements ValidatorConstraintInterface {
-  validate(text: string) {
+  validate(text: unknown): boolean {
+    // class-validator runs every validator of the property: a missing or non-string value must not throw
+    if (typeof text !== 'string') return false;
     const phoneNumber = parsePhoneNumberFromString(text);
     return isDefined(phoneNumber) && phoneNumber.number === text && phoneNumber.isValid();
   }

package/ts/utils/documents.ts

@@ -1,7 +1,7 @@
-import { RequiredDocsType } from '../types/index.js';
+import dayjs from 'dayjs';
 import { GedFileType } from '../types/Enum/Ged.js';
 import { LegalForm } from '../types/Enum/LegalForm.js';
-import dayjs from 'dayjs';
+import { RequiredDocsType } from '../types/index.js';
 
 const requiredListDocs = (params: RequiredDocsType): GedFileType[] => {
   const { society, oldExpertInfo, isOnlyPrevi, isOnlyJuridic, isOnlySocial, isCreation, isConsultingHour, goToClient } =

package/ts/utils/email.ts

@@ -1,10 +1,10 @@
 import ejs from 'ejs';
 import { Role } from '../types/Enum/Role.js';
+import { IRole } from '../types/Interface/models/IRole.js';
 import { IUser } from '../types/Interface/models/IUser.js';
 import { getBrand, getBrandConfig } from './brands.js';
 import { signatureTemplate } from './email/templates/signature.js';
 import { intersection } from './noLodash.js';
-import { IRole } from '../types/Interface/models/IRole.js';
 
 function getRoleSignature(user: any) {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-return

package/ts/utils/exercice.ts

@@ -1,5 +1,5 @@
-import { IExercice } from '../types/index.js';
 import dayjs from 'dayjs';
+import { IExercice } from '../types/index.js';
 
 /**
  * Check if the recovery date is before the exercice start date (with a 3 month tolerance)

package/ts/utils/payment.ts

@@ -1,7 +1,7 @@
 'use strict';
 
-import { IPayment, IRegulation, ParamsForPaymentsAuto, PaymentMethod, PaymentAuto } from '../types/index.js';
 import dayjs from 'dayjs';
+import { IPayment, IRegulation, ParamsForPaymentsAuto, PaymentMethod, PaymentAuto } from '../types/index.js';
 import { PartialExercicePrestationExpress } from '../types/Interface/api/payment/Util.js';
 import { getPriceGrid } from './prestation.js';
 import { getTaxesIncludedAmount } from './vat/utils.js';

package/ts/utils/prestation.ts

@@ -1,21 +1,21 @@
-import { IExercice, IPrestation, IPrestationList } from '../types/index.js';
-import { Vat } from '../types/Enum/Vat.js';
-import { ReasonTerminationType } from '../types/Enum/ReasonTerminationType.js';
-import { intersection } from './noLodash.js';
+import dayjs from 'dayjs';
+import { ClosingType } from '../types/Enum/ClosingType.js';
+import { PrestationOptionType, PrestationOption } from '../types/Enum/PrestationOption.js';
 import {
   ClementineSubscriptionAccountancySoftwarePrestations,
   PrestationDetail,
   PrestationType,
 } from '../types/Enum/PrestationType.js';
-import { PrestationOptionType, PrestationOption } from '../types/Enum/PrestationOption.js';
 import { PriceGridClementine } from '../types/Enum/PriceGridClementine.js';
-import { PriceGridPourcentage } from '../types/Enum/PriceGridPourcentage.js';
 import { PriceGridLegalstart } from '../types/Enum/PriceGridLegalstart.js';
+import { PriceGridPourcentage } from '../types/Enum/PriceGridPourcentage.js';
 import { PriceGridStatutsExpress } from '../types/Enum/PriceGridStatutsExpress.js';
-import { ClosingType } from '../types/Enum/ClosingType.js';
+import { ReasonTerminationType } from '../types/Enum/ReasonTerminationType.js';
+import { Vat } from '../types/Enum/Vat.js';
+import { IExercice, IPrestation, IPrestationList } from '../types/index.js';
 import { getBrandNameByNodeEnv } from './brands.js';
-import dayjs from 'dayjs';
 import { exerciceNumber } from './exercice.js';
+import { intersection } from './noLodash.js';
 
 type priceGridBrand = {
   idTypeBrand: number;
@@ -262,9 +262,8 @@ const calculateScoringOfPrestation = (
   const prestationsExistIds = prestationsSignedPaid.map((prestation) => prestation.idPrestationList);
   const prestationHalfPriceAlreadyDoneIds = prestationsExistIds.filter((id) => prestationHalfPriceIds.includes(id));
 
-  // If one of the prestations already done is in the list of prestations that are half price and if the idPrestationType is in prestationHalfPriceIds, return 50% of points
-  if (prestationHalfPriceAlreadyDoneIds.length && prestationHalfPriceIds.includes(idPrestationType))
-    return Math.floor(numberPoint * 0.3);
+  // If one of the prestations already done is in the list of prestations that are half price and if the idPrestationType is in prestationHalfPriceIds, return upsell points (250)
+  if (prestationHalfPriceAlreadyDoneIds.length && prestationHalfPriceIds.includes(idPrestationType)) return 250;
 
   return numberPoint;
 };

package/ts/utils/quotation.ts

@@ -1,10 +1,10 @@
 import dayjs from 'dayjs';
-import { ForbidenDomain, BasicDomain } from '../types/Enum/MailDomainType.js';
 import { Activity } from '../types/Enum/Activity.js';
 import { ComptaType } from '../types/Enum/ComptaType.js';
-import { ISociety } from '../types/Interface/models/ISociety.js';
-import { ICotation } from '../types/Interface/models/ICotation.js';
+import { ForbidenDomain, BasicDomain } from '../types/Enum/MailDomainType.js';
 import { BasePaginate, IPayment, IRating, IReport, ISocietyProceding, ReadClientQuotation } from '../types/index.js';
+import { ICotation } from '../types/Interface/models/ICotation.js';
+import { ISociety } from '../types/Interface/models/ISociety.js';
 
 type getLeadQuotationParams = {
   firstname: string;

package/ts/utils/siretValidation.ts

@@ -52,8 +52,8 @@ export function validateSiret(siret: string) {
 
 export function getVatCodeBySiren(siren: string, countryCode = 'FR'): string {
   const validSiren = siren.replace(/\s/g, '');
-  // @ts-ignore
-  return `${countryCode}${[12 + 3 * (validSiren % 97)] % 97}${validSiren}`;
+  const vatKey = (12 + 3 * (Number(validSiren) % 97)) % 97;
+  return `${countryCode}${String(vatKey).padStart(2, '0')}${validSiren}`;
 }
 
 export function siretToSiren(siret: string, idCountry?: number): string | null {

package/ts/utils/societyApproval.ts

@@ -1,4 +1,8 @@
+import dayjs from 'dayjs';
+import { CityOfGreffeDetail } from '../types/Enum/CityOfGreffe.js';
+import { Civility } from '../types/Enum/Civility.js';
 import { LegalForm, LegalFormTypeEnum } from '../types/Enum/LegalForm.js';
+import { Quality, QualityList } from '../types/Enum/Quality.js';
 import {
   AdditionalMentionType,
   SocietyApprovalDocumentType,
@@ -7,11 +11,8 @@ import {
   SocietyApprovalDocumentTemplate,
 } from '../types/Enum/SocietyApproval.js';
 import { ISocietyApproval } from '../types/Interface/models/ISocietyApproval.js';
-import { QualityList } from '../types/Enum/Quality.js';
-import { getBrand } from './brands.js';
 import { convertDayOfMonthToLetter, convertNumberToLetter } from './amount.js';
-import dayjs from 'dayjs';
-import { CityOfGreffeDetail } from '../types/Enum/CityOfGreffe.js';
+import { getBrand } from './brands.js';
 import { siretToSiren } from './siretValidation.js';
 
 /**
@@ -59,6 +60,158 @@ export function getApprovalDocumentInfos(
   return config?.documents.find((doc) => doc.idDocumentType === idDocumentType);
 }
 
+type ApprovalPerson = {
+  idCivility?: number | null;
+  firstname?: string | null;
+  lastname?: string | null;
+};
+
+type ApprovalPartner = {
+  idQuality?: number | null;
+  society?: { name?: string | null } | null;
+  user?: ApprovalPerson | null;
+};
+
+/**
+ * Gets the grammatical gender from a civility (masculine when the civility is unknown)
+ * @param idCivility - The civility id
+ * @returns Civility.FEMALE for a woman, Civility.MALE otherwise
+ */
+export function getGenderFromCivility(idCivility: number | null | undefined): Civility {
+  return idCivility === Civility.FEMALE ? Civility.FEMALE : Civility.MALE;
+}
+
+/**
+ * Gets the grammatical gender of a group of partners: feminine only when all of them are women
+ * (natural persons), masculine as soon as a man, a legal entity or an unknown civility is present
+ * @param partners - The partners
+ * @returns The grammatical gender of the group
+ */
+export function getPartnersGender(partners: ApprovalPartner[]): Civility {
+  const isOnlyWomen =
+    partners.length > 0 &&
+    partners.every((partner) => !partner.society && partner.user?.idCivility === Civility.FEMALE);
+  return isOnlyWomen ? Civility.FEMALE : Civility.MALE;
+}
+
+/**
+ * Picks the masculine or feminine form of a text
+ * @param gender - The grammatical gender
+ * @param masculine - The masculine form
+ * @param feminine - The feminine form
+ * @returns The inflected form
+ */
+export function inflectByGender(gender: Civility, masculine: string, feminine: string): string {
+  return gender === Civility.FEMALE ? feminine : masculine;
+}
+
+/**
+ * Gets the quality label inflected by gender
+ * @param idQuality - The quality id
+ * @param gender - The grammatical gender
+ * @returns The inflected label, or an empty string when the quality is unknown
+ */
+export function getQualityLabel(idQuality: Quality | number | null | undefined, gender: Civility): string {
+  const quality = QualityList.find((ql) => ql.id === idQuality);
+  if (!quality) return '';
+  return inflectByGender(gender, quality.label, quality.labelFeminine);
+}
+
+/**
+ * Picks the masculine or feminine form of a text from a civility (masculine when the civility is unknown)
+ * @param idCivility - The civility id
+ * @param masculine - The masculine form
+ * @param feminine - The feminine form
+ * @returns The inflected form
+ */
+export function inflectByCivility(idCivility: number | null | undefined, masculine: string, feminine: string): string {
+  return inflectByGender(getGenderFromCivility(idCivility), masculine, feminine);
+}
+
+type GenderTemplateHelpers = {
+  getCivilityTitle: (idCivility: number | null | undefined, isShort?: boolean) => string;
+  inflectByCivility: (idCivility: number | null | undefined, masculine: string, feminine: string) => string;
+  byOwnerGender: (masculine: string, feminine: string) => string;
+  byPartnersGender: (masculine: string, feminine: string) => string;
+};
+
+/**
+ * Builds the gender agreement functions injected into the EJS templates
+ * @param ownerCivility - The owner civility
+ * @param partners - The partners (a legal entity has `society` set, a natural person has an empty `society`)
+ * @returns The agreement functions
+ */
+export function buildGenderTemplateHelpers(
+  ownerCivility: number | null | undefined,
+  partners: ApprovalPartner[],
+): GenderTemplateHelpers {
+  const ownerGender = getGenderFromCivility(ownerCivility);
+  const partnersGender = getPartnersGender(partners);
+  return {
+    getCivilityTitle,
+    inflectByCivility,
+    byOwnerGender: (masculine: string, feminine: string): string => inflectByGender(ownerGender, masculine, feminine),
+    byPartnersGender: (masculine: string, feminine: string): string =>
+      inflectByGender(partnersGender, masculine, feminine),
+  };
+}
+
+const ELIDED_ARTICLE_REGEXP = /^[aeiouyàâäéèêëîïôöùûü]/i;
+
+/**
+ * Prefixes a label with its inflected definite article, elided before a vowel (« l'associée », « la présidente »)
+ * @param label - The label
+ * @param gender - The grammatical gender
+ * @returns The label preceded by its article
+ */
+export function formatWithDefiniteArticle(label: string, gender: Civility): string {
+  if (ELIDED_ARTICLE_REGEXP.test(label)) return `l'${label}`;
+  return `${inflectByGender(gender, 'le', 'la')} ${label}`;
+}
+
+/**
+ * Gets the civility title (empty when the civility is unknown)
+ * @param idCivility - The civility id
+ * @param isShort - true for the abbreviation (M. / Mme)
+ * @returns The civility title
+ */
+export function getCivilityTitle(idCivility: number | null | undefined, isShort: boolean = false): string {
+  if (idCivility === Civility.MALE) return isShort ? 'M.' : 'Monsieur';
+  if (idCivility === Civility.FEMALE) return isShort ? 'Mme' : 'Madame';
+  return '';
+}
+
+/**
+ * Builds a person identity: civility, firstname and lastname, without extra spaces
+ * @param person - The person
+ * @param isShort - true for the abbreviated civility
+ * @returns The formatted identity
+ */
+export function formatPersonIdentity(person: ApprovalPerson | null | undefined, isShort: boolean = false): string {
+  return [getCivilityTitle(person?.idCivility, isShort), person?.firstname, person?.lastname].filter(Boolean).join(' ');
+}
+
+/**
+ * Builds a partner identity: company name for a legal entity, person identity otherwise
+ * @param partner - The partner
+ * @param isShort - true for the abbreviated civility
+ * @returns The partner identity
+ */
+export function formatPartnerIdentity(partner: ApprovalPartner, isShort: boolean = false): string {
+  if (partner.society) return partner.society.name ?? '';
+  return formatPersonIdentity(partner.user, isShort);
+}
+
+/**
+ * Gets the partner quality label inflected by the partner gender
+ * @param partner - The partner
+ * @returns The inflected label or an empty string
+ */
+export function getPartnerQualityLabel(partner: ApprovalPartner): string {
+  const gender = partner.society ? Civility.MALE : getGenderFromCivility(partner.user?.idCivility);
+  return getQualityLabel(partner.idQuality, gender);
+}
+
 function createApprovalDecisionTitleGenerator(idLegalForm?: LegalFormTypeEnum): () => string {
   const decisionOrdinals = ['PREMIERE', 'DEUXIEME', 'TROISIEME', 'QUATRIEME', 'CINQUIEME', 'SIXIEME'];
   const decisionLabel =
@@ -71,6 +224,24 @@ function createApprovalDecisionTitleGenerator(idLegalForm?: LegalFormTypeEnum):
   };
 }
 
+/**
+ * Gets the default quality of the company manager, used when no quality is stored for the owner
+ * @param idLegalForm - The legal form id
+ * @returns The default quality, or null when the legal form has no default
+ */
+export function getDefaultOwnerQuality(idLegalForm: LegalFormTypeEnum | null | undefined): Quality | null {
+  switch (idLegalForm) {
+    case LegalFormTypeEnum.EURL:
+    case LegalFormTypeEnum.SARL:
+      return Quality.GERANT;
+    case LegalFormTypeEnum.SAS:
+    case LegalFormTypeEnum.SASU:
+      return Quality.PRESIDENT;
+    default:
+      return null;
+  }
+}
+
 /**
  * Construit les données formatées pour le template d'approbation
  * @param existingApproval - Les données d'approbation de la société
@@ -91,9 +262,17 @@ export function buildApprovalTemplateData(existingApproval: ISocietyApproval, st
     existingApproval?.exercice?.society?.totalSharesHeld ?? 0,
   ).toLowerCase();
   const brand = getBrand();
+  const owner = existingApproval?.exercice?.society?.users?.[0];
+  const ownerGender = getGenderFromCivility(owner?.idCivility);
+  const ownerQualityLabel =
+    getQualityLabel(owner?.businessPartners?.[0]?.idQuality, ownerGender) ||
+    getQualityLabel(getDefaultOwnerQuality(existingApproval?.exercice?.society?.idLegalForm), ownerGender);
+  const partners = existingApproval?.exercice?.society?.businessPartners ?? [];
+  const partnersGender = getPartnersGender(partners);
   return {
     // Variables globales
     AdditionalMentionType,
+    Civility,
     nextDecisionTitle: createApprovalDecisionTitleGenerator(
       existingApproval?.exercice?.society?.idLegalForm ?? undefined,
     ),
@@ -120,12 +299,22 @@ export function buildApprovalTemplateData(existingApproval: ISocietyApproval, st
       ECOrderCity: brand?.companyInformation?.ECOrderCity,
     },
     owner: {
-      identity: `${existingApproval?.exercice?.society?.users?.[0]?.idCivility === 1 ? 'Monsieur' : 'Madame'} ${existingApproval?.exercice?.society?.users?.[0]?.firstname} ${existingApproval?.exercice?.society?.users?.[0]?.lastname}`,
-      quality:
-        QualityList.find(
-          (ql) => ql.id === existingApproval?.exercice?.society?.users?.[0]?.businessPartners?.[0]?.idQuality,
-        )?.label ?? '',
+      idCivility: owner?.idCivility ?? null,
+      isFemale: ownerGender === Civility.FEMALE,
+      identity: formatPersonIdentity(owner),
+      quality: ownerQualityLabel,
+      qualityWithArticle: ownerQualityLabel
+        ? formatWithDefiniteArticle(ownerQualityLabel.toLowerCase(), ownerGender)
+        : '',
+    },
+    partners: {
+      count: partners.length,
+      isPlural: partners.length > 1,
+      isFemale: partnersGender === Civility.FEMALE,
     },
+    ...buildGenderTemplateHelpers(owner?.idCivility, partners),
+    formatPartnerIdentity,
+    getPartnerQualityLabel,
     // Variables stockées en base
     ...existingApproval,
     generatingDatas: {

package/ts/utils/tests/document.spec.ts

@@ -1,11 +1,11 @@
 import { describe, expect, test } from 'vitest';
-import { generateCommercialDocument } from '../commercialManagement/document.js';
-import { isHtmlEmpty } from '../isHtml.js';
-import { EstimateInvoiceType } from '../../types/Enum/EstimateInvoice.js';
-import { CreateInvoiceDocument } from '../../types/Interface/api/commercialManagement/Create.js';
 import { DiscountType } from '../../types/Enum/CommercialManagement.js';
+import { EstimateInvoiceType } from '../../types/Enum/EstimateInvoice.js';
 import { Unit } from '../../types/Enum/Unit.js';
 import { Vat } from '../../types/Enum/Vat.js';
+import { CreateInvoiceDocument } from '../../types/Interface/api/commercialManagement/Create.js';
+import { generateCommercialDocument } from '../commercialManagement/document.js';
+import { isHtmlEmpty } from '../isHtml.js';
 
 // Payload reproducing a real-world case where the seller address fields (`name`, `street`,
 // `number`, `zipCode`, `city`) are entirely absent from the object, not just `null`.

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

@@ -1,8 +1,8 @@
 import dayjs from 'dayjs';
-import { IRegulation, Vat, PaymentMethod } from '../../types/index.js';
 import MockDate from 'mockdate';
-import { calculatePaymentsAuto } from '../payment.js';
+import { IRegulation, Vat, PaymentMethod } from '../../types/index.js';
 import { PartialExercicePrestationExpress } from '../../types/Interface/api/payment/Util.js';
+import { calculatePaymentsAuto } from '../payment.js';
 import { getTaxesIncludedAmount } from '../vat/utils.js';
 
 // @ts-ignore

package/ts/utils/tests/societyApproval.spec.ts

@@ -0,0 +1,237 @@
+import { describe, expect, test } from 'vitest';
+import { Civility } from '../../types/Enum/Civility.js';
+import { LegalFormTypeEnum } from '../../types/Enum/LegalForm.js';
+import { Quality } from '../../types/Enum/Quality.js';
+import { ISocietyApproval } from '../../types/Interface/models/ISocietyApproval.js';
+import {
+  buildApprovalTemplateData,
+  buildGenderTemplateHelpers,
+  formatPartnerIdentity,
+  formatPersonIdentity,
+  formatWithDefiniteArticle,
+  getDefaultOwnerQuality,
+  getGenderFromCivility,
+  getPartnerQualityLabel,
+  getPartnersGender,
+  getQualityLabel,
+  inflectByCivility,
+} from '../societyApproval.js';
+
+const WOMAN = { user: { idCivility: Civility.FEMALE, firstname: 'Marie', lastname: 'Curie' } };
+const MAN = { user: { idCivility: Civility.MALE, firstname: 'Pierre', lastname: 'Curie' } };
+const UNKNOWN = { user: { idCivility: null, firstname: 'Camille', lastname: 'Dupont' } };
+const COMPANY = { society: { name: 'Holding' } };
+
+const buildApproval = (params: {
+  ownerCivility: Civility | null;
+  ownerQuality: Quality | null;
+  partners: Array<typeof WOMAN | typeof MAN | typeof UNKNOWN | typeof COMPANY>;
+  idLegalForm?: LegalFormTypeEnum;
+}): ISocietyApproval =>
+  ({
+    exercice: {
+      society: {
+        idLegalForm: params.idLegalForm,
+        users: [
+          {
+            idCivility: params.ownerCivility,
+            firstname: 'Ada',
+            lastname: 'Lovelace',
+            businessPartners: [{ idQuality: params.ownerQuality }],
+          },
+        ],
+        businessPartners: params.partners,
+      },
+    },
+  }) as ISocietyApproval;
+
+describe('societyApproval gender utils', () => {
+  test.each([
+    { idCivility: Civility.FEMALE, expected: Civility.FEMALE },
+    { idCivility: Civility.MALE, expected: Civility.MALE },
+    { idCivility: null, expected: Civility.MALE },
+    { idCivility: undefined, expected: Civility.MALE },
+  ])('should get gender $expected from civility $idCivility', ({ idCivility, expected }) => {
+    expect(getGenderFromCivility(idCivility)).toBe(expected);
+  });
+
+  test.each([
+    { case: 'only women', partners: [WOMAN, WOMAN], expected: Civility.FEMALE },
+    { case: 'a single woman', partners: [WOMAN], expected: Civility.FEMALE },
+    { case: 'women and men', partners: [WOMAN, MAN], expected: Civility.MALE },
+    { case: 'a woman and a company', partners: [WOMAN, COMPANY], expected: Civility.MALE },
+    { case: 'a woman and an unknown civility', partners: [WOMAN, UNKNOWN], expected: Civility.MALE },
+    { case: 'no partner', partners: [], expected: Civility.MALE },
+  ])('should get the partners gender with $case', ({ partners, expected }) => {
+    expect(getPartnersGender(partners)).toBe(expected);
+  });
+
+  test.each([
+    { idQuality: Quality.GERANT, gender: Civility.FEMALE, expected: 'Gérante' },
+    { idQuality: Quality.GERANT, gender: Civility.MALE, expected: 'Gérant' },
+    { idQuality: Quality.PRESIDENT, gender: Civility.FEMALE, expected: 'Présidente' },
+    { idQuality: Quality.EI, gender: Civility.FEMALE, expected: 'Entrepreneuse individuelle' },
+    { idQuality: Quality.AE, gender: Civility.FEMALE, expected: 'Auto-entrepreneuse' },
+    { idQuality: Quality.PDG, gender: Civility.FEMALE, expected: 'PDG' },
+    { idQuality: null, gender: Civility.FEMALE, expected: '' },
+  ])('should get the quality label $expected', ({ idQuality, gender, expected }) => {
+    expect(getQualityLabel(idQuality, gender)).toBe(expected);
+  });
+
+  test.each([
+    { person: WOMAN.user, isShort: false, expected: 'Madame Marie Curie' },
+    { person: MAN.user, isShort: true, expected: 'M. Pierre Curie' },
+    { person: WOMAN.user, isShort: true, expected: 'Mme Marie Curie' },
+    { person: UNKNOWN.user, isShort: false, expected: 'Camille Dupont' },
+    { person: { idCivility: Civility.MALE, firstname: '', lastname: 'Seul' }, isShort: true, expected: 'M. Seul' },
+  ])('should format the identity $expected', ({ person, isShort, expected }) => {
+    expect(formatPersonIdentity(person, isShort)).toBe(expected);
+  });
+
+  test.each([
+    { label: 'présidente', gender: Civility.FEMALE, expected: 'la présidente' },
+    { label: 'président', gender: Civility.MALE, expected: 'le président' },
+    { label: 'associée', gender: Civility.FEMALE, expected: "l'associée" },
+    { label: 'associé', gender: Civility.MALE, expected: "l'associé" },
+    { label: 'entrepreneuse individuelle', gender: Civility.FEMALE, expected: "l'entrepreneuse individuelle" },
+    { label: 'pdg', gender: Civility.FEMALE, expected: 'la pdg' },
+  ])('should prefix $label with its definite article', ({ label, gender, expected }) => {
+    expect(formatWithDefiniteArticle(label, gender)).toBe(expected);
+  });
+
+  test.each([
+    { idCivility: Civility.FEMALE, expected: 'née' },
+    { idCivility: Civility.MALE, expected: 'né' },
+    { idCivility: null, expected: 'né' },
+  ])('should inflect by civility $idCivility', ({ idCivility, expected }) => {
+    expect(inflectByCivility(idCivility, 'né', 'née')).toBe(expected);
+  });
+
+  test('should build the gender template helpers from the owner and the partners', () => {
+    const helpers = buildGenderTemplateHelpers(Civility.FEMALE, [WOMAN, MAN]);
+
+    expect(helpers.byOwnerGender('le soussigné', 'la soussignée')).toBe('la soussignée');
+    expect(helpers.byPartnersGender('Les soussignés', 'Les soussignées')).toBe('Les soussignés');
+    expect(helpers.inflectByCivility(Civility.FEMALE, 'né', 'née')).toBe('née');
+    expect(helpers.getCivilityTitle(Civility.FEMALE, true)).toBe('Mme');
+  });
+
+  test('should format a company partner with its name', () => {
+    expect(formatPartnerIdentity(COMPANY)).toBe('Holding');
+  });
+
+  test.each([
+    { partner: { ...WOMAN, idQuality: Quality.GERANT }, expected: 'Gérante' },
+    { partner: { ...MAN, idQuality: Quality.GERANT }, expected: 'Gérant' },
+    { partner: { ...COMPANY, idQuality: Quality.ASSOCIE }, expected: 'Associé' },
+  ])('should get the partner quality label $expected', ({ partner, expected }) => {
+    expect(getPartnerQualityLabel(partner)).toBe(expected);
+  });
+});
+
+describe('buildApprovalTemplateData gender data', () => {
+  test('should expose a feminine owner and partners', () => {
+    const data = buildApprovalTemplateData(
+      buildApproval({ ownerCivility: Civility.FEMALE, ownerQuality: Quality.PRESIDENT, partners: [WOMAN, WOMAN] }),
+      '',
+    );
+
+    expect(data.owner).toEqual(
+      expect.objectContaining({ isFemale: true, identity: 'Madame Ada Lovelace', quality: 'Présidente' }),
+    );
+    expect(data.partners).toEqual({ count: 2, isPlural: true, isFemale: true });
+    expect(data.byOwnerGender('il', 'elle')).toBe('elle');
+    expect(data.byPartnersGender('associés', 'associées')).toBe('associées');
+  });
+
+  test('should fall back to the masculine without title when the owner civility is unknown', () => {
+    const data = buildApprovalTemplateData(
+      buildApproval({ ownerCivility: null, ownerQuality: Quality.GERANT, partners: [WOMAN, COMPANY] }),
+      '',
+    );
+
+    expect(data.owner).toEqual(
+      expect.objectContaining({ isFemale: false, identity: 'Ada Lovelace', quality: 'Gérant' }),
+    );
+    expect(data.partners).toEqual({ count: 2, isPlural: true, isFemale: false });
+    expect(data.byOwnerGender('il', 'elle')).toBe('il');
+    expect(data.byPartnersGender('associés', 'associées')).toBe('associés');
+  });
+
+  test.each([
+    { idLegalForm: LegalFormTypeEnum.EURL, civility: Civility.MALE, quality: 'Gérant', withArticle: 'le gérant' },
+    { idLegalForm: LegalFormTypeEnum.SARL, civility: Civility.FEMALE, quality: 'Gérante', withArticle: 'la gérante' },
+    { idLegalForm: LegalFormTypeEnum.SASU, civility: Civility.MALE, quality: 'Président', withArticle: 'le président' },
+    {
+      idLegalForm: LegalFormTypeEnum.SAS,
+      civility: Civility.FEMALE,
+      quality: 'Présidente',
+      withArticle: 'la présidente',
+    },
+  ])(
+    'should fall back to the default quality of a $idLegalForm owner without stored quality',
+    ({ idLegalForm, civility, quality, withArticle }) => {
+      const data = buildApprovalTemplateData(
+        buildApproval({ ownerCivility: civility, ownerQuality: null, partners: [], idLegalForm }),
+        '',
+      );
+
+      expect(data.owner).toEqual(expect.objectContaining({ quality, qualityWithArticle: withArticle }));
+    },
+  );
+
+  test('should keep the stored quality over the default one of the legal form', () => {
+    const data = buildApprovalTemplateData(
+      buildApproval({
+        ownerCivility: Civility.MALE,
+        ownerQuality: Quality.GERANT,
+        partners: [],
+        idLegalForm: LegalFormTypeEnum.SAS,
+      }),
+      '',
+    );
+
+    expect(data.owner).toEqual(expect.objectContaining({ quality: 'Gérant', qualityWithArticle: 'le gérant' }));
+  });
+
+  test('should fall back to the default quality when the stored quality has no label', () => {
+    const data = buildApprovalTemplateData(
+      buildApproval({
+        ownerCivility: Civility.MALE,
+        ownerQuality: 11 as Quality,
+        partners: [],
+        idLegalForm: LegalFormTypeEnum.SARL,
+      }),
+      '',
+    );
+
+    expect(data.owner).toEqual(expect.objectContaining({ quality: 'Gérant', qualityWithArticle: 'le gérant' }));
+  });
+
+  test('should leave the owner quality empty when neither stored nor default quality exists', () => {
+    const data = buildApprovalTemplateData(
+      buildApproval({
+        ownerCivility: Civility.MALE,
+        ownerQuality: null,
+        partners: [],
+        idLegalForm: LegalFormTypeEnum.SCI,
+      }),
+      '',
+    );
+
+    expect(data.owner).toEqual(expect.objectContaining({ quality: '', qualityWithArticle: '' }));
+  });
+});
+
+describe('getDefaultOwnerQuality', () => {
+  test.each([
+    { idLegalForm: LegalFormTypeEnum.EURL, expected: Quality.GERANT },
+    { idLegalForm: LegalFormTypeEnum.SARL, expected: Quality.GERANT },
+    { idLegalForm: LegalFormTypeEnum.SASU, expected: Quality.PRESIDENT },
+    { idLegalForm: LegalFormTypeEnum.SAS, expected: Quality.PRESIDENT },
+    { idLegalForm: LegalFormTypeEnum.SCI, expected: null },
+    { idLegalForm: undefined, expected: null },
+  ])('should get the default quality of legal form $idLegalForm', ({ idLegalForm, expected }) => {
+    expect(getDefaultOwnerQuality(idLegalForm)).toBe(expected);
+  });
+});

package/ts/utils/validators/nestedArray.validator.ts

@@ -1,7 +1,7 @@
-import { plainToInstance } from 'class-transformer';
 import type { ClassConstructor } from 'class-transformer';
-import { registerDecorator, validateSync } from 'class-validator';
 import type { ValidationArguments, ValidationError, ValidationOptions } from 'class-validator';
+import { plainToInstance } from 'class-transformer';
+import { registerDecorator, validateSync } from 'class-validator';
 
 function getItemErrors<T extends object>(cls: ClassConstructor<T>, item: unknown): string[] {
   if (typeof item !== 'object' || item === null) return ['must be an object'];