@movalib/movalib-commons 1.60.0 → 1.62.0

package/src/helpers/Tools.ts

@@ -1,56 +1,92 @@
-import Cookies from "js-cookie";
-import VehicleTire from "../models/VehicleTire";
-import { MovaFormField, MovaInterval } from "./Types";
+import parsePhoneNumberFromString from "libphonenumber-js/max";
 import { CSSProperties } from "react";
-import { DayOfWeek, PartsApplicationType, VehiclePlateFormat } from "./Enums";
 import Schedule from "../models/Schedule";
+import VehicleTire from "../models/VehicleTire";
+import { DayOfWeek, PartsApplicationType, VehiclePlateFormat } from "./Enums";
+import { MovaFormField, MovaInterval } from "./Types";
 
-export const getApplicationsShortLabels = (applications: PartsApplicationType[] | undefined): string => {
-  if(!applications) {
-    return '';
+export const getApplicationsShortLabels = (
+  applications: PartsApplicationType[] | undefined
+): string => {
+  if (!applications) {
+    return "";
   }
-  
-  return applications.map(getApplicationShortLabel).join(' + ');
+
+  return applications.map(getApplicationShortLabel).join(" + ");
 };
 
-export const flexStart:CSSProperties = {
-  display: 'flex',
-  justifyContent: 'start',
-  alignItems: 'center'
-}
+export const flexStart: CSSProperties = {
+  display: "flex",
+  justifyContent: "start",
+  alignItems: "center",
+};
 
-export const isSafariOniOS = ():boolean => {
+export const isSafariOniOS = (): boolean => {
   const userAgent = window.navigator.userAgent;
-  const iOS = !!userAgent.match(/iPad/i) || !!userAgent.match(/iPhone/i) || !!userAgent.match(/iPod/i);
+  const iOS =
+    !!userAgent.match(/iPad/i) ||
+    !!userAgent.match(/iPhone/i) ||
+    !!userAgent.match(/iPod/i);
   const webkit = !!userAgent.match(/WebKit/i);
   const criOS = !!userAgent.match(/CriOS/i);
-  
+
   return iOS && webkit && !criOS;
-}
+};
 
+export const isInvalidMobileNumber = (phoneNumber = "") => {
+  if (!phoneNumber || typeof phoneNumber !== "string") return true;
+
+  // Nettoyage : supprime les espaces et convertit "00..." en "+..."
+  const cleaned = phoneNumber.replace(/\s+/g, "").replace(/^00/, "+");
+  // Si le numéro ne commence pas par +, on assume que c'est un numéro local français
+  const cleanedPhoneNumber = cleaned.startsWith("+")
+    ? cleaned
+    : `+33${cleaned.replace(/^0/, "")}`;
+
+  try {
+    const parsed = parsePhoneNumberFromString(cleanedPhoneNumber);
+    const type = parsed?.getType?.();
+    console.log(type);
+    console.log(parsed?.isValid());
+    console.log(["MOBILE", "MOBILE_OR_FIXED_LINE"].includes(type || ""));
+    return !(
+      parsed?.isValid() &&
+      ["MOBILE", "MOBILE_OR_FIXED_LINE"].includes(type || "")
+    );
+  } catch {
+    return true;
+  }
+};
 
-export const FR_WEEK_DAYS: string[] = ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche'];
+export const FR_WEEK_DAYS: string[] = [
+  "Lundi",
+  "Mardi",
+  "Mercredi",
+  "Jeudi",
+  "Vendredi",
+  "Samedi",
+  "Dimanche",
+];
 
 export const getDayOfWeekLabel = (day: DayOfWeek) => {
-  if(day){
-    return FR_WEEK_DAYS[getDayOfWeekIndex(day)]
+  if (day) {
+    return FR_WEEK_DAYS[getDayOfWeekIndex(day)];
   }
-}
+};
 
 export const getDayOfWeekIndex = (day: DayOfWeek) => {
-  if(day){      
+  if (day) {
     // Convertir les valeurs de l'énumération en un tableau
     const daysArray = Object.values(DayOfWeek);
     return daysArray.indexOf(day);
   }
   return -1;
-}
-
+};
 
 export const formatPhoneNumber = (phoneNumber: string): string => {
   let formattedNumber = "";
 
-  if(phoneNumber){
+  if (phoneNumber) {
     for (let i = 0; i < phoneNumber.length; i++) {
       if (i > 0 && i % 2 === 0) {
         formattedNumber += ".";
@@ -62,87 +98,119 @@ export const formatPhoneNumber = (phoneNumber: string): string => {
   return formattedNumber;
 };
 
-export const getFormattedSchedule = (schedule: Schedule | null, dayIndex: number) => {
-  if(schedule){
-    return `${getFrenchDayLabel(schedule.dayOfWeek)} :   ${getFormattedIntervals(schedule.intervals)}`
+export const getFormattedSchedule = (
+  schedule: Schedule | null,
+  dayIndex: number
+) => {
+  if (schedule) {
+    return `${getFrenchDayLabel(
+      schedule.dayOfWeek
+    )} :   ${getFormattedIntervals(schedule.intervals)}`;
   } else {
     return `${getFrenchDayLabel(getDayOfWeek(dayIndex))} :   fermé`;
   }
-}
+};
 
 export const getFormattedIntervals = (intervals: MovaInterval[]) => {
-  if(intervals){
-    let times:string = "";
-    sortMovaIntervals(intervals).map((interval:MovaInterval, index) => {
-      if(index > 0){
-        times = `${times} |  `; 
+  if (intervals) {
+    let times: string = "";
+    sortMovaIntervals(intervals).map((interval: MovaInterval, index) => {
+      if (index > 0) {
+        times = `${times} |  `;
       }
-      times = `${times} ${formatTime(interval.startTime)} - ${formatTime(interval.endTime)}`
-    })
+      times = `${times} ${formatTime(interval.startTime)} - ${formatTime(
+        interval.endTime
+      )}`;
+    });
     return times;
   }
-}
+};
 
 export const formatTime = (date: string | Date | null) => {
-  if(date){
-    let strDate:string = date.toString();
+  if (date) {
+    let strDate: string = date.toString();
     return strDate.substring(0, 5);
   }
 };
 
 const sortMovaIntervals = (intervals: MovaInterval[]): MovaInterval[] => {
-  if(intervals){
+  if (intervals) {
     return intervals.sort((a, b) => {
       // Convertir en Date si nécessaire
-      const startTimeA = a.startTime instanceof Date ? a.startTime : new Date(a.startTime as string);
-      const startTimeB = b.startTime instanceof Date ? b.startTime : new Date(b.startTime as string);
-  
+      const startTimeA =
+        a.startTime instanceof Date
+          ? a.startTime
+          : new Date(a.startTime as string);
+      const startTimeB =
+        b.startTime instanceof Date
+          ? b.startTime
+          : new Date(b.startTime as string);
+
       // Gérer les valeurs nulles
       if (startTimeA === null && startTimeB === null) return 0;
       if (startTimeA === null) return 1;
       if (startTimeB === null) return -1;
-  
+
       // Comparer les dates
       return startTimeA.getTime() - startTimeB.getTime();
     });
   }
   return [];
-}
+};
 
-export const findScheduleByDayOfWeek = (schedules: Schedule[], dayIndex: number): Schedule | null => {
-  const foundSchedule = schedules.find(schedule => schedule.dayOfWeek === getDayOfWeek(dayIndex));
+export const findScheduleByDayOfWeek = (
+  schedules: Schedule[],
+  dayIndex: number
+): Schedule | null => {
+  const foundSchedule = schedules.find(
+    (schedule) => schedule.dayOfWeek === getDayOfWeek(dayIndex)
+  );
   return foundSchedule ? foundSchedule : null;
 };
 
-export const getDayOfWeek = (index:number) => {
+export const getDayOfWeek = (index: number) => {
   switch (index) {
-    case 0 : return DayOfWeek.MONDAY;
-    case 1 : return DayOfWeek.TUESDAY;
-    case 2 : return DayOfWeek.WEDNESDAY;
-    case 3 : return DayOfWeek.THURSDAY;
-    case 4 : return DayOfWeek.FRIDAY;
-    case 5 : return DayOfWeek.SATURDAY;
-    case 6 : return DayOfWeek.SUNDAY;
+    case 0:
+      return DayOfWeek.MONDAY;
+    case 1:
+      return DayOfWeek.TUESDAY;
+    case 2:
+      return DayOfWeek.WEDNESDAY;
+    case 3:
+      return DayOfWeek.THURSDAY;
+    case 4:
+      return DayOfWeek.FRIDAY;
+    case 5:
+      return DayOfWeek.SATURDAY;
+    case 6:
+      return DayOfWeek.SUNDAY;
   }
-}
+};
 
-export const getFrenchDayLabel = (day:DayOfWeek | undefined) => {
+export const getFrenchDayLabel = (day: DayOfWeek | undefined) => {
   switch (day) {
-    case DayOfWeek.MONDAY: return 'Lundi';
-    case DayOfWeek.TUESDAY: return 'Mardi';
-    case DayOfWeek.WEDNESDAY: return 'Mercredi';
-    case DayOfWeek.THURSDAY: return 'Jeudi';
-    case DayOfWeek.FRIDAY: return 'Vendredi';
-    case DayOfWeek.SATURDAY: return 'Samedi';
-    case DayOfWeek.SUNDAY: return 'Dimanche';
+    case DayOfWeek.MONDAY:
+      return "Lundi";
+    case DayOfWeek.TUESDAY:
+      return "Mardi";
+    case DayOfWeek.WEDNESDAY:
+      return "Mercredi";
+    case DayOfWeek.THURSDAY:
+      return "Jeudi";
+    case DayOfWeek.FRIDAY:
+      return "Vendredi";
+    case DayOfWeek.SATURDAY:
+      return "Samedi";
+    case DayOfWeek.SUNDAY:
+      return "Dimanche";
   }
-}
+};
 
-export const flexLeftRow:CSSProperties = {
-  display: 'flex',
-  justifyContent: 'start',
-  alignItems: 'center'
-}
+export const flexLeftRow: CSSProperties = {
+  display: "flex",
+  justifyContent: "start",
+  alignItems: "center",
+};
 
 export const capitalizeFirstLetter = (str: string): string => {
   if (str.length === 0) {
@@ -153,45 +221,56 @@ export const capitalizeFirstLetter = (str: string): string => {
   const restOfString = str.slice(1);
 
   return firstChar + restOfString;
-}
-
-export const getApplicationShortLabel = (application:PartsApplicationType | undefined) => {
-  if(application){
-    switch(application){
-      case PartsApplicationType.FRONT:  return "AV";
-      case PartsApplicationType.REAR: return "AR";
-      case PartsApplicationType.FRONT_REAR: return "AV + AR";
-      case PartsApplicationType.LEFT: return "G";
-      case PartsApplicationType.RIGHT: return "D";
-      case PartsApplicationType.LEFT_RIGHT: return "G + D";  
-      case PartsApplicationType.FRONT_LEFT: return "AVG";
-      case PartsApplicationType.FRONT_RIGHT: return "AVD";
-      case PartsApplicationType.REAR_LEFT: return "ARG";
-      case PartsApplicationType.REAR_RIGHT: return "ARD";  
+};
+
+export const getApplicationShortLabel = (
+  application: PartsApplicationType | undefined
+) => {
+  if (application) {
+    switch (application) {
+      case PartsApplicationType.FRONT:
+        return "AV";
+      case PartsApplicationType.REAR:
+        return "AR";
+      case PartsApplicationType.FRONT_REAR:
+        return "AV + AR";
+      case PartsApplicationType.LEFT:
+        return "G";
+      case PartsApplicationType.RIGHT:
+        return "D";
+      case PartsApplicationType.LEFT_RIGHT:
+        return "G + D";
+      case PartsApplicationType.FRONT_LEFT:
+        return "AVG";
+      case PartsApplicationType.FRONT_RIGHT:
+        return "AVD";
+      case PartsApplicationType.REAR_LEFT:
+        return "ARG";
+      case PartsApplicationType.REAR_RIGHT:
+        return "ARD";
     }
   }
   return "";
-}
+};
 
-export const flexEnd:CSSProperties = {
-  display: 'flex',
-  justifyContent: 'end',
-  alignItems: 'center'
-}
+export const flexEnd: CSSProperties = {
+  display: "flex",
+  justifyContent: "end",
+  alignItems: "center",
+};
 
-export const flexCenter:CSSProperties = {
-  display: 'flex',
-  justifyContent: 'center',
-  alignItems: 'center'
-}
+export const flexCenter: CSSProperties = {
+  display: "flex",
+  justifyContent: "center",
+  alignItems: "center",
+};
 
 export const isEmpty = (data: Object): boolean => {
   return Object.keys(data).length === 0;
-}
+};
 
 export const formatFrenchVehiclePlate = (input: string | undefined): string => {
-  if(input){
-
+  if (input) {
     // On commence par détecter s'il s'agit d'un ancien ou nouveau format
     let plateFormat: VehiclePlateFormat | null = null;
 
@@ -204,21 +283,24 @@ export const formatFrenchVehiclePlate = (input: string | undefined): string => {
     }
 
     // Supprimer tous les caractères non alphanumériques
-    let cleanedInput = input.replace(/[^A-Z0-9]/gi, '').toUpperCase();
+    let cleanedInput = input.replace(/[^A-Z0-9]/gi, "").toUpperCase();
 
-    switch(plateFormat){
-      case VehiclePlateFormat.FRENCH_NEW : {
+    switch (plateFormat) {
+      case VehiclePlateFormat.FRENCH_NEW: {
         // Ajouter des tirets aux positions appropriées
         if (cleanedInput.length >= 2) {
           cleanedInput = `${cleanedInput.slice(0, 2)}-${cleanedInput.slice(2)}`;
         }
         if (cleanedInput.length >= 6) {
-          cleanedInput = `${cleanedInput.slice(0, 6)}-${cleanedInput.slice(6, 8)}`;
+          cleanedInput = `${cleanedInput.slice(0, 6)}-${cleanedInput.slice(
+            6,
+            8
+          )}`;
         }
         break;
       }
 
-      case VehiclePlateFormat.FRENCH_OLD : {
+      case VehiclePlateFormat.FRENCH_OLD: {
         // Rien de particulier, pas de tiret sur les anciennes plaques
         break;
       }
@@ -231,25 +313,30 @@ export const formatFrenchVehiclePlate = (input: string | undefined): string => {
 };
 
 export const formatVehicleTire = (vehicleTire: VehicleTire) => {
-  if(vehicleTire){
+  if (vehicleTire) {
     let concatened = `${vehicleTire.width}${vehicleTire.height}${vehicleTire.diameter}${vehicleTire.speedIndex}`;
     return formatVehicleTireStr(concatened);
   }
-  return '';
-}
+  return "";
+};
 
 export const formatVehicleTireStr = (input: string) => {
-  let formatted = input.toUpperCase().replace(/[^0-9A-QS-Za-qs-z]/g, '').slice(0, 7);
+  let formatted = input
+    .toUpperCase()
+    .replace(/[^0-9A-QS-Za-qs-z]/g, "")
+    .slice(0, 7);
   if (formatted.length > 3) {
     formatted = `${formatted.substring(0, 3)} / ${formatted.substring(3)}`;
   }
   const indexOfRraw = input.indexOf("R");
-  let toAdd = indexOfRraw !== -1 ? input.substring(indexOfRraw + 3) : '';
-  if(toAdd.length > 0) {
-    toAdd = ' ' + toAdd;
+  let toAdd = indexOfRraw !== -1 ? input.substring(indexOfRraw + 3) : "";
+  if (toAdd.length > 0) {
+    toAdd = " " + toAdd;
   }
-  if(formatted.length > 8) {
-    formatted = `${formatted.substring(0, 8)} R${formatted.substring(8)}${toAdd}`;
+  if (formatted.length > 8) {
+    formatted = `${formatted.substring(0, 8)} R${formatted.substring(
+      8
+    )}${toAdd}`;
   }
   return formatted;
 };
@@ -262,13 +349,16 @@ export const formatVehicleTireStr = (input: string) => {
  * @param {string} errorMsg - Le message d'erreur à associer au champ si la validation échoue.
  * @returns {MovaFormField} - Le champ de formulaire avec les propriétés `error` et `isValid` mises à jour.
  */
-export const validateField = (field: MovaFormField | undefined, validator: (value: string) => boolean, errorMsg: string): MovaFormField => {
-    if (field && !validator(field.value)) {
-      return { value: field.value, error: errorMsg, isValid: false };
-    } else if (field) {
-      return { value: field.value, error: '', isValid: true };
-    } else {
-      return  { value: '', error: '', isValid: true };
-    }
-  };
-  
+export const validateField = (
+  field: MovaFormField | undefined,
+  validator: (value: string) => boolean,
+  errorMsg: string
+): MovaFormField => {
+  if (field && !validator(field.value)) {
+    return { value: field.value, error: errorMsg, isValid: false };
+  } else if (field) {
+    return { value: field.value, error: "", isValid: true };
+  } else {
+    return { value: "", error: "", isValid: true };
+  }
+};

package/src/helpers/Validator.ts

@@ -1,57 +1,59 @@
+import { isInvalidMobileNumber } from "./Tools";
+
 /**
  * Un email valide
  */
-const emailRegex:RegExp  = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i;
+const emailRegex: RegExp = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i;
 
 /**
- * Un mot de passe qui contient au moins une majuscule, une minuscule, un chiffre 
+ * Un mot de passe qui contient au moins une majuscule, une minuscule, un chiffre
  * et un caractère spécial. La longueur du mot de passe doit être d'au moins 8 caractères.
  */
-const passwordRegex:RegExp  = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
+const passwordRegex: RegExp =
+  /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
 
 /**
- * Un numéro de téléphone (10 chiffres) 
+ * Un numéro de téléphone (10 chiffres)
  */
-const phoneNumberRegex:RegExp  = /^\d{0,10}$/;
+const phoneNumberRegex: RegExp = /^\d{0,10}$/;
 
 /**
  * Un code postal (5 chiffres)
  */
-const postalCodeRegex:RegExp  = /^\d{5}$/;
+const postalCodeRegex: RegExp = /^\d{5}$/;
 
 /**
  * Une URL valide
  */
-const urlRegex:RegExp =/^(ftp|http|https):\/\/[^ "]+$/;
+const urlRegex: RegExp = /^(ftp|http|https):\/\/[^ "]+$/;
 
 /**
  * Un nom pouvant contenir des lettres, chiffres d'une taille comprise entre 3 et 20 caractères
  */
-const userNameRegex:RegExp = /^[a-z0-9_-]{3,20}$/;
+const userNameRegex: RegExp = /^[a-z0-9_-]{3,20}$/;
 
 /**
  * Un texte pouvant contenir des lettres, chiffres et quelques caractères spéciaux
  */
-const textRegex:RegExp = /^[a-zA-Z0-9\s.,!?'"()+=-_-éèçà]+$/;
-
+const textRegex: RegExp = /^[a-zA-Z0-9\s.,!?'"()+=-_-éèçà]+$/;
 
-export function validatePhoneNumber(phoneNumber: string) : boolean {
-    if (phoneNumber === null || phoneNumber === undefined || phoneNumber === '') {
-        return false;
-    }
-    return phoneNumberRegex.test(phoneNumber);
+export function validatePhoneNumber(phoneNumber: string): boolean {
+  if (phoneNumber === null || phoneNumber === undefined || phoneNumber === "") {
+    return false;
+  }
+  return !isInvalidMobileNumber(phoneNumber);
 }
 
-export function validateText(text: string) : boolean {
-    if (text === null || text === undefined) {
-        return false;
-    }
-    return textRegex.test(text);
+export function validateText(text: string): boolean {
+  if (text === null || text === undefined) {
+    return false;
+  }
+  return textRegex.test(text);
 }
 
-export function validateEmail(email: string) : boolean {
-    if (email === null || email === undefined) {
-        return false;
-    }
-    return emailRegex.test(email);
-}
+export function validateEmail(email: string): boolean {
+  if (email === null || email === undefined) {
+    return false;
+  }
+  return emailRegex.test(email);
+}

package/src/models/Document.ts

@@ -15,7 +15,10 @@ export default class Document {
   reference?: string;
   rejectReason?: string;
   validateToken?: string;
-
+  remindersCount?: number;
+  totalAmountInclVat?: number;
+  lastSendingTime?: Date;
+  firstSendingTime?: Date;
   constructor(
     id: string,
     ownerId: number,
@@ -28,7 +31,11 @@ export default class Document {
     creationDate?: Date,
     updateDate?: Date,
     reference?: string,
-    validateToken?: string
+    validateToken?: string,
+    remindersCount?: number,
+    totalAmountInclVat?: number,
+    lastSendingTime?: Date,
+    firstSendingTime?: Date
   ) {
     this.id = id;
     this.state = state;
@@ -42,6 +49,14 @@ export default class Document {
     this.updateDate = updateDate;
     this.reference = reference;
     this.validateToken = validateToken;
+    this.remindersCount = remindersCount;
+    this.totalAmountInclVat = totalAmountInclVat;
+    this.lastSendingTime = lastSendingTime
+      ? new Date(lastSendingTime)
+      : undefined;
+    this.firstSendingTime = firstSendingTime
+      ? new Date(firstSendingTime)
+      : undefined;
   }
 
   static findByTypeAndReference(