fix(doc): aligne la version des pieds de page CGU et Mentions legales sur 1.1.0

Le pied de page Documentation etait passe en 1.1.0, mais les pages CGU et
Mentions legales affichaient encore v1.0 : l'application annoncait donc deux
versions differentes selon l'ecran consulte.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.gitea/workflows/build.yml

@@ -23,6 +23,7 @@ jobs:
           set -e
           echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login git.nfteam.ovh -u "${{ secrets.REGISTRY_USER }}" --password-stdin
           docker build --build-arg VITE_API_URL="${VITE_API_URL}" \
+            --build-arg APP_BUILD="${GITHUB_SHA::12}" \
             -t "${IMAGE}:latest" -t "${IMAGE}:${GITHUB_SHA::12}" ./DataSentinel
           docker push --all-tags "${IMAGE}"
           echo "pushed ${IMAGE}"

DataSentinel/Dockerfile

@@ -11,6 +11,11 @@ ARG VITE_API_URL
 ENV VITE_API_URL=$VITE_API_URL
 RUN pnpm build
 
+# SHA du commit construit, servi sur /version.json : permet de vérifier quelle
+# version est réellement déployée sans se fier au cache du navigateur.
+ARG APP_BUILD=local
+RUN printf '{"build":"%s"}' "$APP_BUILD" > /app/dist/version.json
+
 FROM nginx:alpine
 COPY --from=build /app/dist /usr/share/nginx/html
 COPY nginx.conf /etc/nginx/conf.d/default.conf

DataSentinel/src/__tests__/Admin.test.jsx

@@ -0,0 +1,174 @@
+/* Écran d'administration des référentiels.
+
+   Avant correction, les boutons Modifier / Désactiver n'appelaient rien
+   (console.log) et « Enregistrer » se contentait de fermer la modale. Ces
+   tests vérifient que chaque action atteint réellement l'API et que les
+   erreurs métier remontent à l'utilisateur. */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import Admin from '../pages/Admin/Admin';
+import * as api from '../services/api';
+
+const SERVICES = [
+  { id_service: 1, nom_service: 'Contrat' },
+  { id_service: 2, nom_service: 'Fournisseur' },
+];
+const CATEGORIES = [{ id_categorie: 1, intitule_categorie: 'Tiers-payeurs' }];
+const MONITORINGS = [{
+  id_monito: 1, monito_intitule: 'Erreurs tiers payeurs', id_service: 1,
+  id_categorie: 1, table_source: 'MONITO_TIERS_PAYEURS', bdd_source: 'Sage',
+}];
+
+function stubLectures() {
+  vi.spyOn(api, 'getServices').mockResolvedValue(SERVICES);
+  vi.spyOn(api, 'getCategories').mockResolvedValue(CATEGORIES);
+  vi.spyOn(api, 'getContacts').mockResolvedValue([]);
+  vi.spyOn(api, 'getMonitorings').mockResolvedValue(MONITORINGS);
+}
+
+async function ouvrirOnglet(utilisateur, nom) {
+  await utilisateur.click(screen.getByRole('button', { name: nom }));
+}
+
+describe('Admin — CRUD des référentiels', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    stubLectures();
+    vi.spyOn(window, 'confirm').mockReturnValue(true);
+  });
+
+  it('crée un service via l’API et recharge la liste', async () => {
+    const creation = vi.spyOn(api, 'createService').mockResolvedValue({ id_service: 3 });
+    const utilisateur = userEvent.setup();
+    render(<Admin />);
+
+    await screen.findByText('Administration');
+    await ouvrirOnglet(utilisateur, 'Services');
+    await utilisateur.click(screen.getByRole('button', { name: /Ajouter/ }));
+
+    await utilisateur.type(screen.getByLabelText('Nom du service'), 'Comptabilité');
+    await utilisateur.click(screen.getByRole('button', { name: 'Enregistrer' }));
+
+    await waitFor(() => {
+      expect(creation).toHaveBeenCalledWith({ nom_service: 'Comptabilité' });
+    });
+    /* Rechargement après écriture : la liste doit être redemandée. */
+    expect(api.getServices).toHaveBeenCalledTimes(2);
+  });
+
+  it('pré-remplit le formulaire de modification avec la ligne choisie', async () => {
+    vi.spyOn(api, 'updateService').mockResolvedValue({});
+    const utilisateur = userEvent.setup();
+    render(<Admin />);
+
+    await screen.findByText('Administration');
+    await ouvrirOnglet(utilisateur, 'Services');
+
+    const ligne = screen.getByText('Fournisseur').closest('tr');
+    await utilisateur.click(within(ligne).getByRole('button', { name: /Modifier/ }));
+
+    expect(screen.getByLabelText('Nom du service')).toHaveValue('Fournisseur');
+  });
+
+  it('envoie l’identifiant de la ligne lors d’une modification', async () => {
+    const modification = vi.spyOn(api, 'updateService').mockResolvedValue({});
+    const utilisateur = userEvent.setup();
+    render(<Admin />);
+
+    await screen.findByText('Administration');
+    await ouvrirOnglet(utilisateur, 'Services');
+
+    const ligne = screen.getByText('Fournisseur').closest('tr');
+    await utilisateur.click(within(ligne).getByRole('button', { name: /Modifier/ }));
+    await utilisateur.click(screen.getByRole('button', { name: 'Enregistrer' }));
+
+    await waitFor(() => {
+      expect(modification).toHaveBeenCalledWith(2, { nom_service: 'Fournisseur' });
+    });
+  });
+
+  it('demande confirmation avant de supprimer, et n’appelle rien si on refuse', async () => {
+    window.confirm.mockReturnValue(false);
+    const suppression = vi.spyOn(api, 'deleteService').mockResolvedValue({});
+    const utilisateur = userEvent.setup();
+    render(<Admin />);
+
+    await screen.findByText('Administration');
+    await ouvrirOnglet(utilisateur, 'Services');
+
+    const ligne = screen.getByText('Contrat').closest('tr');
+    await utilisateur.click(within(ligne).getByRole('button', { name: /Supprimer/ }));
+
+    expect(window.confirm).toHaveBeenCalled();
+    expect(suppression).not.toHaveBeenCalled();
+  });
+
+  it('affiche le refus de l’API quand des enregistrements sont rattachés', async () => {
+    /* Cas réel : l'API renvoie 409 avec le décompte des rattachements. */
+    vi.spyOn(api, 'deleteService').mockRejectedValue(
+      new Error('Erreur 409: Suppression impossible : 5 monitoring(s) rattachés.'),
+    );
+    const utilisateur = userEvent.setup();
+    render(<Admin />);
+
+    await screen.findByText('Administration');
+    await ouvrirOnglet(utilisateur, 'Services');
+
+    const ligne = screen.getByText('Contrat').closest('tr');
+    await utilisateur.click(within(ligne).getByRole('button', { name: /Supprimer/ }));
+
+    expect(await screen.findByText(/5 monitoring\(s\) rattachés/)).toBeInTheDocument();
+  });
+
+  it('parle de désactivation, pas de suppression, pour un monitoring', async () => {
+    /* TABLE_FINAL référence le monitoring : il n'est jamais supprimé. */
+    const desactivation = vi.spyOn(api, 'desactiverMonitoring').mockResolvedValue({});
+    const utilisateur = userEvent.setup();
+    render(<Admin />);
+
+    await screen.findByText('Administration');
+
+    const ligne = screen.getByText('Erreurs tiers payeurs').closest('tr');
+    expect(within(ligne).getByRole('button', { name: /Désactiver/ })).toBeInTheDocument();
+
+    await utilisateur.click(within(ligne).getByRole('button', { name: /Désactiver/ }));
+    await waitFor(() => expect(desactivation).toHaveBeenCalledWith(1));
+  });
+
+  it('affiche le libellé du service plutôt que son identifiant brut', async () => {
+    render(<Admin />);
+    await screen.findByText('Administration');
+
+    const ligne = screen.getByText('Erreurs tiers payeurs').closest('tr');
+    /* id_service = 1 doit s'afficher « Contrat ». */
+    expect(within(ligne).getByText('Contrat')).toBeInTheDocument();
+  });
+
+  it('convertit en entier les identifiants issus des listes déroulantes', async () => {
+    /* Un <select> renvoie une chaîne ; l'API attend un entier. */
+    const creation = vi.spyOn(api, 'createMonitoring').mockResolvedValue({ id_monito: 9 });
+    const utilisateur = userEvent.setup();
+    render(<Admin />);
+
+    await screen.findByText('Administration');
+    await utilisateur.click(screen.getByRole('button', { name: /Ajouter/ }));
+
+    await utilisateur.type(screen.getByLabelText('Nom'), 'Nouveau monitoring');
+    await utilisateur.selectOptions(screen.getByLabelText('Service'), '2');
+    await utilisateur.selectOptions(screen.getByLabelText('Catégorie'), '1');
+    await utilisateur.type(screen.getByLabelText('Table source'), 'MONITO_TEST');
+    await utilisateur.type(screen.getByLabelText('Base source'), 'Sage');
+    await utilisateur.click(screen.getByRole('button', { name: 'Enregistrer' }));
+
+    await waitFor(() => {
+      expect(creation).toHaveBeenCalledWith({
+        monito_intitule: 'Nouveau monitoring',
+        id_service: 2,
+        id_categorie: 1,
+        table_source: 'MONITO_TEST',
+        bdd_source: 'Sage',
+      });
+    });
+  });
+});

DataSentinel/src/__tests__/Dashboard.test.jsx

@@ -0,0 +1,108 @@
+/* Filtres du dashboard.
+
+   Le comportement testé ici est la correction apportée aux menus déroulants :
+   ils étaient alimentés par les référentiels SERVICE / CATEGORIE complets,
+   dont certaines entrées (« Business Intelligence ») n'ont aucun monitoring
+   rattaché et menaient sur un écran vide. */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter } from 'react-router-dom';
+import Dashboard from '../pages/Dashboard/Dashboard';
+import * as api from '../services/api';
+
+/* Ce que renvoie GET /dashboard/filtres : uniquement les valeurs présentes
+   dans VUE_CONSO. Contrat porte 2 catégories, Fournisseur une seule. */
+const FILTRES = {
+  services: ['Contrat', 'Fournisseur'],
+  categories: ['Comptes fournisseurs', 'DOM-TOM', 'Tiers-payeurs'],
+  combinaisons: [
+    { service: 'Contrat', categorie: 'DOM-TOM' },
+    { service: 'Contrat', categorie: 'Tiers-payeurs' },
+    { service: 'Fournisseur', categorie: 'Comptes fournisseurs' },
+  ],
+};
+
+function renduDashboard() {
+  return render(<MemoryRouter><Dashboard /></MemoryRouter>);
+}
+
+describe('Dashboard — menus de filtre', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.spyOn(api, 'getDashboardFiltres').mockResolvedValue(FILTRES);
+    vi.spyOn(api, 'getDashboardSummary').mockResolvedValue({
+      total: 3, ok: 0, critical: 3, total_erreurs: 12,
+    });
+    vi.spyOn(api, 'getDashboard').mockResolvedValue([]);
+  });
+
+  it('ne propose que les services ayant au moins un monitoring', async () => {
+    renduDashboard();
+
+    const selectService = await screen.findByDisplayValue('Tous les services');
+    const options = [...selectService.options].map(o => o.value);
+
+    expect(options).toContain('Contrat');
+    expect(options).toContain('Fournisseur');
+    /* Le cœur du correctif : ces entrées du référentiel ne doivent pas
+       apparaître puisqu'elles ramèneraient un dashboard vide. */
+    expect(options).not.toContain('Business Intelligence');
+    expect(options).not.toContain('Comptabilité');
+  });
+
+  it('restreint les catégories au service sélectionné', async () => {
+    const utilisateur = userEvent.setup();
+    renduDashboard();
+
+    const selectService = await screen.findByDisplayValue('Tous les services');
+    const selectCategorie = screen.getByDisplayValue('Toutes les catégories');
+
+    /* Sans filtre de service : toutes les catégories utilisées */
+    expect([...selectCategorie.options].map(o => o.value)).toEqual(
+      expect.arrayContaining(['DOM-TOM', 'Tiers-payeurs', 'Comptes fournisseurs']),
+    );
+
+    await utilisateur.selectOptions(selectService, 'Fournisseur');
+
+    await waitFor(() => {
+      const restantes = [...selectCategorie.options].map(o => o.value).filter(Boolean);
+      expect(restantes).toEqual(['Comptes fournisseurs']);
+    });
+  });
+
+  it('réinitialise la catégorie devenue sans résultat après changement de service', async () => {
+    const utilisateur = userEvent.setup();
+    renduDashboard();
+
+    const selectService = await screen.findByDisplayValue('Tous les services');
+    const selectCategorie = screen.getByDisplayValue('Toutes les catégories');
+
+    await utilisateur.selectOptions(selectCategorie, 'DOM-TOM');
+    expect(selectCategorie.value).toBe('DOM-TOM');
+
+    /* DOM-TOM n'existe pas pour Fournisseur : garder la sélection
+       produirait une combinaison vide. */
+    await utilisateur.selectOptions(selectService, 'Fournisseur');
+
+    await waitFor(() => expect(selectCategorie.value).toBe(''));
+  });
+
+  it('interroge l’API avec les filtres sélectionnés', async () => {
+    const utilisateur = userEvent.setup();
+    renduDashboard();
+
+    const selectService = await screen.findByDisplayValue('Tous les services');
+    await utilisateur.selectOptions(selectService, 'Contrat');
+
+    await waitFor(() => {
+      expect(api.getDashboard).toHaveBeenLastCalledWith('Contrat', '');
+    });
+  });
+
+  it('affiche les KPI renvoyés par l’API', async () => {
+    renduDashboard();
+    expect(await screen.findByText('12')).toBeInTheDocument();
+    expect(screen.getByText('Total erreurs')).toBeInTheDocument();
+  });
+});

DataSentinel/src/__tests__/accessibilite.test.jsx

@@ -0,0 +1,89 @@
+/* Accessibilité des composants transverses.
+
+   Le dossier affirme que les boîtes de dialogue piègent le focus et que les
+   messages dynamiques sont annoncés aux lecteurs d'écran. Ces tests rendent ces
+   affirmations vérifiables : elles étaient auparavant invalidables autrement
+   qu'en relisant le code. */
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import Modal from '../components/common/Modal';
+import ErrorMessage from '../components/common/ErrorMessage';
+import LoadingSpinner from '../components/common/LoadingSpinner';
+
+function ouvrirModale(onClose = () => {}) {
+  return render(
+    <Modal isOpen onClose={onClose} title="Modifier le service">
+      <input aria-label="Nom" />
+      <button>Enregistrer</button>
+    </Modal>,
+  );
+}
+
+describe('Modal — accessibilité', () => {
+  it('est exposée comme boîte de dialogue modale', () => {
+    ouvrirModale();
+    const dialogue = screen.getByRole('dialog');
+    expect(dialogue).toHaveAttribute('aria-modal', 'true');
+  });
+
+  it('est nommée par son titre', () => {
+    ouvrirModale();
+    /* Le lecteur d'écran doit annoncer de quoi parle la modale. */
+    expect(screen.getByRole('dialog', { name: 'Modifier le service' })).toBeInTheDocument();
+  });
+
+  it('place le focus sur le premier champ à l’ouverture', () => {
+    ouvrirModale();
+    expect(screen.getByLabelText('Nom')).toHaveFocus();
+  });
+
+  it('referme la modale à la touche Échap', async () => {
+    const onClose = vi.fn();
+    const utilisateur = userEvent.setup();
+    ouvrirModale(onClose);
+
+    await utilisateur.keyboard('{Escape}');
+    expect(onClose).toHaveBeenCalled();
+  });
+
+  it('retient le focus à l’intérieur de la modale', async () => {
+    const utilisateur = userEvent.setup();
+    ouvrirModale();
+
+    /* Depuis le dernier élément, Tab doit revenir au premier et non filer
+       vers la page située derrière. */
+    const fermer = screen.getByRole('button', { name: 'Fermer' });
+    fermer.focus();
+    await utilisateur.tab();
+
+    expect(document.activeElement).not.toBe(document.body);
+    expect(screen.getByRole('dialog').contains(document.activeElement)).toBe(true);
+  });
+
+  it('n’affiche rien quand elle est fermée', () => {
+    render(<Modal isOpen={false} onClose={() => {}} title="Titre">contenu</Modal>);
+    expect(screen.queryByRole('dialog')).toBeNull();
+  });
+});
+
+describe('Messages dynamiques — annonce aux lecteurs d’écran', () => {
+  it('annonce une erreur immédiatement', () => {
+    render(<ErrorMessage message="Erreur 500 : service indisponible" />);
+    const alerte = screen.getByRole('alert');
+    expect(alerte).toHaveAttribute('aria-live', 'assertive');
+    expect(alerte).toHaveTextContent('service indisponible');
+  });
+
+  it('annonce le chargement sans interrompre la lecture', () => {
+    render(<LoadingSpinner message="Chargement de l'historique..." />);
+    const statut = screen.getByRole('status');
+    expect(statut).toHaveAttribute('aria-live', 'polite');
+  });
+
+  it('masque les éléments purement décoratifs', () => {
+    /* L'animation du spinner n'apporte rien à l'oral : elle doit être ignorée. */
+    const { container } = render(<LoadingSpinner />);
+    expect(container.querySelector('[aria-hidden="true"]')).toBeInTheDocument();
+  });
+});

DataSentinel/src/__tests__/dates.test.js

@@ -0,0 +1,50 @@
+/* Formatage des bornes de période de la page Historique.
+
+   Ces tests protègent une régression précise : la version d'origine utilisait
+   toISOString(), qui convertit en UTC. Depuis un fuseau en avance sur UTC
+   (Paris = UTC+1 en hiver), le 1er janvier local devient le 31 décembre de
+   l'année précédente, et la période affichée est décalée d'un jour. */
+import { describe, it, expect } from 'vitest';
+import { formatDateISO, periodeParDefaut } from '../utils/dates';
+
+describe('formatDateISO', () => {
+  it('formate une date en YYYY-MM-DD', () => {
+    expect(formatDateISO(new Date(2026, 7, 15))).toBe('2026-08-15');
+  });
+
+  it('complète le mois et le jour à deux chiffres', () => {
+    expect(formatDateISO(new Date(2026, 0, 5))).toBe('2026-01-05');
+  });
+
+  it('ne décale pas la date à minuit en heure locale', () => {
+    /* Le cas qui cassait : minuit local est la veille en UTC dès UTC+1. */
+    const premierJanvierMinuit = new Date(2026, 0, 1, 0, 0, 0);
+    expect(formatDateISO(premierJanvierMinuit)).toBe('2026-01-01');
+  });
+
+  it('ne décale pas non plus en fin de journée', () => {
+    /* Symétrique : 23h local bascule au lendemain pour les fuseaux négatifs. */
+    const finDeJournee = new Date(2026, 11, 31, 23, 30, 0);
+    expect(formatDateISO(finDeJournee)).toBe('2026-12-31');
+  });
+});
+
+describe('periodeParDefaut', () => {
+  it('démarre au 1er janvier de l’année de la date fournie', () => {
+    expect(periodeParDefaut(new Date(2026, 7, 15)).debut).toBe('2026-01-01');
+  });
+
+  it('se termine à la date fournie', () => {
+    expect(periodeParDefaut(new Date(2026, 7, 15)).fin).toBe('2026-08-15');
+  });
+
+  it('reste cohérente le 1er janvier (début = fin)', () => {
+    const periode = periodeParDefaut(new Date(2026, 0, 1));
+    expect(periode.debut).toBe('2026-01-01');
+    expect(periode.fin).toBe('2026-01-01');
+  });
+
+  it('suit le changement d’année', () => {
+    expect(periodeParDefaut(new Date(2027, 2, 9)).debut).toBe('2027-01-01');
+  });
+});

DataSentinel/src/__tests__/exportToCSV.test.js

@@ -0,0 +1,83 @@
+/* Export CSV, utilisé par les pages Vue consolidée, Contrat, Fournisseur,
+   Historique et Détail monitoring. Les données exportées viennent de Sage et
+   du CRM : elles contiennent des intitulés avec virgules et apostrophes, d'où
+   l'importance de l'échappement. */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { exportToCSV } from '../services/api';
+
+/* Capture le contenu du Blob passé à URL.createObjectURL, sans télécharger. */
+function capturerCSV(data, filename) {
+  let contenu = '';
+  let nomFichier = '';
+
+  vi.stubGlobal('Blob', class {
+    constructor(parties) { contenu = parties.join(''); }
+  });
+  vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:fake');
+  vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {});
+  vi.spyOn(document, 'createElement').mockReturnValue({
+    set download(valeur) { nomFichier = valeur; },
+    get download() { return nomFichier; },
+    href: '',
+    click: () => {},
+  });
+
+  exportToCSV(data, filename);
+  return { contenu, nomFichier };
+}
+
+describe('exportToCSV', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('écrit une ligne d’en-têtes puis une ligne par enregistrement', () => {
+    const { contenu } = capturerCSV(
+      [{ nom: 'Tiers payeurs', erreurs: 5 }, { nom: 'DOM-TOM', erreurs: 3 }],
+      'export.csv',
+    );
+    const lignes = contenu.split('\n');
+    expect(lignes[0]).toBe('nom,erreurs');
+    expect(lignes[1]).toBe('Tiers payeurs,5');
+    expect(lignes[2]).toBe('DOM-TOM,3');
+  });
+
+  it('entoure de guillemets une valeur contenant une virgule', () => {
+    /* Sans échappement, la virgule créerait une colonne fantôme. */
+    const { contenu } = capturerCSV([{ intitule: 'XEFI Lyon, agence Est' }], 'x.csv');
+    expect(contenu.split('\n')[1]).toBe('"XEFI Lyon, agence Est"');
+  });
+
+  it('double les guillemets internes', () => {
+    const { contenu } = capturerCSV([{ intitule: 'Client "Test"' }], 'x.csv');
+    expect(contenu.split('\n')[1]).toBe('"Client ""Test"""');
+  });
+
+  it('protège une valeur contenant un saut de ligne', () => {
+    const { contenu } = capturerCSV([{ adresse: 'Ligne 1\nLigne 2' }], 'x.csv');
+    expect(contenu).toContain('"Ligne 1\nLigne 2"');
+  });
+
+  it('rend les valeurs nulles ou absentes par une cellule vide', () => {
+    const { contenu } = capturerCSV([{ a: null, b: undefined, c: 'ok' }], 'x.csv');
+    expect(contenu.split('\n')[1]).toBe(',,ok');
+  });
+
+  it('conserve le zéro au lieu de le traiter comme une valeur vide', () => {
+    /* 0 est falsy : un test de vérité naïf l’effacerait alors que
+       « 0 erreur » est justement l’information utile. */
+    const { contenu } = capturerCSV([{ nb_erreurs: 0 }], 'x.csv');
+    expect(contenu.split('\n')[1]).toBe('0');
+  });
+
+  it('utilise le nom de fichier demandé', () => {
+    const { nomFichier } = capturerCSV([{ a: 1 }], 'historique_2026.csv');
+    expect(nomFichier).toBe('historique_2026.csv');
+  });
+
+  it('n’exporte rien si la liste est vide', () => {
+    const creerElement = vi.spyOn(document, 'createElement');
+    exportToCSV([], 'vide.csv');
+    expect(creerElement).not.toHaveBeenCalled();
+  });
+});

DataSentinel/src/__tests__/statutMonitoring.test.js

@@ -0,0 +1,33 @@
+/* Règle métier de classement d'un monitoring selon son nombre d'erreurs.
+   Elle était dupliquée dans trois composants avant d'être centralisée : ces
+   tests fixent le contrat pour que les trois écrans restent cohérents. */
+import { describe, it, expect } from 'vitest';
+import { getStatutMonitoring, SEUIL_ATTENTION } from '../utils/statutMonitoring';
+
+describe('getStatutMonitoring', () => {
+  it('classe OK un monitoring sans erreur', () => {
+    expect(getStatutMonitoring(0).label).toBe('OK');
+    expect(getStatutMonitoring(0).variant).toBe('ok');
+  });
+
+  it('classe Attention en dessous du seuil', () => {
+    expect(getStatutMonitoring(1).label).toBe('Attention');
+    expect(getStatutMonitoring(SEUIL_ATTENTION - 1).label).toBe('Attention');
+  });
+
+  it('bascule en Critique à partir du seuil, pas avant', () => {
+    /* La borne est le point où une erreur de type < / <= se verrait. */
+    expect(getStatutMonitoring(SEUIL_ATTENTION - 1).label).toBe('Attention');
+    expect(getStatutMonitoring(SEUIL_ATTENTION).label).toBe('Critique');
+    expect(getStatutMonitoring(SEUIL_ATTENTION + 1).label).toBe('Critique');
+  });
+
+  it('fournit toujours un libellé, une variante et une couleur', () => {
+    for (const nb of [0, 5, 50]) {
+      const statut = getStatutMonitoring(nb);
+      expect(statut.label).toBeTruthy();
+      expect(statut.variant).toBeTruthy();
+      expect(statut.color).toMatch(/^var\(--/);
+    }
+  });
+});

DataSentinel/src/components/Layout/Header.jsx

@@ -1,6 +1,6 @@
 /* En-tête fixe de l'application Data Sentinel */
 
-import { Bell, LogOut, Menu } from 'lucide-react';
+import { LogOut, Menu } from 'lucide-react';
 import { useAuth } from '../../context/useAuth';
 import { useNavigate } from 'react-router-dom';
 import styles from './Header.module.css';
@@ -40,9 +40,6 @@ export default function Header({ onToggleSidebar, sidebarOpen }) {
       </div>
 
       <div className={styles.right}>
-        <button className={styles.iconBtn} aria-label="Notifications">
-          <Bell size={18} color="var(--color-white)" aria-hidden="true" />
-        </button>
         {user && (
           <span className={styles.username} aria-label={`Connecté en tant que ${user.username}`}>
             {user.username}

DataSentinel/src/components/Layout/Header.module.css

@@ -68,15 +68,6 @@
   gap: 16px;
 }
 
-.iconBtn {
-  background: none;
-  border: none;
-  cursor: pointer;
-  padding: 4px;
-  display: flex;
-  align-items: center;
-}
-
 .username {
   color: var(--color-white);
   font-size: 13px;
@@ -122,7 +113,6 @@
 
 /* Focus visible sur tous les éléments interactifs */
 .burgerBtn:focus-visible,
-.iconBtn:focus-visible,
 .logoutBtn:focus-visible {
   outline: 2px solid var(--color-white);
   outline-offset: 2px;

DataSentinel/src/components/common/ErrorMessage.jsx

@@ -4,9 +4,12 @@ import { AlertCircle } from 'lucide-react';
 import styles from './ErrorMessage.module.css';
 
 export default function ErrorMessage({ message = 'Une erreur est survenue.', onRetry }) {
+  /* role="alert" annonce l'erreur immédiatement au lecteur d'écran : elle
+     apparaît après le chargement de la page, sans quoi elle passerait
+     inaperçue pour un utilisateur non voyant. */
   return (
-    <div className={styles.container}>
-      <AlertCircle size={20} color="var(--color-primary)" />
+    <div className={styles.container} role="alert" aria-live="assertive">
+      <AlertCircle size={20} color="var(--color-primary)" aria-hidden="true" />
       <p className={styles.text}>{message}</p>
       {onRetry && (
         <button className={styles.retryBtn} onClick={onRetry}>

DataSentinel/src/components/common/LoadingSpinner.jsx

@@ -3,9 +3,11 @@
 import styles from './LoadingSpinner.module.css';
 
 export default function LoadingSpinner({ message = 'Chargement...' }) {
+  /* aria-live="polite" fait annoncer la fin du chargement sans interrompre la
+     lecture en cours ; l'animation elle-même n'apporte rien à l'oral. */
   return (
-    <div className={styles.container}>
-      <div className={styles.spinner} />
+    <div className={styles.container} role="status" aria-live="polite">
+      <div className={styles.spinner} aria-hidden="true" />
       {message && <p className={styles.message}>{message}</p>}
     </div>
   );

DataSentinel/src/components/common/Modal.jsx

@@ -1,13 +1,74 @@
+import { useEffect, useId, useRef } from 'react';
 import styles from './Modal.module.css';
 
+/* Sélecteur des éléments qui peuvent recevoir le focus au clavier. */
+const ELEMENTS_FOCUSABLES =
+  'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])';
+
 export default function Modal({ isOpen, onClose, title, children }) {
+  const conteneur = useRef(null);
+  /* useId fournit un identifiant stable et unique par instance, sans tirage
+     aléatoire pendant le rendu et sans collision si deux modales coexistent. */
+  const titreId = useId();
+
+  /* Piège le focus dans la modale et gère la touche Échap.
+     Sans cela, la tabulation continue de parcourir la page située derrière,
+     ce qui rend la boîte de dialogue inutilisable au clavier. */
+  useEffect(() => {
+    if (!isOpen) return undefined;
+
+    const elementActifAvant = document.activeElement;
+    /* On vise d'abord le contenu : sur une modale de formulaire, ouvrir sur le
+       premier champ évite à l'utilisateur une tabulation inutile. À défaut, on
+       se rabat sur le premier élément focusable, souvent le bouton de fermeture. */
+    const corps = conteneur.current?.querySelector(`.${styles.modalBody}`);
+    const premier = corps?.querySelector(ELEMENTS_FOCUSABLES)
+      ?? conteneur.current?.querySelector(ELEMENTS_FOCUSABLES);
+    premier?.focus();
+
+    function handleKeyDown(evenement) {
+      if (evenement.key === 'Escape') {
+        onClose();
+        return;
+      }
+      if (evenement.key !== 'Tab') return;
+
+      const focusables = conteneur.current?.querySelectorAll(ELEMENTS_FOCUSABLES);
+      if (!focusables?.length) return;
+
+      const premier = focusables[0];
+      const dernier = focusables[focusables.length - 1];
+
+      if (evenement.shiftKey && document.activeElement === premier) {
+        evenement.preventDefault();
+        dernier.focus();
+      } else if (!evenement.shiftKey && document.activeElement === dernier) {
+        evenement.preventDefault();
+        premier.focus();
+      }
+    }
+
+    document.addEventListener('keydown', handleKeyDown);
+    return () => {
+      document.removeEventListener('keydown', handleKeyDown);
+      elementActifAvant?.focus?.();
+    };
+  }, [isOpen, onClose]);
+
   if (!isOpen) return null;
 
   return (
     <div className={styles.modalOverlay} onClick={onClose}>
-      <div className={styles.modal} onClick={e => e.stopPropagation()}>
+      <div
+        className={styles.modal}
+        ref={conteneur}
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={titreId}
+        onClick={e => e.stopPropagation()}
+      >
         <div className={styles.modalHeader}>
-          <h2>{title}</h2>
+          <h2 id={titreId}>{title}</h2>
           <button className={styles.closeBtn} onClick={onClose} aria-label="Fermer">×</button>
         </div>
         <div className={styles.modalBody}>

DataSentinel/src/pages/Admin/referentielsConfig.js

@@ -1,9 +1,7 @@
-import {
-  createService, updateService, deleteService,
-  createCategorie, updateCategorie, deleteCategorie,
-  createContact, updateContact, deleteContact,
-  createMonitoring, updateMonitoring, desactiverMonitoring,
-} from '../../services/api';
+/* Les appels API sont référencés via l'espace de noms et résolus au moment de
+   l'appel, et non capturés à l'import : la configuration ne fige donc pas une
+   implémentation, ce qui la découple du module d'API. */
+import * as api from '../../services/api';
 
 /* Description déclarative des 4 référentiels administrables.
    Les colonnes du tableau, les champs du formulaire et les appels API sont
@@ -31,9 +29,9 @@ export const REFERENTIELS = [
       { name: 'table_source', label: 'Table source', type: 'text', required: true },
       { name: 'bdd_source', label: 'Base source', type: 'text', required: true },
     ],
-    creer: createMonitoring,
-    modifier: updateMonitoring,
-    supprimer: desactiverMonitoring,
+    creer: body => api.createMonitoring(body),
+    modifier: (id, body) => api.updateMonitoring(id, body),
+    supprimer: id => api.desactiverMonitoring(id),
   },
   {
     key: 'services',
@@ -42,9 +40,9 @@ export const REFERENTIELS = [
     idField: 'id_service',
     colonnes: [{ key: 'nom_service', label: 'Nom' }],
     champs: [{ name: 'nom_service', label: 'Nom du service', type: 'text', required: true }],
-    creer: createService,
-    modifier: updateService,
-    supprimer: deleteService,
+    creer: body => api.createService(body),
+    modifier: (id, body) => api.updateService(id, body),
+    supprimer: id => api.deleteService(id),
   },
   {
     key: 'categories',
@@ -53,9 +51,9 @@ export const REFERENTIELS = [
     idField: 'id_categorie',
     colonnes: [{ key: 'intitule_categorie', label: 'Nom' }],
     champs: [{ name: 'intitule_categorie', label: 'Intitulé', type: 'text', required: true }],
-    creer: createCategorie,
-    modifier: updateCategorie,
-    supprimer: deleteCategorie,
+    creer: body => api.createCategorie(body),
+    modifier: (id, body) => api.updateCategorie(id, body),
+    supprimer: id => api.deleteCategorie(id),
   },
   {
     key: 'contacts',
@@ -76,9 +74,9 @@ export const REFERENTIELS = [
       { name: 'mail', label: 'Email', type: 'email', required: true },
       { name: 'id_service', label: 'Service', type: 'select', options: 'services', required: true },
     ],
-    creer: createContact,
-    modifier: updateContact,
-    supprimer: deleteContact,
+    creer: body => api.createContact(body),
+    modifier: (id, body) => api.updateContact(id, body),
+    supprimer: id => api.deleteContact(id),
   },
 ];
 

DataSentinel/src/pages/CGU/CGU.jsx

@@ -27,14 +27,17 @@ export default function CGU() {
             <h2 id="art1">Article 1 — Objet et champ d'application</h2>
             <p>
               Les présentes Conditions Générales d'Utilisation (ci-après « CGU ») régissent l'accès et
-              l'utilisation de la plateforme <strong>Data Sentinel</strong>, outil interne de monitoring
-              de la qualité des données développé par COYAUD Anthony pour le compte de <strong>XEFI SA</strong>
-              (ci-après « l'Éditeur »).
+              l'utilisation de la plateforme <strong>Data Sentinel</strong>, outil de monitoring de la
+              qualité des données développé par <strong>COYAUD Anthony</strong> (ci-après « l'Éditeur »)
+              dans le cadre de son projet annuel Nexa Digital School, en réponse à un besoin du service
+              Business Intelligence de <strong>XEFI SA</strong> (commanditaire).
             </p>
             <p>
-              Data Sentinel est une application web à usage professionnel interne, accessible uniquement
-              aux collaborateurs habilités de XEFI et de ses filiales. Toute utilisation de la plateforme
-              implique l'acceptation pleine et entière des présentes CGU.
+              Data Sentinel est une application web à usage professionnel interne. La présente instance
+              est une <strong>démonstration académique</strong> : elle est accessible à des fins
+              d'évaluation au moyen de comptes de test et ne contient aucune donnée réelle
+              d'entreprise. Toute utilisation de la plateforme implique l'acceptation pleine et entière
+              des présentes CGU.
             </p>
           </section>
 
@@ -42,8 +45,9 @@ export default function CGU() {
             <h2 id="art2">Article 2 — Accès au service</h2>
             <p>
               L'accès à Data Sentinel est réservé aux utilisateurs disposant d'un compte valide créé
-              par un administrateur système XEFI. L'authentification s'effectue via un identifiant et
-              un mot de passe fournis par l'entreprise.
+              par un administrateur de la plateforme. L'authentification s'effectue par identifiant et
+              mot de passe, complétée par une vérification anti-robot. Les mots de passe ne sont jamais
+              stockés en clair.
             </p>
             <ul className={styles.list}>
               <li>Chaque utilisateur est responsable de la confidentialité de ses identifiants.</li>
@@ -58,11 +62,17 @@ export default function CGU() {
             <p>Data Sentinel offre les fonctionnalités suivantes :</p>
             <ul className={styles.list}>
               <li><strong>Dashboard</strong> — Vue d'ensemble des indicateurs clés de qualité des données (KPI).</li>
-              <li><strong>Monitoring</strong> — Suivi en temps réel des monitorings CRM, Sage et Infocentre.</li>
+              <li><strong>Monitoring</strong> — Suivi de 7 monitorings répartis sur deux pôles (Contrat, Fournisseur), alimentés par des extractions de Sage et du CRM.</li>
               <li><strong>Vue consolidée</strong> — Agrégation des résultats par service et catégorie.</li>
-              <li><strong>Historique</strong> — Consultation et export des données historiques.</li>
+              <li><strong>Historique</strong> — Consultation et export des données historiques, à partir d'un instantané quotidien.</li>
               <li><strong>Administration</strong> — Gestion des nomenclatures, utilisateurs et journaux.</li>
             </ul>
+            <p>
+              Le service ne comporte <strong>ni vente, ni transaction, ni paiement en ligne</strong> :
+              aucune condition générale de vente n'est donc applicable. Il ne propose
+              <strong> aucun espace de contribution</strong> (commentaires, forum, avis), ce qui rend
+              sans objet toute politique de modération.
+            </p>
           </section>
 
           <section className={styles.section} aria-labelledby="art4">
@@ -80,33 +90,50 @@ export default function CGU() {
           <section className={styles.section} aria-labelledby="art5">
             <h2 id="art5">Article 5 — Protection des données personnelles (RGPD)</h2>
             <p>
-              Conformément au Règlement Général sur la Protection des Données (UE 2016/679), XEFI SA
-              traite les données personnelles des utilisateurs dans le strict respect de la réglementation.
+              Le traitement est conçu conformément au Règlement Général sur la Protection des Données
+              (UE 2016/679). Les données personnelles traitées sont limitées au strict nécessaire pour
+              authentifier les utilisateurs et tracer les actions d'administration.
             </p>
             <div className={styles.infoBox} role="note" aria-label="Informations RGPD">
-              <p><strong>Responsable du traitement :</strong> XEFI SA — 2507 Avenue de l'Europe, 69140 Rillieux-la-Pape</p>
-              <p><strong>Délégué à la Protection des Données (DPO) :</strong> dpo@xefi.fr</p>
+              <p><strong>Responsable du traitement (instance de démonstration) :</strong> COYAUD Anthony — a.coyaud@xefi.fr</p>
+              <p><strong>Données traitées :</strong> identifiant, e-mail, rôle, horodatage des connexions et des actions d'administration.</p>
               <p><strong>Finalité :</strong> Authentification, traçabilité des actions, sécurité du système.</p>
-              <p><strong>Durée de conservation :</strong> 24 mois à compter de la dernière connexion.</p>
-              <p><strong>Droits :</strong> Accès, rectification, effacement, portabilité — à exercer auprès de dpo@xefi.fr.</p>
+              <p><strong>Base légale :</strong> intérêt légitime — fiabilité des données et traçabilité des accès.</p>
+              <p><strong>Conservation :</strong> historique de monitoring purgé automatiquement au-delà de 24 mois. Les comptes et le journal d'audit sont conservés le temps de l'exploitation, puis supprimés avec l'instance.</p>
+              <p><strong>Droits :</strong> export de ses données et suppression de son compte directement dans l'application (portabilité art. 20, effacement art. 17 par désactivation et anonymisation). Pour toute autre demande — accès, rectification, opposition : a.coyaud@xefi.fr.</p>
+              <p><strong>Transferts hors UE :</strong> aucun. <strong>Traceurs tiers :</strong> aucun.</p>
             </div>
+            <p>
+              Dans l'hypothèse d'un déploiement en production chez XEFI SA, la responsabilité du
+              traitement reviendrait à l'entreprise et une validation par son délégué à la protection
+              des données serait requise au préalable.
+            </p>
           </section>
 
           <section className={styles.section} aria-labelledby="art6">
             <h2 id="art6">Article 6 — Accessibilité</h2>
             <p>
-              XEFI s'engage à rendre Data Sentinel accessible conformément au Référentiel Général
-              d'Amélioration de l'Accessibilité (RGAA). L'application respecte les principes WCAG 2.1
-              niveau AA : perceptibilité, utilisabilité, compréhension et robustesse.
+              L'Éditeur s'est fixé pour <strong>objectif</strong> le niveau AA des WCAG 2.1, en
+              s'appuyant sur le Référentiel Général d'Amélioration de l'Accessibilité (RGAA).
+              Cet objectif est poursuivi par une démarche intégrée aux composants ; il ne fait pas
+              encore l'objet d'une déclaration de conformité, l'audit formel restant à mener.
             </p>
+            <p>Mesures effectivement en place :</p>
             <ul className={styles.list}>
-              <li>Navigation clavier intégrale supportée.</li>
-              <li>Compatibilité avec les lecteurs d'écran (ARIA labels, landmarks, roles).</li>
-              <li>Contrastes de couleurs conformes aux exigences WCAG 2.1 AA (ratio 4.5:1 minimum).</li>
+              <li>Navigation clavier sur l'ensemble des contrôles ; les boîtes de dialogue retiennent le focus, se ferment par Échap et le restituent à l'élément appelant.</li>
+              <li>Attributs ARIA (labels, landmarks, rôles), langue déclarée, annonces des messages d'erreur et de chargement aux lecteurs d'écran.</li>
+              <li>Formulaires étiquetés ; la connexion est protégée par un captcha additif, sans image ni distorsion, donc restituable par un lecteur d'écran.</li>
+              <li>Aucune information portée par la seule couleur : les statuts sont doublés d'un libellé.</li>
               <li>Interface responsive adaptée aux écrans de 320px à 1920px.</li>
             </ul>
+            <p>Points restant à traiter, énoncés par transparence :</p>
+            <ul className={styles.list}>
+              <li>Vérification systématique des contrastes (ratio 4.5:1) lors d'un audit dédié.</li>
+              <li>Tests sur lecteurs d'écran réels (NVDA, VoiceOver) non encore réalisés.</li>
+              <li>Aucune surcouche d'accessibilité n'est installée : ces widgets dégradent souvent la sémantique et la navigation clavier, l'accessibilité étant traitée à la source dans les composants.</li>
+            </ul>
             <p>
-              Pour signaler un problème d'accessibilité : <strong>dpo@xefi.fr</strong>
+              Pour signaler un problème d'accessibilité : <strong>a.coyaud@xefi.fr</strong>
             </p>
           </section>
 
@@ -122,17 +149,18 @@ export default function CGU() {
           <section className={styles.section} aria-labelledby="art8">
             <h2 id="art8">Article 8 — Propriété intellectuelle</h2>
             <p>
-              L'ensemble des éléments composant Data Sentinel (code source, design, données, documentation)
-              est la propriété exclusive de <strong>XEFI SA</strong>. Toute reproduction, modification
-              ou diffusion sans autorisation écrite préalable est interdite.
+              L'ensemble des éléments composant Data Sentinel (code source, design, documentation) a été
+              réalisé par <strong>COYAUD Anthony</strong> dans le cadre de son alternance chez XEFI SA et
+              de son projet annuel — Bachelor DBI, Nexa Digital School, 2026. Les règles de gestion et le
+              besoin métier appartiennent à XEFI SA.
             </p>
-            <p>Application développée par <strong>COYAUD Anthony</strong> — Bachelor DBI, Nexa Digital School, 2026.</p>
+            <p>Toute reproduction, modification ou diffusion sans autorisation préalable est interdite.</p>
           </section>
 
           <section className={styles.section} aria-labelledby="art9">
             <h2 id="art9">Article 9 — Modification des CGU</h2>
             <p>
-              XEFI SA se réserve le droit de modifier les présentes CGU à tout moment. Les utilisateurs
+              L'Éditeur se réserve le droit de modifier les présentes CGU à tout moment. Les utilisateurs
               seront informés de toute modification substantielle. La poursuite de l'utilisation de la
               plateforme après notification vaut acceptation des nouvelles conditions.
             </p>
@@ -142,15 +170,15 @@ export default function CGU() {
             <h2 id="art10">Article 10 — Droit applicable et contact</h2>
             <p>Les présentes CGU sont soumises au droit français. Pour toute question :</p>
             <div className={styles.infoBox} role="note" aria-label="Coordonnées de contact">
-              <p><strong>XEFI SA</strong></p>
-              <p>2507 Avenue de l'Europe — 69140 Rillieux-la-Pape</p>
-              <p>Email : dpo@xefi.fr</p>
+              <p><strong>COYAUD Anthony</strong> — Éditeur</p>
+              <p>Projet annuel Bachelor DBI — Nexa Digital School, 2026</p>
+              <p>Email : a.coyaud@xefi.fr</p>
             </div>
           </section>
         </main>
 
         <footer className={styles.footer} role="contentinfo">
-          <p>Data Sentinel v1.0 — © XEFI SA 2026</p>
+          <p>Data Sentinel v1.1.0 — COYAUD Anthony, Nexa Digital School 2026</p>
           <nav aria-label="Liens légaux">
             <a href="/mentions-legales">Mentions légales</a>
           </nav>

DataSentinel/src/pages/Documentation/Documentation.jsx

@@ -18,29 +18,29 @@ const sections = [
     icon: Code,
     title: 'Architecture technique',
     items: [
-      { label: 'Frontend — React 18 + Vite', desc: 'SPA React 18 avec CSS Modules, React Router v7, Recharts. Build Vite.' },
-      { label: 'Backend — API REST', desc: 'API REST avec authentification JWT. Endpoints documentés via Swagger.' },
-      { label: 'Base de données — SQL Server', desc: 'SQL Server avec vues SQL optimisées et jobs CRON pour les agrégations.' },
-      { label: 'Infrastructure — NEXERN (XEFI)', desc: 'Hébergement souverain français sur les datacenters NEXERN de XEFI.' },
+      { label: 'Frontend — React 19 + Vite', desc: 'SPA React 19 avec CSS Modules, React Router v7, Recharts. Build Vite.' },
+      { label: 'Backend — API REST', desc: 'API REST FastAPI avec authentification JWT. Endpoints documentés via Swagger.' },
+      { label: 'Base de données — SQL Server', desc: 'SQL Server 2022 avec vues SQL d\'agrégation et jobs SQL Server Agent pour l\'historisation quotidienne.' },
+      { label: 'Infrastructure — Docker', desc: 'Conteneurs Docker derrière un reverse proxy HTTPS. Cible métier : datacenters souverains NEXERN de XEFI.' },
     ],
   },
   {
     icon: Database,
     title: 'Monitorings disponibles',
     items: [
-      { label: 'CRM — Données clients et prospects', desc: 'Surveillance de la cohérence et de la complétude des données CRM.' },
-      { label: 'Sage — Données comptables et financières', desc: 'Contrôle qualité des flux comptables issus de Sage.' },
-      { label: 'Infocentre — Reporting décisionnel', desc: 'Validation des données alimentant les rapports de direction.' },
+      { label: 'Contrat — 5 monitorings', desc: 'Tiers-payeurs, prélèvements sans RIB, TVA DOM-TOM, zone de ventes nulle, modes de règlement multiples.' },
+      { label: 'Fournisseur — 2 monitorings', desc: 'Écritures sans SIRET et écritures sans compte de contrepartie.' },
+      { label: 'Sources — Sage et CRM en V1', desc: 'Le périmètre V1 couvre Sage (6 monitorings) et le CRM (1). L\'Infocentre fait partie du périmètre cible.' },
     ],
   },
   {
     icon: Shield,
     title: 'Sécurité et conformité',
     items: [
-      { label: 'Authentification JWT', desc: 'Token JWT stocké en sessionStorage, expiration automatique.' },
-      { label: 'Contrôle d\'accès RBAC', desc: 'Rôles : Administrateur, Superviseur, Consultant. Accès aux fonctions selon le rôle.' },
-      { label: 'Conformité RGPD', desc: 'Conservation 24 mois, DPO joignable sur dpo@xefi.fr, droits exercés à la demande.' },
-      { label: 'Accessibilité RGAA / WCAG 2.1 AA', desc: 'Navigation clavier, ARIA, contrastes conformes, responsive 320px–1920px.' },
+      { label: 'Authentification JWT', desc: 'Token JWT (HS256) stocké en localStorage, expiration 60 min sans refresh token.' },
+      { label: 'Contrôle d\'accès RBAC', desc: 'Rôles : Admin, Superviseur, Consultant. Accès aux fonctions selon le rôle.' },
+      { label: 'Conformité RGPD', desc: 'Historique conservé 24 mois, export et suppression de son compte en libre-service, droits exercés à la demande.' },
+      { label: 'Accessibilité — objectif WCAG 2.1 AA', desc: 'Navigation clavier, ARIA, responsive 320px–1920px. Audit formel des contrastes à finaliser.' },
     ],
   },
 ];
@@ -73,7 +73,7 @@ export default function Documentation() {
       </div>
 
       <div className={styles.footer}>
-        <p>Data Sentinel v1.0 — Développé par COYAUD Anthony, Nexa Digital School 2026</p>
+        <p>Data Sentinel v1.1.0 — Développé par COYAUD Anthony, Nexa Digital School 2026</p>
         <p>
           <a href="/cgu" className={styles.link}>CGU</a>
           {' · '}

DataSentinel/src/pages/Historique/Historique.jsx

@@ -8,27 +8,9 @@ import DataTable from '../../components/common/DataTable';
 import LoadingSpinner from '../../components/common/LoadingSpinner';
 import ErrorMessage from '../../components/common/ErrorMessage';
 import Button from '../../components/common/Button';
+import { periodeParDefaut } from '../../utils/dates';
 import styles from './Historique.module.css';
 
-/* Formate une date au format attendu par <input type="date"> (YYYY-MM-DD).
-   On lit les composantes en heure locale plutôt que d'utiliser toISOString(),
-   qui bascule en UTC : un 1er janvier saisi depuis Paris (UTC+1) y devient le
-   31 décembre de l'année précédente. */
-function formatDateISO(date) {
-  const mois = String(date.getMonth() + 1).padStart(2, '0');
-  const jour = String(date.getDate()).padStart(2, '0');
-  return `${date.getFullYear()}-${mois}-${jour}`;
-}
-
-/* Période affichée par défaut : du 1er janvier de l'année courante à aujourd'hui. */
-function periodeParDefaut() {
-  const aujourdhui = new Date();
-  return {
-    debut: formatDateISO(new Date(aujourdhui.getFullYear(), 0, 1)),
-    fin: formatDateISO(aujourdhui),
-  };
-}
-
 /* Récupère le tableau d'historique et la série du graphique pour les filtres
    donnés. Sans monitoring sélectionné, on prend la courbe globale.
    Fonction pure : elle ne touche à aucun état, ce qui permet de l'appeler

DataSentinel/src/pages/MentionsLegales/MentionsLegales.jsx

@@ -24,47 +24,82 @@ export default function MentionsLegales() {
 
           <section className={styles.section}>
             <h2>Éditeur</h2>
-            <p><strong>XEFI SA</strong></p>
-            <p>2507 Avenue de l'Europe</p>
-            <p>69140 Rillieux-la-Pape</p>
-            <p>dpo@xefi.fr</p>
+            <p><strong>COYAUD Anthony</strong></p>
+            <p>Projet annuel — Bachelor Data &amp; Business Intelligence</p>
+            <p>Nexa Digital School, 2026</p>
+            <p>a.coyaud@xefi.fr</p>
+          </section>
+
+          <section className={styles.section}>
+            <h2>Commanditaire</h2>
+            <p><strong>XEFI SA</strong> — 2507 Avenue de l'Europe, 69140 Rillieux-la-Pape</p>
+            <p>
+              Le besoin métier et les règles de gestion sont ceux du service Business Intelligence
+              de XEFI. XEFI SA n'édite ni n'exploite la présente instance de démonstration.
+            </p>
           </section>
 
           <section className={styles.section}>
             <h2>Hébergeur</h2>
-            <p><strong>XEFI Infrastructure NEXERN</strong></p>
-            <p>Souveraineté française</p>
+            <p><strong>Environnement de démonstration auto-hébergé</strong></p>
+            <p>
+              Conteneurs Docker exposés en HTTPS via un reverse proxy, sur un serveur administré
+              par l'auteur du projet. Cible métier d'un déploiement réel : les datacenters
+              souverains NEXERN de XEFI.
+            </p>
           </section>
 
           <section className={styles.section}>
-            <h2>Accès & Utilisation</h2>
-            <p>Usage interne exclusif aux collaborateurs habilités.</p>
+            <h2>Accès &amp; Utilisation</h2>
+            <p>
+              Application destinée à un usage professionnel interne. La présente instance est une
+              démonstration accessible à des fins d'évaluation académique, au moyen de comptes de
+              test ; elle ne contient aucune donnée réelle d'entreprise.
+            </p>
           </section>
 
           <section className={styles.section}>
             <h2>Données personnelles RGPD (UE 2016/679)</h2>
-            <p>Conservation des données : 24 mois</p>
-            <p>Contact DPO : dpo@xefi.fr</p>
+            <p>Données traitées : compte utilisateur (identifiant, e-mail, rôle) et journal des connexions.</p>
+            <p>Conservation de l'historique de monitoring : 24 mois, par purge automatique en base.</p>
+            <p>
+              Droits exerçables directement dans l'application : export de ses données
+              (portabilité, art. 20) et suppression de son compte (effacement, art. 17, par
+              désactivation et anonymisation).
+            </p>
+            <p>Contact : a.coyaud@xefi.fr</p>
           </section>
 
           <section className={styles.section}>
             <h2>Cookies</h2>
-            <p>Session JWT uniquement, aucun tiers, bandeau de consentement.</p>
+            <p>
+              Aucun cookie n'est déposé et aucun traceur tiers n'est utilisé. La session et le
+              choix de consentement sont conservés dans le stockage local du navigateur
+              (<code>localStorage</code>), effaçable à tout moment depuis les réglages du navigateur
+              ou par déconnexion.
+            </p>
           </section>
 
           <section className={styles.section}>
             <h2>Propriété intellectuelle</h2>
-            <p>© XEFI SA 2026, développé par COYAUD Anthony</p>
+            <p>
+              Code source, design et documentation réalisés par <strong>COYAUD Anthony</strong>
+              {' '}dans le cadre de son alternance chez XEFI et de son projet annuel Nexa Digital
+              School (2026).
+            </p>
           </section>
 
           <section className={styles.section}>
             <h2>Responsabilité</h2>
-            <p>Données anonymisées pour rendu académique.</p>
+            <p>
+              Jeu de données entièrement fictif, produit pour la démonstration. Aucune donnée
+              réelle de client, de fournisseur ou de collaborateur n'est exposée.
+            </p>
           </section>
         </div>
 
         <footer className={styles.footer}>
-          <p>Data Sentinel v1.0 — © XEFI SA 2026</p>
+          <p>Data Sentinel v1.1.0 — COYAUD Anthony, Nexa Digital School 2026</p>
         </footer>
       </div>
     </div>

DataSentinel/src/utils/dates.js

@@ -0,0 +1,17 @@
+/* Formate une date au format attendu par <input type="date"> (YYYY-MM-DD).
+   On lit les composantes en heure locale plutôt que d'utiliser toISOString(),
+   qui bascule en UTC : un 1er janvier saisi depuis Paris (UTC+1) y devient le
+   31 décembre de l'année précédente. */
+export function formatDateISO(date) {
+  const mois = String(date.getMonth() + 1).padStart(2, '0');
+  const jour = String(date.getDate()).padStart(2, '0');
+  return `${date.getFullYear()}-${mois}-${jour}`;
+}
+
+/* Période affichée par défaut : du 1er janvier de l'année courante à aujourd'hui. */
+export function periodeParDefaut(aujourdhui = new Date()) {
+  return {
+    debut: formatDateISO(new Date(aujourdhui.getFullYear(), 0, 1)),
+    fin: formatDateISO(aujourdhui),
+  };
+}

DataSentinel/vite.config.js

@@ -6,6 +6,12 @@ export default defineConfig({
   plugins: [
     react(),
   ],
+  build: {
+    // Cible de compilation déclarée explicitement plutôt que laissée au défaut de
+    // Vite : la matrice de compatibilité annoncée dans le README est ainsi tracée
+    // dans le dépôt et ne bougera pas si Vite change sa baseline par défaut.
+    target: ['chrome111', 'edge111', 'firefox114', 'safari16.4', 'ios16.4'],
+  },
   test: {
     environment: 'jsdom',
     globals: true,