@movalib/movalib-commons 1.59.13 → 1.59.15

package/src/components/vehicle/VehiclePlateField.tsx

@@ -0,0 +1,164 @@
+import React, { FunctionComponent, ReactNode, useEffect, useState } from 'react';
+import TextField from '@mui/material/TextField';
+import { IconButton, InputAdornment } from '@mui/material';
+import SearchIcon from '@mui/icons-material/SearchRounded';
+import { VehiclePlateFormat } from '../../helpers/Enums';
+import Logger from '../../helpers/Logger';
+
+interface VehiclePlateFieldProps {
+    onValidVehiclePlate: (vehiclePlate: string) => void;
+  }
+
+// Regex pour une plaque d'immatriculation française (nouveau format SIV)
+export const regexPlate = /^[A-Z]{2}-\d{3}-[A-Z]{2}$/; 
+// Regex pour une plaque d'immatriculation française (ancien format FNI)
+export const oldRegexPlate = /^\d{1,4}[ -]?[A-Z]{1,4}[ -]?\d{1,4}$/;
+
+
+const VehiclePlateField: FunctionComponent<VehiclePlateFieldProps> = ({ onValidVehiclePlate }) => {
+
+  const [value, setValue] = useState<string>('');
+  const [error, setError] = useState<boolean>(false);
+  const [lastLength, setLastLength] = useState<number>(0); // Ajout d'un état pour stocker la longueur précédente
+  const [helperText, setHelperText] = useState<ReactNode>('');
+
+  // Hook de validation de la plaque
+  useEffect(() => {
+    if (!error && value !== '' && value.match(regexPlate)) {
+        onValidVehiclePlate(value);
+    }
+
+  }, [error, value, onValidVehiclePlate]);
+
+  const getPlateFormat = (plate: string): VehiclePlateFormat | undefined  => {
+    if (plate === '') {
+      // Si la saisie est vide, retournez un format par défaut (nouveau format, par exemple)
+      return undefined;
+    }
+
+    if (/^[A-Za-z]/.test(plate)) {
+      // Commence par une lettre => nouveau format
+      return VehiclePlateFormat.FRENCH_NEW;
+    } else if (/^\d/.test(plate)) {
+      // Commence par un chiffre => ancien format
+      return VehiclePlateFormat.FRENCH_OLD;
+    } else {
+      Logger.error("Format de plaque inconnu");
+      // On retourne le nouveau format par défaut
+      return VehiclePlateFormat.FRENCH_NEW;
+    }
+  }
+
+  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+
+    let inputValue = e.target.value.toUpperCase().replace(/[^A-Z0-9]/g, ''); // Convertir en majuscules et supprimer les caractères non valides
+
+    // Si la saisie commence par une lettre, on contrôle l'ancien format, sinon le nouveau
+    switch(getPlateFormat(inputValue)){
+
+      case VehiclePlateFormat.FRENCH_NEW :{
+        setHelperText(<>Format détecté : <b>AA-111-AA</b></>);
+        handleChangeFrenchNew(inputValue);
+        break;
+      }
+
+      case VehiclePlateFormat.FRENCH_OLD: {
+        setHelperText(
+          <>
+            Format détecté (ancien) : <b>1111 AAAA 1111</b>
+            <br />
+            Pour lancer la recherche, cliquez sur <SearchIcon />
+          </>
+        );        
+        handleChangeFrenchOld(inputValue);
+        break;
+      }
+
+      case undefined: {
+        setHelperText('');
+        setValue('');
+      }
+    }
+
+  };
+
+  const validatePlate = () => {
+
+    if(oldRegexPlate.test(value)){
+      onValidVehiclePlate(value);
+    }
+
+    setError(!oldRegexPlate.test(value));
+  }
+
+  const handleChangeFrenchOld = (inputValue: string) => {
+    
+      // ON bloque la saisie à 12 caractères max (limite des anciennes plaques)
+      if(!(inputValue.length > 12)){
+        setValue(inputValue);
+      } 
+
+      setLastLength(inputValue.length); // Mettre à jour la longueur précédente
+  }
+
+  const handleChangeFrenchNew = (inputValue: string) => {
+
+      // Vérifier si l'utilisateur est en train de supprimer un caractère
+      const isDeleting = inputValue.length < lastLength;
+
+      // Supprimer les tirets pour avoir une chaîne propre
+      const cleanInput = inputValue.replace(/-/g, '');
+
+      // Ajouter des tirets aux positions appropriées
+      if (cleanInput.length > 1 && !(cleanInput.length == 2 && isDeleting)) {
+        inputValue = `${cleanInput.slice(0, 2)}-${cleanInput.slice(2)}`;
+      }
+
+      if (cleanInput.length > 4 && !(cleanInput.length == 5 && isDeleting)) {
+        inputValue = `${cleanInput.slice(0, 2)}-${cleanInput.slice(2, 5)}-${cleanInput.slice(5, 7)}`;
+      }
+
+      setValue(inputValue);
+
+      // On teste la plaque une fois la saisie terminée
+      if(inputValue.length == 9){
+        setError(!regexPlate.test(inputValue));
+      } else {
+        setError(false);
+      }
+
+      setLastLength(inputValue.length); // Mettre à jour la longueur précédente
+  }
+
+  return (
+    <TextField
+      label="Plaque d'immatriculation"
+      variant="outlined"
+      value={value}
+      onChange={handleChange}
+      error={error}
+      autoFocus
+      sx={{ 
+        width: '100%', 
+        '& input': { textTransform: 'uppercase' } // CSS pour forcer les majuscules dans l'input
+      }}
+      helperText={lastLength > 0 ? helperText : ''}
+      InputProps={{
+        endAdornment: (
+             
+          <InputAdornment position="end" sx={{ mr: 1, display: getPlateFormat(value) === VehiclePlateFormat.FRENCH_OLD ? 'inherit' : 'none' }} >
+            <IconButton
+              edge="end"
+              onClick={validatePlate}
+            >
+              <SearchIcon />
+            </IconButton>
+          </InputAdornment>
+          
+        ),
+      }} 
+    />
+  );
+};
+
+export default VehiclePlateField;

package/src/helpers/CookieUtils.ts

@@ -5,8 +5,9 @@ export const COOKIE_INDIVIDUAL_TOKEN: string = 'movalibIndividualToken';
 export const COOKIE_DEFAULT_EXPIRES: number = 7;
 
 export const createCookie = (name:string, value:string) => {
+  console.log('from lib', name, value);
   if(name && value){
-    Cookies.set(name, value, { expires: COOKIE_DEFAULT_EXPIRES, sameSite: 'None', secure: true });
+    Cookies.set(name, value, { expires: COOKIE_DEFAULT_EXPIRES, sameSite: 'Lax' });
   }
 }
 

package/src/helpers/Enums.ts

@@ -171,6 +171,10 @@ export enum DigitalPassportIndex {
 }
 
 export enum EventState {
+    /**
+     * Demande d'empreinte bancaire (pour validation de la demande de RDV)
+    */
+    REQUIRES_PAYMENT_AUTHORIZATION = "REQUIRES_PAYMENT_AUTHORIZATION",
     /**
      * Nouvelle demande de rendez-vous (origine client OU centre)
      */
@@ -231,8 +235,15 @@ export enum DocumentType {
     USER_BANK_DETAILS = "USER_BANK_DETAILS",
     USER_APPOINTMENT_QUOTE = "USER_APPOINTMENT_QUOTE",
     VEHICLE_MAINTENANCE_INVOICE = 'VEHICLE_MAINTENANCE_INVOICE',
+    GARAGE_LOGO = "GARAGE_LOGO",
+
     VEHICLE_TIRE_PHOTO = 'VEHICLE_TIRE_PHOTO',
-    GARAGE_LOGO = "GARAGE_LOGO"
+    VEHICLE_INSPECTION = 'VEHICLE_INSPECTION',
+    VEHICLE_OTHER = 'VEHICLE_OTHER',
+    
+    EVENT_OTHER = 'EVENT_OTHER',
+    EVENT_VISUAL_PROOFS = 'EVENT_VISUAL_PROOFS',
+    EVENT_MAINTENANCE = 'EVENT_MAINTENANCE',
 }
 
 export enum MovaAppType {

package/src/helpers/Tools.ts

@@ -4,6 +4,7 @@ import { MovaFormField, MovaInterval } from "./Types";
 import { CSSProperties } from "react";
 import { DayOfWeek, PartsApplicationType, VehiclePlateFormat } from "./Enums";
 import Schedule from "../models/Schedule";
+import UserConnected from "../services/UserConnected";
 
 export const getApplicationsShortLabels = (applications: PartsApplicationType[] | undefined): string => {
   if(!applications) {
@@ -46,6 +47,10 @@ export const getDayOfWeekIndex = (day: DayOfWeek) => {
   return -1;
 }
 
+export const iAmOwner = (ownreId: number): boolean => {
+    return ownreId === UserConnected.getInstance().me?.id;
+}
+
 export const formatPhoneNumber = (phoneNumber: string): string => {
   let formattedNumber = "";
 

package/src/models/Event.ts

@@ -108,4 +108,4 @@ export default class Event {
 
         return [];
     }
-}
+}

package/src/models/Garage.ts

@@ -51,6 +51,8 @@ export default class Garage {
     defaultView?: string;
     loanerVehicleActive?: boolean;
     loanerVehicleRequestActive?: boolean;
+    paymentAuthorizationActive?: boolean;
+    paymentAuthorizationMinDowntime?: number;
 
     constructor(
         id:string,

package/src/services/AuthenticationService.ts

@@ -3,6 +3,7 @@ import { COOKIE_PRO_TOKEN, COOKIE_INDIVIDUAL_TOKEN, createCookie } from "../help
 import { APIMethod, MovaAppType } from "../helpers/Enums";
 import Logger from "../helpers/Logger";
 import User from "../models/User";
+import UserConnected from "./UserConnected";
 import UserService from "./UserService";
 
 export default class AuthenticationService {
@@ -68,7 +69,7 @@ export default class AuthenticationService {
                     Logger.error(errorMsg);
                     return { success: false, error: errorMsg };
                 }
-
+                UserConnected.getInstance().me = userResponse.data;
                 return { success: true, data: userResponse.data };
 
             } else {