Merge branch 'dev' into feat/pipeline-ci

.env.example

@@ -17,57 +17,3 @@ APP_LOG_LEVEL=INFO
 APP_SECRET_KEY=change_me
 APP_CORS_ORIGINS=http://localhost:4200
 BACKEND_PORT=8000
-FRONTEND_PORT=3000
-
-# Mailpit capture les courriels du backend, rien ne sort vers l'extérieur.
-MAILPIT_SMTP_PORT=1025
-MAILPIT_UI_PORT=8025
-
-# API Mock EnerVision
-APP_MOCK_API_BASE_URL=https://api-mock.charlieandre.fr
-APP_MOCK_API_USERNAME=change_me
-APP_MOCK_API_PASSWORD=change_me
-APP_MOCK_API_TIMEOUT_SECONDS=10
-
-# Airflow (webserver + scheduler, LocalExecutor). Base de métadonnées dédiée `airflow` dans le
-# même conteneur `db` (cf. db/init/120-airflow-database.sql), pas un conteneur de plus.
-AIRFLOW_PORT=8080
-# Chiffre les connexions/variables stockées par Airflow. Générer la vôtre :
-# python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
-AIRFLOW_FERNET_KEY=change_me
-# Clé Flask du webserver Airflow (signature de session), distincte de la précédente. Générer la
-# vôtre : python -c "import secrets; print(secrets.token_urlsafe(48))"
-AIRFLOW_WEBSERVER_SECRET_KEY=change_me
-AIRFLOW_ADMIN_USERNAME=admin
-# Compte Airflow créé au premier démarrage (service `airflow-init`), sans rapport avec les
-# comptes `app_user` d'EnerVision.
-AIRFLOW_ADMIN_PASSWORD=change_me
-AIRFLOW_ADMIN_EMAIL=admin@enervision.fr
-# `APP_SECRET_KEY` du backend, que le DAG `alertes` lance en sous-processus. Distincte de
-# celle de l'API : la détection ne signe aucun jeton, et Airflow exécute du code depuis son
-# interface (cf. ADR 0008). Générer la vôtre :
-# python -c "import secrets; print(secrets.token_urlsafe(48))"
-AIRFLOW_APP_SECRET_KEY=change_me
-
-# Stack complète derrière le reverse proxy (docker-compose.prod.yml).
-# PUBLIC_HOST alimente l'origine CORS, le lien de réinitialisation et le certificat.
-PUBLIC_HOST=enervision.local
-ACME_EMAIL=
-
-# Deux environnements sur la même machine (ADR 0009) : un dossier, un `.env` et un projet Compose
-# chacun. Le nom de projet préfixe volumes, réseau et conteneurs et l'emporte sur `name:`.
-# Vide sur un poste de développement : le projet reste `enervision`.
-COMPOSE_PROJECT_NAME=
-# Origine publique, avec le port si le proxy HTTPS n'écoute pas 443. Vide : https://PUBLIC_HOST.
-# Recette : PUBLIC_HOST=rec.enervision.local et PUBLIC_ORIGIN=https://rec.enervision.local:8443.
-PUBLIC_ORIGIN=
-# Ports publiés par le proxy. Vides : 80 et 443. Recette : PROXY_HTTPS_PORT=8443 et
-# PROXY_HTTP_PORT=127.0.0.1:8081, la redirection vers 443 n'ayant pas à être joignable de
-# l'extérieur. Décaler aussi POSTGRES_PORT, MAILPIT_UI_PORT et AIRFLOW_PORT (5434, 8026, 8082).
-PROXY_HTTP_PORT=
-PROXY_HTTPS_PORT=
-# Réglages mémoire de la stack déployée. Sans eux, timescaledb-tune réserve 25 % de la RAM de la
-# machine à chaque base au premier démarrage, et le webserver Airflow lance 4 workers gunicorn.
-TS_TUNE_MEMORY=2GB
-TS_TUNE_NUM_CPUS=2
-AIRFLOW_WEBSERVER_WORKERS=2

.github/dependabot.yml

@@ -38,9 +38,3 @@ updates:
     directory: "/apps/frontend"
     schedule:
       interval: "weekly"
-
-  # Images du reverse proxy et du compagnon ACME, épinglées dans les fichiers Compose
-  - package-ecosystem: "docker-compose"
-    directory: "/"
-    schedule:
-      interval: "weekly"

.github/workflows/airflow.yml

@@ -1,102 +0,0 @@
-name: Airflow
-
-# Piège : la version de Python vient de etl/airflow/.python-version. C'est 3.12 et non 3.14
-# (contrairement à backend.yml et ml.yml) : apache-airflow 2.10 ne supporte pas 3.14. Le 3.14 de
-# ml/ ne vit que dans l'image Docker, dans son propre environnement (cf. etl/airflow/Dockerfile).
-#
-# Piège : l'image COPY les fichiers de dépendances et le code de ml/ et de apps/backend/. Une
-# modification de l'un ou de l'autre peut donc casser sa construction, d'où ces chemins dans
-# les déclencheurs, alors même que ce workflow ne teste ni le modèle ni l'API.
-
-on:
-  push:
-    paths:
-      - "etl/airflow/**"
-      - "ml/pyproject.toml"
-      - "ml/uv.lock"
-      - "ml/enervision_ml/**"
-      - "apps/backend/pyproject.toml"
-      - "apps/backend/uv.lock"
-      - "apps/backend/app/**"
-      - ".github/workflows/airflow.yml"
-  pull_request:
-    paths:
-      - "etl/airflow/**"
-      - "ml/pyproject.toml"
-      - "ml/uv.lock"
-      - "ml/enervision_ml/**"
-      - "apps/backend/pyproject.toml"
-      - "apps/backend/uv.lock"
-      - "apps/backend/app/**"
-      - ".github/workflows/airflow.yml"
-
-permissions:
-  contents: read
-
-concurrency:
-  group: airflow-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  verification:
-    name: Lint et intégrité des DAGs
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: etl/airflow
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v4
-
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: etl/airflow/uv.lock
-
-      - name: Installe l'interpréteur déclaré par .python-version
-        run: uv python install
-
-      - name: Synchronise les dépendances sans dévier du verrou
-        run: uv sync --all-groups --frozen
-
-      - name: Vérifie le formatage
-        run: uv run ruff format --check .
-
-      - name: Analyse statique
-        run: uv run ruff check --output-format=github .
-
-      # Aucun test ne lance de tâche ni de scheduler : DagBag charge les fichiers de dags/ et
-      # vérifie import, planification, plafonds d'exécution et commande de chaque tâche.
-      - name: Tests d'intégrité des DAGs
-        run: uv run pytest
-
-  image:
-    name: Construction de l'image
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v4
-
-      - name: Construit l'image (contexte à la racine, elle COPY ml/ et apps/backend/)
-        run: docker build -f etl/airflow/Dockerfile -t enervision-airflow:ci .
-
-      # Vérifie ce qui ne casse qu'à l'exécution, pas à la construction : libgomp1 absent
-      # (`OSError: libgomp.so.1` au premier import) ou environnement ml/ non figé.
-      - name: Vérifie que le pipeline ML s'importe sans réseau
-        run: >
-          docker run --rm --network none enervision-airflow:ci
-          bash -c "cd /opt/ml && env -u VIRTUAL_ENV uv run --no-sync python -m enervision_ml.train --help"
-
-      # `--help` sort par argparse avant `get_settings()` : ni base ni secret requis, et
-      # l'import des modules prouve que l'environnement /opt/backend est complet.
-      # Les deux commandes du DAG `alertes` et la commande du DAG historique sont couvertes.
-      - name: Vérifie que les trois commandes backend s'importent sans réseau
-        run: >
-          docker run --rm --network none enervision-airflow:ci
-          bash -c "cd /opt/backend
-          && env -u VIRTUAL_ENV uv run --no-sync python -m app.detection.internal_alerts --help
-          && env -u VIRTUAL_ENV uv run --no-sync python -m app.cli generate-recommendations --help
-          && env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.historical_import --help"

.github/workflows/backend.yml

@@ -56,113 +56,3 @@ jobs:
       # Le marqueur `integration` est exclu par défaut, donc aucune base n'est nécessaire ici.
       - name: Tests et couverture
         run: uv run pytest --cov-fail-under=85
-
-  # Piège : l'image est celle de docker-compose.yml, pas une image `postgres` nue. La première
-  # migration (`5353c0e4f094`) échoue volontairement si l'extension TimescaleDB manque, et un
-  # écart d'image entre la CI et le poste rendrait ce job vert sur une base qui n'est pas la nôtre.
-  integration:
-    name: Tests exigeant une base
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: apps/backend
-
-    services:
-      db:
-        image: timescale/timescaledb-ha:pg17
-        env:
-          POSTGRES_USER: enervision
-          POSTGRES_PASSWORD: change_me
-          POSTGRES_DB: enervision_test
-        ports:
-          - "5433:5432"
-        options: >-
-          --health-cmd "pg_isready -U enervision -d enervision_test"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 12
-          --health-start-period 40s
-
-    env:
-      DATABASE_URL: postgresql+asyncpg://enervision:change_me@localhost:5433/enervision_test
-      APP_SECRET_KEY: secret-de-test-assez-long-pour-le-validateur
-      PGPASSWORD: change_me
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v4
-
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: apps/backend/uv.lock
-
-      - name: Installe l'interpréteur déclaré par .python-version
-        run: uv python install
-
-      - name: Synchronise les dépendances sans dévier du verrou
-        run: uv sync --all-groups --frozen
-
-      # Sur le poste, c'est db/init/110-test-database.sql qui pose l'extension. Ce fichier n'est
-      # pas monté ici, et sans lui `alembic upgrade head` s'arrête sur la garde de la révision 1.
-      - name: Active TimescaleDB sur la base de test
-        run: psql -h localhost -p 5433 -U enervision -d enervision_test -c "CREATE EXTENSION IF NOT EXISTS timescaledb"
-
-      - name: Applique les migrations
-        run: uv run alembic upgrade head
-
-      # `-m` en ligne de commande écrase celui d'`addopts`. La couverture est désactivée : ce job
-      # ne joue qu'une partie de la suite, son taux n'aurait aucun sens face au seuil de 85 %.
-      - name: Tests d'intégration
-        run: uv run pytest -m integration --no-cov
-
-  security-audit:
-    name: Audit des dépendances
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: apps/backend
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v4
-
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: apps/backend/uv.lock
-
-      # L'audit porte sur le verrou, pas sur l'environnement : sinon pip-audit auditerait
-      # aussi les paquets que son propre `--with` injecte, hors dépendances du projet.
-      - name: Audite les dépendances livrées
-        # Piège : sans `shell: bash`, un échec de `uv export` serait masqué par le pipe.
-        shell: bash
-        run: uv export --frozen --no-dev --no-emit-project --no-hashes | uvx pip-audit --requirement /dev/stdin --no-deps
-
-  sast:
-    name: Analyse statique de sécurité
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: apps/backend
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v4
-
-      # Pourquoi : pas de cache ici. uvx n'installe pas le projet, le verrou n'alimente donc
-      # aucune clé de cache ; la seule roue téléchargée est celle de Bandit.
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-
-      # Pourquoi : le périmètre est `app`, le code livré. Les tests emploient légitimement des
-      # secrets factices et des `assert` que Bandit signalerait sans qu'aucun n'atteigne la prod.
-      - name: Analyse le code livré (bloquant à partir de MEDIUM)
-        run: uvx bandit==1.9.4 --recursive app --severity-level medium --confidence-level medium
-
-      # Piège : sans cette seconde passe, un constat LOW disparaîtrait du journal sans trace.
-      - name: Rapport complet, tous niveaux
-        continue-on-error: true
-        run: uvx bandit==1.9.4 --recursive app

.github/workflows/deploy.yml

@@ -1,57 +0,0 @@
-# Pourquoi : le runner tourne sur la VM ENI, adresse privée que les runners hébergés par GitHub
-# ne joignent pas, et travaille dans un dossier stable par environnement plutôt que dans son
-# espace de travail : `.env`, certificats et volumes y survivent d'un déploiement à l'autre.
-# Piège : jamais de déclencheur `pull_request` ici. Sur un dépôt public, une PR de fork
-# exécuterait son code sur la machine de production (ADR 0009) - job deploy.
-
-name: Déploiement
-
-on:
-  push:
-    branches: [dev, main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: deploy-${{ github.ref_name }}
-  cancel-in-progress: false
-
-jobs:
-  deploy:
-    runs-on: [self-hosted, linux, eni-g3]
-    timeout-minutes: 30
-    environment:
-      name: ${{ github.ref_name == 'main' && 'prod' || 'rec' }}
-      url: ${{ github.ref_name == 'main' && 'https://enervision.local' || 'https://rec.enervision.local:8443' }}
-    env:
-      ENVIRONNEMENT: ${{ github.ref_name == 'main' && 'prod' || 'rec' }}
-      PORT_HTTPS: ${{ github.ref_name == 'main' && '443' || '8443' }}
-    steps:
-      - name: Aligner le dossier de l'environnement sur la branche poussée
-        run: |
-          cd "/srv/enervision/${ENVIRONNEMENT}"
-          git fetch --quiet origin "${GITHUB_REF_NAME}"
-          git checkout --quiet "${GITHUB_REF_NAME}"
-          git reset --quiet --hard "origin/${GITHUB_REF_NAME}"
-          git log -1 --format='%h %s'
-
-      - name: Reconstruire et redémarrer la stack
-        run: |
-          cd "/srv/enervision/${ENVIRONNEMENT}"
-          make stack-up
-
-      - name: Attendre que l'API réponde derrière le proxy
-        run: |
-          for tentative in $(seq 1 36); do
-            if curl --fail --silent --insecure "https://localhost:${PORT_HTTPS}/api/v1/health/ready"; then
-              exit 0
-            fi
-            sleep 5
-          done
-          echo "L'API ne répond pas après 3 minutes" >&2
-          cd "/srv/enervision/${ENVIRONNEMENT}"
-          docker compose ps
-          docker compose logs --tail=50 backend proxy
-          exit 1

.github/workflows/frontend.yml

@@ -1,4 +1,5 @@
 name: Frontend
+# Pipeline à choix multiple
 
 on:
   push:
@@ -9,9 +10,9 @@ on:
     paths:
       - "apps/frontend/**"
       - ".github/workflows/frontend.yml"
-
-permissions:
-  contents: read
+      
+# Ordre de lancement des jobs
+# build -> test -> sonarqube -> deploy
 
 jobs:
   build:
@@ -23,25 +24,13 @@ jobs:
           node-version: 24
           cache: npm
           cache-dependency-path: apps/frontend/package-lock.json
-
-      - run: npm ci
+      
+      - run: npm ci 
         working-directory: apps/frontend
       - run: npm run build
         working-directory: apps/frontend
 
-  security-audit:
-    name: Audit des dépendances
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24
-      # Seuil high : une vulnérabilité moderate de devDependency ne doit pas bloquer une livraison.
-      - run: npm audit --audit-level=high --package-lock-only
-        working-directory: apps/frontend
-
-  test:
+  test:  
     needs: build
     runs-on: ubuntu-latest
     steps:
@@ -51,14 +40,30 @@ jobs:
           node-version: 24
           cache: npm
           cache-dependency-path: apps/frontend/package-lock.json
-      - name : Installation des dépendances (Front)
-        run: npm ci 
+      - run: npm ci 
         working-directory: apps/frontend
-      - name : Lancement des tests et génénration du rapport de couverture (Front)
-        run: npm test --watch=false --code-coverage --coverageReporters=lcov
+      - run: npm test --watch=false --code-coverage --coverageReporters=lcov
         working-directory: apps/frontend
       - name: Upload coverage
         uses: actions/upload-artifact@v4
         with:
           name: frontend-coverage
           path: apps/frontend/coverage/frontend/lcov.info
+        
+  sonarqube:
+    needs: [build, test]
+    name: SonarQube
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Download coverage
+        uses: actions/download-artifact@v4
+        with:
+          name: frontend-coverage
+          path: apps/frontend/coverage/frontend
+      - name: SonarQube Scan
+        uses: SonarSource/sonarqube-scan-action@v8
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.github/workflows/ml.yml

@@ -57,26 +57,3 @@ jobs:
       # synthetiques ou un magasin SQLite local jetable (cf. ml/tests/test_train.py).
       - name: Tests
         run: uv run pytest
-
-  sast:
-    name: Analyse statique de sécurité
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ml
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v4
-
-      # Pourquoi : pas de cache ici. uvx n'installe pas le projet, le verrou n'alimente donc
-      # aucune clé de cache ; la seule roue téléchargée est celle de Bandit.
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-
-      - name: Analyse le code livré (bloquant à partir de MEDIUM)
-        run: uvx bandit==1.9.4 --recursive enervision_ml --severity-level medium --confidence-level medium
-
-      - name: Rapport complet, tous niveaux
-        continue-on-error: true
-        run: uvx bandit==1.9.4 --recursive enervision_ml

.github/workflows/sonarqube.yml

@@ -1,169 +0,0 @@
-name: SonarQube
-
-on:
-  push:
-    paths:
-      - "apps/frontend/**"
-      - "apps/backend/**"
-      - "ml/**"
-      - "etl/airflow/**"
-      - ".github/workflows/sonarqube.yml"
-  pull_request:
-    paths:
-      - "apps/frontend/**"
-      - "apps/backend/**"
-      - "ml/**"
-      - "etl/airflow/**"
-      - ".github/workflows/sonarqube.yml"
-
-
-# Build l'ensemble du projet, puis lance les tests
-# Génère les rapports de couverture, puis lance l'analyse SonarQube
-
-jobs:
-  build-front:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: npm
-          cache-dependency-path: apps/frontend/package-lock.json
-      
-      - run: npm ci 
-        working-directory: apps/frontend
-      - run: npm run build
-        working-directory: apps/frontend
-
-  test-front:  
-    needs: build-front
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: npm
-          cache-dependency-path: apps/frontend/package-lock.json
-
-      - name : Installation des dépendances (Front)
-        run: npm ci 
-        working-directory: apps/frontend
-
-      - name : Lancement des tests et génénration du rapport de couverture (Front)
-        run: npm test --watch=false --code-coverage --coverageReporters=lcov
-        working-directory: apps/frontend
-
-      - name: Upload coverage
-        uses: actions/upload-artifact@v4
-        with:
-          name: frontend-coverage
-          path: apps/frontend/coverage/frontend/lcov.info
-
-  build-back:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: apps/backend/uv.lock
-      - name: Installe l'interpréteur déclaré par .python-version
-        run: uv python install
-        working-directory: apps/backend
-
-      - name: Synchronise les dépendances sans dévier du verrou
-        run: uv sync --all-groups --frozen
-        working-directory: apps/backend
-
-      - name: Vérifie le formatage
-        run: uv run ruff format --check .
-        working-directory: apps/backend
-
-      - name: Analyse statique
-        run: uv run ruff check --output-format=github .
-        working-directory: apps/backend
-
-      - name: Typage
-        run: uv run mypy app
-        working-directory: apps/backend
-
-
-  test-back:
-    needs: build-back
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: apps/backend/uv.lock
-
-      - name : Lancement des tests et génénration du rapport de couverture (Back)
-        run: uv run pytest --cov-fail-under=85 --cov-report=xml
-        working-directory: apps/backend
-
-      - name: Upload coverage
-        uses: actions/upload-artifact@v4
-        with:
-          name: backend-coverage
-          path: apps/backend/coverage.xml
-
-  test-ml:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: ml/uv.lock
-
-      - name: Installe l'interpréteur déclaré par .python-version
-        run: uv python install
-        working-directory: ml
-
-      - name: Synchronise les dépendances sans dévier du verrou
-        run: uv sync --all-groups --frozen
-        working-directory: ml
-
-      - name: Lancement des tests et génération du rapport de couverture (ML)
-        run: uv run pytest --cov-report=xml
-        working-directory: ml
-
-      - name: Upload coverage
-        uses: actions/upload-artifact@v4
-        with:
-          name: ml-coverage
-          path: ml/coverage.xml
-
-  sonarqube:
-    needs: [build-front, build-back, test-front, test-back, test-ml]
-    name: SonarQube
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-      - name: Téléchargement du rapport de couverture (Front)
-        uses: actions/download-artifact@v4
-        with:
-          name: frontend-coverage
-          path: apps/frontend/coverage/frontend
-      - name: Téléchargement du rapport de couverture (Back)
-        uses: actions/download-artifact@v4
-        with:
-          name: backend-coverage
-          path: apps/backend
-      - name: Téléchargement du rapport de couverture (ML)
-        uses: actions/download-artifact@v4
-        with:
-          name: ml-coverage
-          path: ml
-      - name: SonarQube Scan
-        uses: SonarSource/sonarqube-scan-action@v8
-        env:
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.gitignore

@@ -66,12 +66,6 @@ ml/mlruns/
 ml/mlartifacts/
 ml/mlflow.db
 
-# Airflow : base sqlite locale generee par les tests d'integrite des DAGs (etl/airflow/tests)
-etl/airflow/tests/.airflow_home/
-
-# TLS : certificats du reverse proxy, générés par script ou par certbot
-infra/proxy/tls/*.pem
-
 # IDE et OS
 .idea/
 .vscode/

Makefile

@@ -1,48 +1,17 @@
 BACKEND := apps/backend
 FRONTEND := apps/frontend
 ML := ml
-AIRFLOW := etl/airflow
-COMPOSE_PROD := docker compose -f docker-compose.yml -f docker-compose.prod.yml
-
-# Piège : sans `export`, une valeur passée en ligne de commande n'atteindrait pas docker compose.
-# PUBLIC_HOST retombe sur le `.env`, que make ne lit pas, puis sur la valeur de `.env.example`.
-PUBLIC_HOST ?= $(shell sed -n 's/^PUBLIC_HOST=//p' .env 2>/dev/null | tail -1)
-PUBLIC_HOST := $(or $(strip $(PUBLIC_HOST)),enervision.local)
-export PUBLIC_HOST
-ifdef ACME_EMAIL
-export ACME_EMAIL
-endif
-
-# Piege : make ne lit pas `.env`, que seul docker compose interpole. Les cibles hors conteneur
-# (ml-*, demo-data, db-wait) joignent la base par le port publie et ont besoin de ces valeurs.
-env-val = $(shell sed -n 's/^$(1)=//p' .env 2>/dev/null | tail -1)
-PG_USER := $(or $(strip $(call env-val,POSTGRES_USER)),enervision)
-PG_PASSWORD := $(or $(strip $(call env-val,POSTGRES_PASSWORD)),change_me)
-PG_DB := $(or $(strip $(call env-val,POSTGRES_DB)),enervision)
-PG_PORT := $(or $(strip $(call env-val,POSTGRES_PORT)),5433)
-AIRFLOW_PORT := $(or $(strip $(call env-val,AIRFLOW_PORT)),8080)
-MAILPIT_UI_PORT := $(or $(strip $(call env-val,MAILPIT_UI_PORT)),8025)
-ML_DATABASE_URL ?= postgresql+psycopg://$(PG_USER):$(PG_PASSWORD)@localhost:$(PG_PORT)/$(PG_DB)
-export ML_DATABASE_URL
-
-# Le jeu historique s'arrete au 31/12/2024 : score et detection ancres a l'horloge reelle ne
-# verraient qu'un parc muet depuis des mois. Cf. `--now` de enervision_ml.score.
-DEMO_NOW ?= 2024-12-31T00:00:00Z
 
 .DEFAULT_GOAL := help
-.PHONY: help install install-backend install-frontend install-ml install-airflow \
-        dev dev-backend dev-frontend \
+.PHONY: help install install-backend install-frontend install-ml dev dev-backend dev-frontend \
         lint format typecheck test test-cov test-integration check \
-        openapi docker-build db-up db-down db-reset db-logs db-psql db-wait db-ensure-airflow \
-        migrate bootstrap-admin services-up demo-data demo-data-force \
-        ml-lint ml-typecheck ml-test ml-check ml-train ml-score detect-alerts recommendations \
-        airflow-lint airflow-test airflow-check airflow-up airflow-down airflow-logs \
-        tls-selfsigned tls-acme tls-renew stack-up stack-down stack-logs
+        openapi docker-build db-up db-down db-reset db-logs db-psql migrate bootstrap-admin \
+        ml-lint ml-typecheck ml-test ml-check ml-train
 
 help: ## Liste les cibles disponibles
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2}'
 
-install: install-backend install-frontend install-ml install-airflow ## Installe les dépendances backend, frontend, ML et Airflow
+install: install-backend install-frontend install-ml ## Installe les dépendances backend, frontend et ML
 
 install-backend: ## Installe les dépendances du backend
 	cd $(BACKEND) && uv sync --all-groups
@@ -53,22 +22,12 @@ install-frontend: ## Installe les dépendances du frontend
 install-ml: ## Installe les dépendances du pipeline ML
 	cd $(ML) && uv sync --all-groups
 
-install-airflow: ## Installe les dépendances de lint/test des DAGs Airflow
-	cd $(AIRFLOW) && uv sync --all-groups
-
-dev: services-up migrate demo-data ## Lance toute la stack : base, Mailpit, Airflow, puis backend et frontend
-	@echo "airflow  -> http://localhost:$(AIRFLOW_PORT)  mailpit -> http://localhost:$(MAILPIT_UI_PORT)"
+dev: ## Lance toute la stack (backend + frontend) en rechargement à chaud
 	@trap 'kill 0' EXIT INT TERM; \
 	$(MAKE) --no-print-directory dev-backend & \
 	$(MAKE) --no-print-directory dev-frontend & \
 	wait
 
-services-up: ## Démarre les services conteneurisés dont `make dev` dépend (base, Mailpit, Airflow)
-	docker compose up -d db mailpit
-	@$(MAKE) --no-print-directory db-wait
-	@$(MAKE) --no-print-directory db-ensure-airflow
-	docker compose up -d airflow-init airflow-webserver airflow-scheduler
-
 dev-backend: ## Lance l'API seule en rechargement à chaud
 	@echo "backend  -> http://localhost:8000 (docs sur /docs)"
 	cd $(BACKEND) && uv run uvicorn app.main:create_app --factory --reload --host 0.0.0.0 --port 8000
@@ -115,68 +74,9 @@ ml-check: ml-lint ml-typecheck ml-test ## Chaîne de vérification complète du
 ml-train: ## Entraine le modele LightGBM. CSV=chemin optionnel, sinon lit ML_DATABASE_URL
 	cd $(ML) && uv run python -m enervision_ml.train $(if $(CSV),--csv $(CSV),)
 
-ml-score: ## Score le prochain pas horaire et l'ecrit dans `prediction`. CSV= et NOW= optionnels
-	cd $(ML) && uv run python -m enervision_ml.score $(if $(CSV),--csv $(CSV),) $(if $(NOW),--now $(NOW),)
-
-detect-alerts: ## Détecte les alertes internes depuis les lectures en base. SITE= et NOW= optionnels
-	cd $(BACKEND) && uv run python -m app.detection.internal_alerts $(if $(SITE),--site-id $(SITE),) $(if $(NOW),--now $(NOW),)
-
-recommendations: ## Genere les recommandations depuis les alertes en base. SITE=identifiant optionnel
-	cd $(BACKEND) && uv run python -m app.cli generate-recommendations $(if $(SITE),--site-id $(SITE),)
-
-airflow-lint: ## Analyse statique des DAGs Airflow
-	cd $(AIRFLOW) && uv run ruff check .
-
-airflow-test: ## Verifie que les DAGs s'importent sans erreur et ont la structure attendue
-	cd $(AIRFLOW) && uv run pytest
-
-airflow-check: airflow-lint airflow-test ## Chaîne de vérification complète des DAGs Airflow
-
-airflow-up: db-ensure-airflow ## Démarre Airflow (webserver + scheduler, LocalExecutor). db-up requis avant.
-	docker compose up -d airflow-init airflow-webserver airflow-scheduler
-	@echo "airflow  -> http://localhost:$${AIRFLOW_PORT:-8080}"
-
-airflow-down: ## Arrête le webserver et le scheduler Airflow
-	docker compose stop airflow-webserver airflow-scheduler
-
-airflow-logs: ## Suit les journaux du scheduler Airflow (où tournent les tâches, LocalExecutor)
-	docker compose logs -f airflow-scheduler
-
 docker-build: ## Construit l'image du backend
 	docker build -t enervision-backend:local $(BACKEND)
 
-tls-selfsigned: ## Génère le certificat de démonstration. PUBLIC_HOST=..., FORCE=1 pour écraser
-	./scripts/tls-selfsigned.sh $(if $(FORCE),--force,)
-
-# Piège : l'image backend ne migre pas au démarrage, et `/health/ready` ne teste que la connexion
-# et l'extension. Sans `alembic upgrade head`, la stack démarre verte sur une base sans schéma.
-stack-up: ## Démarre la stack derrière le reverse proxy, puis migre la base. PUBLIC_HOST=... au besoin
-	@test -f infra/proxy/tls/fullchain.pem \
-		|| { echo "Aucun certificat dans infra/proxy/tls. Lancer d'abord make tls-selfsigned"; exit 1; }
-	@openssl x509 -in infra/proxy/tls/fullchain.pem -noout -checkhost "$(PUBLIC_HOST)" >/dev/null \
-		|| { echo "Le certificat ne couvre pas $(PUBLIC_HOST). Relancer make tls-selfsigned PUBLIC_HOST=$(PUBLIC_HOST) FORCE=1"; exit 1; }
-	$(COMPOSE_PROD) up -d --build
-	$(COMPOSE_PROD) exec -T backend alembic upgrade head
-
-stack-down: ## Arrête la stack complète en conservant les données
-	$(COMPOSE_PROD) stop
-
-stack-logs: ## Suit les journaux du reverse proxy
-	$(COMPOSE_PROD) logs -f proxy
-
-tls-acme: ## Demande un certificat Let's Encrypt. PUBLIC_HOST public et ACME_EMAIL requis
-	@test "$(PUBLIC_HOST)" != enervision.local \
-		|| { echo "PUBLIC_HOST doit être un domaine public résolvable, pas le nom de démonstration"; exit 1; }
-	$(COMPOSE_PROD) --profile acme run --rm certbot certonly --webroot -w /var/www/certbot \
-		-d $(PUBLIC_HOST) \
-		--email $${ACME_EMAIL:?ACME_EMAIL=... requis} \
-		--agree-tos --no-eff-email --deploy-hook /deploy-hook.sh
-	$(COMPOSE_PROD) exec proxy nginx -s reload
-
-tls-renew: ## Renouvelle les certificats Let's Encrypt et recharge le proxy
-	$(COMPOSE_PROD) --profile acme run --rm certbot renew --deploy-hook /deploy-hook.sh
-	$(COMPOSE_PROD) exec proxy nginx -s reload
-
 db-up: ## Démarre la base PostgreSQL TimescaleDB
 	docker compose up -d db
 
@@ -192,36 +92,8 @@ db-logs: ## Suit les journaux de la base
 db-psql: ## Ouvre une session psql sur la base applicative
 	docker compose exec db psql -U $${POSTGRES_USER:-enervision} -d $${POSTGRES_DB:-enervision}
 
-db-wait: ## Attend que la base accepte les connexions
-	@for _ in $$(seq 1 60); do \
-		docker compose exec -T db pg_isready -U $(PG_USER) -d $(PG_DB) >/dev/null 2>&1 && exit 0; \
-		sleep 1; \
-	done; \
-	echo "La base n'accepte toujours pas de connexion apres 60s"; exit 1
-
-# Piege : db/init ne rejoue qu'a la premiere initialisation du volume. Un `pgdata` cree avant
-# db/init/120-airflow-database.sql n'a pas de base `airflow`, et airflow-init boucle dessus.
-db-ensure-airflow: ## Crée la base de métadonnées Airflow si le volume pgdata est antérieur à db/init/120
-	@docker compose exec -T db psql -U $(PG_USER) -d postgres -tAc \
-		"SELECT 1 FROM pg_database WHERE datname = 'airflow'" | grep -q 1 \
-		|| docker compose exec -T db psql -U $(PG_USER) -d postgres -c "CREATE DATABASE airflow"
-
 migrate: ## Applique les migrations Alembic
 	cd $(BACKEND) && uv run alembic upgrade head
 
 bootstrap-admin: ## Crée le premier administrateur, mot de passe saisi au clavier
 	cd $(BACKEND) && uv run python -m app.cli create-admin --email $${EMAIL:?EMAIL=... requis}
-
-demo-data: ## Renseigne prédictions, alertes et recommandations si elles manquent. NOW= optionnel
-	@nombre=$$(docker compose exec -T db psql -U $(PG_USER) -d $(PG_DB) -tAc 'SELECT count(*) FROM alert') \
-		|| { echo "demo-data : base injoignable ou migrations non appliquees"; exit 1; }; \
-	if [ "$$nombre" = 0 ]; then \
-		$(MAKE) --no-print-directory demo-data-force; \
-	else \
-		echo "demo-data : $$nombre alerte(s) deja en base (make demo-data-force pour rejouer)"; \
-	fi
-
-demo-data-force: ## Rejoue le peuplement sans regarder l'existant. Les trois etapes sont idempotentes
-	$(MAKE) --no-print-directory ml-score NOW=$(DEMO_NOW)
-	$(MAKE) --no-print-directory detect-alerts NOW=$(DEMO_NOW)
-	$(MAKE) --no-print-directory recommendations

README.md

@@ -21,9 +21,8 @@ Ce que la documentation apporte à chacun : [docs/architecture/00-vue-ensemble.m
 | Backend    | FastAPI, Python 3.14                | `apps/backend`      | Initialise    |
 | Frontend   | Angular 22, Node 24 LTS             | `apps/frontend`     | Tableau de bord |
 | Base       | PostgreSQL 17 + TimescaleDB         | `db`                | Initialise    |
-| ETL        | Apache Airflow                      | `etl/airflow`       | Quatre DAGs   |
+| ETL        | Apache Airflow                      | `etl/airflow`       | A initialiser |
 | Infra      | Terraform (k3s single-node)         | `infra/terraform`   | Initialise    |
-| Reverse proxy | Nginx, TLS                       | `infra/proxy`       | En place      |
 | CI/CD      | GitHub Actions                      | `.github/workflows` | Backend en place |
 | Monitoring | Prometheus, Grafana, Alertmanager   | `monitoring`        | A initialiser |
 | ML         | LightGBM, MLflow                    | `ml`                | Entrainement initialise |
@@ -48,15 +47,13 @@ L'etat detaille de chaque brique et les vues d'architecture sont dans
 │   ├── migrations/     Migrations SQL versionnees
 │   └── seeds/          Jeux de donnees de reference
 ├── etl/airflow/
-│   ├── dags/           DAGs d'orchestration (pipeline ML, alertes, import historique)
+│   ├── dags/           DAGs d'ingestion et d'agregation
 │   ├── plugins/        Operateurs et hooks maison
 │   ├── include/        Requetes SQL et ressources des DAGs
 │   └── tests/          Tests d'integrite des DAGs
-├── infra/
-│   ├── proxy/          Reverse proxy Nginx : terminaison TLS et routage
-│   └── terraform/
-│       ├── modules/        Modules reutilisables
-│       └── environments/   Racines Terraform, une par environnement
+├── infra/terraform/
+│   ├── modules/        Modules reutilisables
+│   └── environments/   Racines Terraform, une par environnement
 ├── ml/                 Pipeline d'entrainement LightGBM, suivi MLflow
 ├── monitoring/
 │   ├── prometheus/     Collecte et regles d'alerte
@@ -75,52 +72,25 @@ Prerequis : uv, Docker, Node 24 LTS (npm fourni). Le poste doit disposer de Pyth
 cp .env.example .env                               # variables de docker-compose
 cp apps/backend/.env.example apps/backend/.env     # variables du backend hors conteneur
 
-make install   # dependances du backend, du frontend, du ML et des DAGs
-make dev       # toute la stack, voir ci-dessous
+make db-up     # PostgreSQL + TimescaleDB, publie sur le port 5433
+make install   # dependances du backend et du frontend
+make migrate   # applique les migrations Alembic
+make dev       # backend sur http://localhost:8000 (docs sur /docs), frontend sur http://localhost:4200
 make check     # lint + typage + tests
 ```
 
-`make dev` enchaine tout : demarrage des services conteneurises (base sur le port 5433, Mailpit,
-Airflow), migrations Alembic, peuplement de demonstration si les alertes manquent, puis backend
-et frontend en rechargement a chaud sur le poste.
-
-| Service | Adresse |
-|---|---|
-| Backend | <http://localhost:8000> (documentation sur `/docs`) |
-| Frontend | <http://localhost:4200> |
-| Airflow | <http://localhost:8080> (`AIRFLOW_ADMIN_USERNAME` / `AIRFLOW_ADMIN_PASSWORD` du `.env`) |
-| Mailpit | <http://localhost:8025> |
-
-Le `.env` doit porter les cles Airflow avant le premier `make dev` : `AIRFLOW_FERNET_KEY`,
-`AIRFLOW_WEBSERVER_SECRET_KEY`, `AIRFLOW_APP_SECRET_KEY` et `AIRFLOW_ADMIN_PASSWORD`. Sans elles
-`airflow-init` refuse de demarrer, et `airflow-webserver` comme `airflow-scheduler` avec lui.
-
-Les cibles d'origine restent disponibles pour ne demarrer qu'une partie : `make db-up`,
-`make airflow-up`, `make dev-backend`, `make dev-frontend`.
-
 `make help` liste les cibles disponibles.
 
 Deux fichiers d'environnement, deux usages : `.env` a la racine alimente `docker-compose.yml`,
 `apps/backend/.env` alimente le backend lance sur le poste. Le port 5433 est publie plutot que
 5432, souvent deja pris par une autre base.
 
-Le backend et le frontend tournent sur le poste, lances ensemble par `make dev` (logs
-entrelaces dans le meme terminal, Ctrl+C arrete les deux) ; la base, Mailpit et Airflow tournent
-en conteneur. Le service `backend` du `docker-compose.yml` sert la stack complete et la recette,
-et n'embarque pas le source, donc toute modification y demande un
-`docker compose up -d --build backend`.
-
-### Donnees de demonstration
-
-Le jeu historique s'arrete au 31/12/2024. `make demo-data` renseigne les tables que les vues
-alertes, recommandations et previsions lisent, en ancrant le scoring et la detection a cette
-date (`DEMO_NOW`) plutot qu'a l'horloge reelle, qui ne verrait qu'un parc muet depuis des mois.
-La cible ne fait rien si des alertes existent deja ; `make demo-data-force` rejoue les trois
-etapes, toutes idempotentes en base.
-
-Un volume `pgdata` cree avant `db/init/120-airflow-database.sql` n'a pas de base `airflow` :
-`db/init` ne rejoue qu'a la premiere initialisation. `make db-ensure-airflow`, appelee par
-`make dev` et `make airflow-up`, la cree au besoin, sans detruire les donnees applicatives.
+La boucle de developpement est `make db-up` puis `make dev` : seule la base tourne en
+conteneur, le backend et le frontend tournent tous les deux sur le poste, lances ensemble par
+`make dev` (logs entrelaces dans le meme terminal, Ctrl+C arrete les deux). `make dev-backend`
+et `make dev-frontend` restent disponibles pour lancer un seul des deux. Le service `backend`
+du `docker-compose.yml` sert la stack complete et la recette, et n'embarque pas le source, donc
+toute modification y demande un `docker compose up -d --build backend`.
 
 Verifier que la base repond et que l'extension est chargee :
 
@@ -128,27 +98,6 @@ Verifier que la base repond et que l'extension est chargee :
 curl -s localhost:8000/api/v1/health/ready
 ```
 
-## Stack complète derrière le reverse proxy
-
-Pour servir l'application comme sur la machine cible, en HTTPS et sous une seule origine.
-L'overlay emploie `!override` et `!reset`, donc **Docker Compose 2.24.4 ou plus récent** :
-
-```bash
-make tls-selfsigned PUBLIC_HOST=enervision.local   # certificat de démonstration
-make stack-up PUBLIC_HOST=enervision.local         # nginx en 80/443, rien d'autre n'est publié
-```
-
-Le navigateur avertit d'un émetteur inconnu : Let's Encrypt reste hors d'atteinte tant qu'aucun
-nom de domaine public ne résout vers la machine. Routage, mode ACME et renouvellement dans
-[`infra/proxy/README.md`](infra/proxy/README.md) ; la décision et ses motifs dans
-[l'ADR 0007](docs/adr/0007-terminaison-tls-et-reverse-proxy-nginx.md).
-
-Sur la VM ENI, deux environnements cohabitent, recette sur `dev` et production sur `main`,
-chacun dans son dossier et son projet Compose : `scripts/provision-host.sh` les prépare, le
-workflow `deploy.yml` les redéploie à chaque push par un runner auto-hébergé. Ports, noms
-d'hôte et garde-fous dans [`docs/architecture/10-infra.md`](docs/architecture/10-infra.md) et
-[l'ADR 0009](docs/adr/0009-deux-environnements-compose-sur-la-vm-eni.md).
-
 ## Conventions
 
 - Branches : `feat/`, `fix/`, `chore/`, `docs/`, `test/` suivi d'un libelle court.

apps/backend/.env.example

@@ -18,7 +18,3 @@ APP_SMTP_HOST=localhost
 APP_SMTP_PORT=1025
 APP_SMTP_USE_TLS=false
 APP_SMTP_FROM_ADDRESS=no-reply@enervision.fr
-APP_MOCK_API_BASE_URL=https://api-mock.charlieandre.fr
-APP_MOCK_API_USERNAME=change_me
-APP_MOCK_API_PASSWORD=change_me
-APP_MOCK_API_TIMEOUT_SECONDS=10

apps/backend/Dockerfile

@@ -11,14 +11,13 @@ WORKDIR /app
 RUN --mount=type=cache,target=/root/.cache/uv \
     --mount=type=bind,source=uv.lock,target=uv.lock \
     --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
-    uv sync --locked --no-install-project --no-dev --no-build
+    uv sync --locked --no-install-project --no-dev
 
-# Le projet lui-meme n'est pas installe (pas de second `uv sync`) : il tourne depuis /app, le
-# repertoire de travail, et rien ne lit ses metadonnees. L'installer imposerait de le construire
-# (backend hatchling), donc de retirer `--no-build` de l'etape ci-dessus, qui garantit que
-# l'installation des dependances n'execute aucun script de build (regle Sonar docker:S8541).
 COPY . /app
 
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --locked --no-dev
+
 
 FROM python:3.14-slim AS runtime
 

apps/backend/README.md

@@ -113,7 +113,6 @@ Le sens de dependance est unique : `endpoints` vers `services` vers `repositorie
 | `/api/v1/sites/{site_id}` | Décrit un site | `lecteur` |
 | `/api/v1/recommendations` | Liste les recommandations | `lecteur` |
 | `/api/v1/recommendations/{recommendation_id}` | Décrit une recommandation | `lecteur` |
-| `/api/v1/recommendations/generate` | Génère les recommandations depuis les alertes (POST) | `admin` |
 | `/metrics` | Métriques au format Prometheus | jeton si `APP_METRICS_TOKEN` |
 | `/docs`, `/openapi.json` | Documentation, fermée en `staging` et `prod` | public sinon |
 

apps/backend/TESTING.md

@@ -123,11 +123,6 @@ async def test_repository_reads_back_what_it_wrote(session: AsyncSession) -> Non
 defaut, ce qui garde `make check` jouable sans Docker. Tout autre marqueur doit etre
 declare dans `pyproject.toml` : `--strict-markers` refuse les marqueurs inconnus.
 
-Ces tests ne sont pas pour autant facultatifs : le job `integration` de
-`.github/workflows/backend.yml` monte un service TimescaleDB, applique les migrations et
-les joue a chaque poussee. Un test `integration` casse donc la CI comme un autre. En local,
-`make db-up` puis `make test-integration`.
-
 ## Couverture
 
 Les branches sont mesurees, pas seulement les lignes. Le seuil de 85 % ne s'applique
@@ -147,27 +142,14 @@ uv run pytest tests/api/test_health.py           # un seul fichier
 uv run pytest -k readiness                       # par motif de nom
 ```
 
-## Quatre fichiers à connaître avant de toucher à l'authentification
-
-`tests/api/acces.py` porte la classification des routes du contrat, en quatre ensembles :
-`ROUTES_PUBLIQUES`, `ROUTE_COOKIE`, `ROUTES_SANS_ROLE` et la table `ROLE_MINIMUM`. Ce n'est pas
-un fichier de test, c'est la référence que les trois autres confrontent au comportement observé.
-**Toute route ajoutée doit y être classée** : `test_every_declared_route_is_classified` échoue
-sinon, et échoue aussi sur une entrée qui ne correspond plus à aucune route.
+## Trois fichiers à connaître avant de toucher à l'authentification
 
 `tests/api/test_route_protection.py` interroge réellement chaque route sans identifiant et
 échoue si l'une d'elles répond autre chose qu'un 401 ou un 403. Il n'inspecte pas l'arbre de
 dépendances : celui-ci n'est accessible que par l'API privée de FastAPI, et surtout une route
 peut porter la bonne dépendance tout en répondant quand même. **Rendre une route publique impose
-donc de modifier `ROUTES_PUBLIQUES` dans `acces.py`**, ce qui apparaît en clair dans la diff
-d'une pull request.
-
-`tests/api/test_matrice_acces.py` croise chaque route gardée avec chacun des trois rôles, dans
-les deux sens : un rôle insuffisant reçoit un 403 `Droits insuffisants`, un rôle suffisant ne le
-reçoit jamais. Le second sens est ce qui rend visible une garde posée trop haut, par exemple
-`AdminDep` sur une route de lecture. La même matrice est rejouée sous `integration` avec de vrais
-jetons, donc en traversant le décodage du JWT et la relecture du compte en base, que
-`dependency_overrides` court-circuite.
+donc de modifier la liste `ROUTES_PUBLIQUES` de ce fichier**, ce qui apparaît en clair dans la
+diff d'une pull request.
 
 `tests/services/test_auth.py` donne au faux hacheur un **compteur d'appels**. C'est ce qui rend
 possibles les deux assertions qui prouvent la conception, et qu'aucune autre forme de test

apps/backend/app/api/deps.py

@@ -27,7 +27,6 @@ from app.repositories.audit_log import AuditLogRepository
 from app.repositories.login_attempt import LoginAttemptRepository
 from app.repositories.password_reset_attempt import PasswordResetAttemptRepository
 from app.repositories.password_reset_token import PasswordResetTokenRepository
-from app.repositories.prediction import PredictionRepository
 from app.repositories.reading import ReadingRepository
 from app.repositories.recommendation import RecommendationRepository
 from app.repositories.refresh_token import RefreshTokenRepository
@@ -35,7 +34,6 @@ from app.repositories.site import SiteRepository
 from app.repositories.user import UserRepository
 from app.services.alert import AlertService
 from app.services.auth import AuthService, LoginPolicy, PasswordResetPolicy
-from app.services.prediction import PredictionService
 from app.services.reading import ReadingService
 from app.services.recommendation import RecommendationService
 from app.services.sensor import SensorService
@@ -180,23 +178,14 @@ SiteServiceDep = Annotated[SiteService, Depends(get_site_service)]
 
 
 def get_alert_service(session: SessionDep) -> AlertService:
-    return AlertService(
-        alerts=AlertRepository(session),
-        readings=ReadingRepository(session),
-        predictions=PredictionRepository(session),
-        sites=SiteRepository(session),
-    )
+    return AlertService(alerts=AlertRepository(session))
 
 
 AlertServiceDep = Annotated[AlertService, Depends(get_alert_service)]
 
 
 def get_recommendation_service(session: SessionDep) -> RecommendationService:
-    return RecommendationService(
-        recommendations=RecommendationRepository(session),
-        alerts=AlertRepository(session),
-        transaction=session,
-    )
+    return RecommendationService(recommendations=RecommendationRepository(session))
 
 
 RecommendationServiceDep = Annotated[RecommendationService, Depends(get_recommendation_service)]
@@ -223,15 +212,6 @@ def get_sensor_service(session: SessionDep) -> SensorService:
 SensorServiceDep = Annotated[SensorService, Depends(get_sensor_service)]
 
 
-def get_prediction_service(session: SessionDep) -> PredictionService:
-    return PredictionService(
-        sites=SiteRepository(session), predictions=PredictionRepository(session)
-    )
-
-
-PredictionServiceDep = Annotated[PredictionService, Depends(get_prediction_service)]
-
-
 async def get_current_principal(
     credentials: CredentialsDep,
     session: SessionDep,

apps/backend/app/api/openapi.py

@@ -63,7 +63,7 @@ TAGS: Final[list[dict[str, Any]]] = [
         "name": "recommendations",
         "description": (
             "Consultation des recommandations issues des alertes. Accessible à partir du rôle "
-            "`lecteur`. Leur génération par le moteur de règles est réservée au rôle `admin`."
+            "`lecteur`."
         ),
     },
     {
@@ -83,13 +83,6 @@ TAGS: Final[list[dict[str, Any]]] = [
         "name": "sensors",
         "description": "État de santé des capteurs par site. Réservé au rôle `admin`.",
     },
-    {
-        "name": "predictions",
-        "description": (
-            "Dernière prévision de consommation par site, calculée hors ligne par le pipeline "
-            "de scoring (`ml/`) et simplement lue ici. Accessible à partir du rôle `lecteur`."
-        ),
-    },
 ]
 
 cookie_de_rafraichissement = APIKeyCookie(

apps/backend/app/api/v1/endpoints/predictions.py

@@ -1,18 +0,0 @@
-from fastapi import APIRouter
-
-from app.api.deps import LecteurDep, PredictionServiceDep
-from app.schemas.prediction import PredictionSummaryResponse
-
-router = APIRouter()
-
-
-@router.get(
-    "",
-    response_model=PredictionSummaryResponse,
-    summary="Dernière prédiction de consommation par site",
-)
-async def get_predictions(
-    _: LecteurDep, service: PredictionServiceDep
-) -> PredictionSummaryResponse:
-    resume = await service.summary()
-    return PredictionSummaryResponse.model_validate(resume)

apps/backend/app/api/v1/endpoints/recommendations.py

@@ -1,18 +1,13 @@
 from fastapi import APIRouter, HTTPException, status
 
-from app.api.deps import AdminDep, LecteurDep, RecommendationServiceDep
-from app.api.openapi import REPONSE_VALIDATION, REPONSES_ADMIN, Reponses
+from app.api.deps import LecteurDep, RecommendationServiceDep
+from app.api.openapi import REPONSE_VALIDATION, Reponses
 from app.schemas.errors import ErrorResponse
-from app.schemas.recommendation import (
-    RecommendationGenerationResponse,
-    RecommendationResponse,
-)
+from app.schemas.recommendation import RecommendationResponse
 from app.services.recommendation import RecommendationNotFoundError
 
 router = APIRouter()
 
-REPONSES_GENERATION: Reponses = {**REPONSES_ADMIN, **REPONSE_VALIDATION}
-
 REPONSES_INTROUVABLE: Reponses = {
     **REPONSE_VALIDATION,
     404: {"model": ErrorResponse, "description": "Aucune recommandation ne porte cet identifiant."},
@@ -43,22 +38,3 @@ async def get_recommendation(
             status_code=status.HTTP_404_NOT_FOUND, detail="Recommandation introuvable"
         ) from erreur
     return RecommendationResponse.model_validate(recommendation)
-
-
-@router.post(
-    "/generate",
-    response_model=RecommendationGenerationResponse,
-    summary="Génère les recommandations à partir des alertes",
-    responses=REPONSES_GENERATION,
-)
-async def generate_recommendations(
-    _: AdminDep,
-    service: RecommendationServiceDep,
-    site_id: str | None = None,
-) -> RecommendationGenerationResponse:
-    rapport = await service.generate(site_id=site_id)
-    return RecommendationGenerationResponse(
-        alerts_examined=rapport.alertes_examinees,
-        recommendations_created=rapport.recommandations_creees,
-        already_present=rapport.deja_presentes,
-    )

apps/backend/app/api/v1/router.py

@@ -5,7 +5,6 @@ from app.api.v1.endpoints import (
     alerts,
     auth,
     health,
-    predictions,
     readings,
     recommendations,
     sensors,
@@ -35,6 +34,3 @@ api_router.include_router(
 api_router.include_router(
     sensors.router, prefix="/sensors", tags=["sensors"], responses=REPONSES_ADMIN
 )
-api_router.include_router(
-    predictions.router, prefix="/predictions", tags=["predictions"], responses=REPONSES_LECTEUR
-)

apps/backend/app/cli.py

@@ -22,11 +22,8 @@ from app.core.hashing import build_hasher
 from app.core.roles import Role
 from app.db.session import get_session_factory
 from app.main import create_app
-from app.repositories.alert import AlertRepository
-from app.repositories.recommendation import RecommendationRepository
 from app.repositories.user import UserRepository
 from app.schemas.auth import PASSWORD_MIN_LENGTH, SPECIAL_CHARACTERS, valide_complexite
-from app.services.recommendation import RecommendationService
 
 LONGUEUR_MOT_DE_PASSE_GENERE = 24
 CHEMIN_CONTRAT = Path(__file__).resolve().parent.parent / "openapi.json"
@@ -66,22 +63,6 @@ async def create_admin(
     )
 
 
-async def generate_recommendations(*, site_id: str | None) -> str:
-    async with get_session_factory()() as session:
-        service = RecommendationService(
-            recommendations=RecommendationRepository(session),
-            alerts=AlertRepository(session),
-            transaction=session,
-        )
-        rapport = await service.generate(site_id=site_id)
-
-    return (
-        f"{rapport.alertes_examinees} alerte(s) examinée(s), "
-        f"{rapport.recommandations_creees} recommandation(s) créée(s), "
-        f"{rapport.deja_presentes} déjà présente(s)"
-    )
-
-
 # Piège : le schéma ne doit dépendre ni du `.env` du poste ni des variables `APP_*`, sinon le
 # fichier versionné changerait de machine en machine et le test de dérive deviendrait un oracle
 # de configuration locale. Tout ce qui atteint le schéma est donc posé ici, `_env_file` compris.
@@ -128,14 +109,6 @@ def build_parser() -> argparse.ArgumentParser:
         "export-openapi", help="Écrit le contrat OpenAPI sur disque"
     )
     contrat.add_argument("--output", default=str(CHEMIN_CONTRAT))
-
-    recommandations = sous_commandes.add_parser(
-        "generate-recommendations",
-        help="Applique le moteur de règles aux alertes en base",
-    )
-    recommandations.add_argument(
-        "--site-id", default=None, help="Limite le traitement aux alertes d'un site"
-    )
     return parser
 
 
@@ -179,10 +152,6 @@ def main(argv: list[str] | None = None) -> int:
         print(export_openapi(Path(arguments.output)))
         return 0
 
-    if arguments.commande == "generate-recommendations":
-        print(asyncio.run(generate_recommendations(site_id=arguments.site_id)))
-        return 0
-
     mot_de_passe = read_password(generate=arguments.generate)
 
     succes, message = asyncio.run(

apps/backend/app/core/config.py

@@ -34,11 +34,6 @@ class Settings(BaseSettings):
     database_pool_size: int = 5
     database_max_overflow: int = 10
 
-    mock_api_base_url: str = "https://api-mock.charlieandre.fr"
-    mock_api_username: str | None = None
-    mock_api_password: SecretStr | None = None
-    mock_api_timeout_seconds: float = Field(default=10.0, gt=0)
-
     jwt_issuer: str = "enervision-api"
     jwt_audience: str = "enervision-web"
     access_token_ttl_seconds: int = Field(default=900, ge=60, le=3600)

apps/backend/app/detection/internal_alerts.py

@@ -1,68 +0,0 @@
-# Détection d'alertes internes EnerVision (issue #104) : script lancé à la main pour l'instant,
-# comme `enervision_ml.score` côté ML, sans automatisation Airflow pour l'ordonnancer.
-
-from __future__ import annotations
-
-import argparse
-import asyncio
-import sys
-from datetime import UTC, datetime
-
-from app.core.config import get_settings
-from app.db.session import get_session_factory
-from app.repositories.alert import AlertRepository
-from app.repositories.prediction import PredictionRepository
-from app.repositories.reading import ReadingRepository
-from app.repositories.site import SiteRepository
-from app.services.alert import AlertService
-
-
-async def run_detection(*, now: datetime | None = None, site_id: str | None = None) -> int:
-    """Exécute les cinq règles de détection et enregistre les nouvelles alertes. Rend le nombre de
-    lignes effectivement insérées (les doublons de `source_alert_id` sont silencieusement
-    ignorés)."""
-    async with get_session_factory()() as session:
-        service = AlertService(
-            alerts=AlertRepository(session),
-            readings=ReadingRepository(session),
-            predictions=PredictionRepository(session),
-            sites=SiteRepository(session),
-        )
-        nouvelles = await service.detect(now=now, site_id=site_id)
-        await session.commit()
-    return len(nouvelles)
-
-
-def _parse_instant(valeur: str) -> datetime:
-    instant = datetime.fromisoformat(valeur)
-    return instant if instant.tzinfo is not None else instant.replace(tzinfo=UTC)
-
-
-def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        prog="python -m app.detection.internal_alerts",
-        description="Détection d'alertes internes EnerVision",
-    )
-    parser.add_argument("--site-id", default=None, help="Limite la détection à un seul site.")
-    parser.add_argument(
-        "--now",
-        type=_parse_instant,
-        default=None,
-        help=(
-            "Instant de référence (ISO 8601, UTC si le fuseau est omis). Défaut : l'heure courante."
-        ),
-    )
-    return parser.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = parse_args(argv)
-    # Échoue tôt si `APP_SECRET_KEY`/`DATABASE_URL` manquent, avant toute requête à la base.
-    get_settings()
-    nombre = asyncio.run(run_detection(now=args.now, site_id=args.site_id))
-    print(f"{nombre} nouvelle(s) alerte(s) enregistrée(s).")
-    return 0
-
-
-if __name__ == "__main__":  # pragma: no cover
-    sys.exit(main())

apps/backend/app/etl/mock_api_import.py

@@ -1,416 +0,0 @@
-# Contrainte : la réponse de l'API Mock est une entrée hostile, pas une source de confiance.
-# Voir OWASP API10 dans docs/architecture/owasp-traceabilite.md. Rien de ce qu'elle renvoie
-# n'atteint la base sans passer par build_site_row() ou build_reading_row() : seuls les champs
-# attendus sont recopiés, les grandeurs physiques sont bornées par PHYSICAL_BOUNDS et la taille
-# des tableaux est plafonnée par MAX_SITES et par --limit. Une valeur hors bornes devient NULL
-# et laisse sa trace dans null_reasons plutôt que de lever : le mock émet des anomalies par
-# construction, et raw_data conserve de toute façon la réponse d'origine intacte.
-
-from __future__ import annotations
-
-import argparse
-import asyncio
-import json
-from datetime import datetime
-from typing import Any
-
-import httpx
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine
-
-from app.core.config import get_settings
-
-SOURCE_HISTORY = "api_history"
-
-MAX_SITES = 100
-
-MAX_LIMIT = 1000
-
-# Les quatre seules valeurs que la contrainte ck_reading_quality accepte.
-ACCEPTED_QUALITIES = frozenset({"good", "partial", "degraded", "critical"})
-
-PHYSICAL_BOUNDS: dict[str, tuple[float, float]] = {
-    "consumption_kw": (0.0, 100_000.0),
-    "consumption_kwh": (0.0, 100_000.0),
-    "voltage_v": (0.0, 1_000.0),
-    "current_a": (0.0, 10_000.0),
-    "power_factor": (0.0, 1.0),
-    "temperature_celsius": (-90.0, 60.0),
-    "humidity_percent": (0.0, 100.0),
-}
-
-CAPACITY_BOUNDS = (0.0, 100_000.0)
-
-
-def create_mock_api_client() -> httpx.AsyncClient:
-    settings = get_settings()
-
-    if settings.mock_api_username is None or settings.mock_api_password is None:
-        raise ValueError("Les identifiants de l'API Mock ne sont pas configurés.")
-
-    return httpx.AsyncClient(
-        base_url=settings.mock_api_base_url.rstrip("/"),
-        auth=(
-            settings.mock_api_username,
-            settings.mock_api_password.get_secret_value(),
-        ),
-        timeout=settings.mock_api_timeout_seconds,
-    )
-
-
-def read_text(payload: dict[str, Any], key: str) -> str:
-    value = payload.get(key)
-
-    if not isinstance(value, str) or not value:
-        raise ValueError(f"Champ {key} absent ou invalide dans la réponse de l'API Mock.")
-
-    return value
-
-
-def optional_text(value: Any) -> str | None:
-    return value if isinstance(value, str) else None
-
-
-def coerce_measure(
-    value: Any,
-    bounds: tuple[float, float],
-) -> float | None:
-    if isinstance(value, bool) or not isinstance(value, int | float):
-        return None
-
-    lower, upper = bounds
-
-    # Écarte aussi NaN et les infinis, qu'aucune comparaison de bornes ne retient.
-    return float(value) if lower <= value <= upper else None
-
-
-def resolve_quality(
-    value: Any,
-    rejected: list[str],
-) -> str | None:
-    quality = value if isinstance(value, str) and value in ACCEPTED_QUALITIES else None
-
-    if rejected:
-        return "critical" if quality == "critical" else "degraded"
-
-    return quality
-
-
-def resolve_null_reasons(
-    value: Any,
-    rejected: list[str],
-) -> list[str]:
-    reported = [str(reason) for reason in value] if isinstance(value, list) else []
-
-    return reported + rejected
-
-
-async def fetch_sites(
-    client: httpx.AsyncClient,
-) -> list[dict[str, Any]]:
-    response = await client.get("/api/v1/sites")
-
-    response.raise_for_status()
-
-    payload = response.json()
-
-    if not isinstance(payload, list):
-        raise ValueError("La réponse /api/v1/sites doit être une liste.")
-
-    if len(payload) > MAX_SITES:
-        raise ValueError(f"La réponse /api/v1/sites dépasse le plafond de {MAX_SITES} sites.")
-
-    return payload
-
-
-def build_site_row(
-    site: dict[str, Any],
-) -> dict[str, Any]:
-    return {
-        "site_id": read_text(site, "site_id"),
-        "site_type": read_text(site, "site_type"),
-        "site_name": read_text(site, "site_name"),
-        "location": optional_text(site.get("location")),
-        "capacity_kw": coerce_measure(site.get("capacity_kw"), CAPACITY_BOUNDS),
-        "status": optional_text(site.get("status")),
-    }
-
-
-async def upsert_sites(
-    connection: AsyncConnection,
-    sites: list[dict[str, Any]],
-) -> None:
-    rows = [build_site_row(site) for site in sites]
-
-    if not rows:
-        return
-
-    await connection.execute(
-        text(
-            """
-            INSERT INTO site (
-                site_id,
-                site_type,
-                site_name,
-                location,
-                capacity_kw,
-                status
-            )
-            VALUES (
-                :site_id,
-                :site_type,
-                :site_name,
-                :location,
-                :capacity_kw,
-                :status
-            )
-            ON CONFLICT (site_id)
-            DO UPDATE SET
-                site_type = EXCLUDED.site_type,
-                site_name = EXCLUDED.site_name,
-                location = EXCLUDED.location,
-                capacity_kw = EXCLUDED.capacity_kw,
-                status = EXCLUDED.status
-            """
-        ),
-        rows,
-    )
-
-
-async def fetch_readings(
-    client: httpx.AsyncClient,
-    site_id: str,
-    start_time: datetime,
-    end_time: datetime,
-    limit: int = MAX_LIMIT,
-) -> list[dict[str, Any]]:
-    response = await client.get(
-        "/api/v1/readings",
-        params={
-            "site_id": site_id,
-            "start_time": start_time.isoformat(),
-            "end_time": end_time.isoformat(),
-            "limit": limit,
-        },
-    )
-
-    response.raise_for_status()
-
-    payload = response.json()
-
-    if not isinstance(payload, list):
-        raise ValueError("La réponse /api/v1/readings doit être une liste.")
-
-    if len(payload) > limit:
-        raise ValueError(f"La réponse /api/v1/readings dépasse la limite demandée de {limit}.")
-
-    return payload
-
-
-def build_reading_row(
-    reading: dict[str, Any],
-) -> dict[str, Any]:
-    measures: dict[str, float | None] = {}
-    rejected: list[str] = []
-
-    for name, bounds in PHYSICAL_BOUNDS.items():
-        received = reading.get(name)
-        measures[name] = coerce_measure(received, bounds)
-
-        if received is not None and measures[name] is None:
-            rejected.append(f"out_of_physical_bounds:{name}")
-
-    return {
-        "site_id": read_text(reading, "site_id"),
-        "timestamp": parse_datetime(read_text(reading, "timestamp")),
-        "source": SOURCE_HISTORY,
-        "dataset_id": None,
-        **measures,
-        "consumption_euros": None,
-        "solar_irradiance_wm2": None,
-        "is_working_hours": None,
-        "data_quality": resolve_quality(reading.get("data_quality"), rejected),
-        "null_reasons": resolve_null_reasons(reading.get("null_reasons"), rejected),
-        "imputed_values": None,
-        "imputation_method": None,
-        "raw_data": json.dumps(
-            reading,
-            ensure_ascii=False,
-        ),
-    }
-
-
-# Le conflit vise l'index unique uq_reading_source plutôt que la table entière : sans cible
-# nommée, DO NOTHING avalerait aussi une violation de clé primaire.
-READING_INSERT = text(
-    """
-    INSERT INTO reading (
-        site_id,
-        timestamp,
-        source,
-        dataset_id,
-        consumption_kw,
-        consumption_kwh,
-        consumption_euros,
-        voltage_v,
-        current_a,
-        power_factor,
-        temperature_celsius,
-        humidity_percent,
-        solar_irradiance_wm2,
-        is_working_hours,
-        data_quality,
-        null_reasons,
-        imputed_values,
-        imputation_method,
-        raw_data
-    )
-    VALUES (
-        :site_id,
-        :timestamp,
-        :source,
-        :dataset_id,
-        :consumption_kw,
-        :consumption_kwh,
-        :consumption_euros,
-        :voltage_v,
-        :current_a,
-        :power_factor,
-        :temperature_celsius,
-        :humidity_percent,
-        :solar_irradiance_wm2,
-        :is_working_hours,
-        :data_quality,
-        :null_reasons,
-        CAST(:imputed_values AS jsonb),
-        :imputation_method,
-        CAST(:raw_data AS jsonb)
-    )
-    ON CONFLICT (site_id, timestamp, source, (coalesce(dataset_id, 0)))
-    DO NOTHING
-    """
-)
-
-
-def build_reading_batch(
-    readings: list[dict[str, Any]],
-) -> list[dict[str, Any]]:
-    return [build_reading_row(reading) for reading in readings]
-
-
-async def import_mock_api_history(
-    start_time: datetime,
-    end_time: datetime,
-    limit: int,
-    dry_run: bool,
-) -> None:
-    settings = get_settings()
-
-    async with create_mock_api_client() as client:
-        sites = await fetch_sites(client)
-
-        print(f"Sites récupérés : {len(sites)}")
-
-        all_readings: list[dict[str, Any]] = []
-
-        for site in sites:
-            site_id = read_text(site, "site_id")
-
-            readings = await fetch_readings(
-                client=client,
-                site_id=site_id,
-                start_time=start_time,
-                end_time=end_time,
-                limit=limit,
-            )
-
-            print(f"{site_id}: {len(readings)} lectures")
-
-            all_readings.extend(readings)
-
-    print(f"Lectures récupérées : {len(all_readings)}")
-
-    if dry_run:
-        print("Dry-run terminé : aucune donnée écrite.")
-        return
-
-    engine = create_async_engine(
-        str(settings.database_url),
-        pool_pre_ping=True,
-    )
-
-    try:
-        async with engine.begin() as connection:
-            await upsert_sites(
-                connection,
-                sites,
-            )
-
-            rows = build_reading_batch(all_readings)
-
-            if rows:
-                await connection.execute(
-                    READING_INSERT,
-                    rows,
-                )
-
-    finally:
-        await engine.dispose()
-
-    print("Import API Mock terminé.")
-
-
-def parse_datetime(value: str) -> datetime:
-    return datetime.fromisoformat(value.replace("Z", "+00:00"))
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=("Import historique depuis l'API Mock EnerVision"))
-
-    parser.add_argument(
-        "--start-time",
-        required=True,
-        type=parse_datetime,
-    )
-
-    parser.add_argument(
-        "--end-time",
-        required=True,
-        type=parse_datetime,
-    )
-
-    parser.add_argument(
-        "--limit",
-        type=int,
-        default=MAX_LIMIT,
-    )
-
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-    )
-
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-
-    if args.limit < 1 or args.limit > MAX_LIMIT:
-        raise ValueError(f"--limit doit être compris entre 1 et {MAX_LIMIT}.")
-
-    if args.start_time >= args.end_time:
-        raise ValueError("--start-time doit être antérieur à --end-time.")
-
-    asyncio.run(
-        import_mock_api_history(
-            start_time=args.start_time,
-            end_time=args.end_time,
-            limit=args.limit,
-            dry_run=args.dry_run,
-        )
-    )
-
-
-if __name__ == "__main__":
-    main()

apps/backend/app/repositories/alert.py

@@ -1,15 +1,10 @@
 from collections.abc import Sequence
 
 from sqlalchemy import select
-from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.energy import Alert
 
-# Douze colonnes par alerte, contre quatre pour une recommandation : le plafond asyncpg de
-# 32 767 parametres tombe a 2 730 lignes, d'ou un lot plus petit que `recommendation.py`.
-TAILLE_DE_LOT = 1000
-
 
 class AlertRepository:
     def __init__(self, session: AsyncSession) -> None:
@@ -24,41 +19,3 @@ class AlertRepository:
         if severity is not None:
             requete = requete.where(Alert.severity == severity)
         return (await self._session.scalars(requete)).all()
-
-    async def create_many(self, alerts: Sequence[Alert]) -> Sequence[Alert]:
-        # `ON CONFLICT DO NOTHING` sur `uq_alert_source_reference` : rejouer la détection sur une
-        # fenêtre qui recouvre une exécution précédente ne doit pas dupliquer une alerte déjà
-        # enregistrée. `RETURNING` ne renvoie donc que les lignes effectivement insérées.
-        if not alerts:
-            return []
-        valeurs = [
-            {
-                "source_alert_id": alerte.source_alert_id,
-                "site_id": alerte.site_id,
-                "source": alerte.source,
-                "timestamp": alerte.timestamp,
-                "type": alerte.type,
-                "severity": alerte.severity,
-                "message": alerte.message,
-                "value": alerte.value,
-                "threshold": alerte.threshold,
-                "metric": alerte.metric,
-                "prediction_id": alerte.prediction_id,
-                "raw_data": alerte.raw_data,
-            }
-            for alerte in alerts
-        ]
-        creees: list[Alert] = []
-        # Piège : asyncpg plafonne une requête à 32 767 paramètres. Une détection sur une fenêtre
-        # chargée dépasse ce seuil, et l'`INSERT` d'un seul tenant échouerait.
-        for debut in range(0, len(valeurs), TAILLE_DE_LOT):
-            requete = (
-                insert(Alert)
-                .values(valeurs[debut : debut + TAILLE_DE_LOT])
-                .on_conflict_do_nothing(constraint="uq_alert_source_reference")
-                .returning(Alert)
-            )
-            resultat = await self._session.execute(requete)
-            creees.extend(resultat.scalars().all())
-        await self._session.flush()
-        return creees

apps/backend/app/repositories/prediction.py

@@ -1,49 +0,0 @@
-from collections.abc import Sequence
-from datetime import datetime
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.models.energy import Prediction
-
-
-class PredictionRepository:
-    def __init__(self, session: AsyncSession) -> None:
-        self._session = session
-
-    async def list_since(
-        self, *, since: datetime, site_id: str | None = None
-    ) -> Sequence[Prediction]:
-        # Restreint à `available` : une prévision `insufficient_data`/`error` n'a pas de
-        # `predicted_value` à comparer à une lecture réelle (détection d'anomalie).
-        # Piège : `prediction` n'a pas d'unicité sur `(site_id, target_at)` (cf.
-        # `enervision_ml.score`, qui insère toujours une nouvelle ligne plutôt que d'écraser la
-        # précédente). `prediction_id` en dernier départage donc les égalités de `target_at` par
-        # ordre croissant : `_detect_anomaly` construit un dict qui garde le dernier rencontré,
-        # c'est-à-dire le run le plus récent plutôt qu'une ligne choisie au hasard par le plan
-        # d'exécution.
-        requete = (
-            select(Prediction)
-            .where(Prediction.target_at >= since, Prediction.status == "available")
-            .order_by(Prediction.site_id, Prediction.target_at, Prediction.prediction_id)
-        )
-        if site_id is not None:
-            requete = requete.where(Prediction.site_id == site_id)
-        return (await self._session.scalars(requete)).all()
-
-    async def latest_by_site(self) -> Sequence[Prediction]:
-        # `.distinct(site_id)` compile en `DISTINCT ON (site_id)` sous PostgreSQL : une seule
-        # ligne par site, la plus récente grâce à l'ordre composite qui suit. Même mécanisme que
-        # `ReadingRepository.latest_by_site`. Trié sur `target_at` (couvert par
-        # `ix_prediction_site_target`) plutôt que `created_at` : c'est la prévision la plus
-        # récente qui compte pour un tableau de bord, pas forcément le dernier run de scoring.
-        requete = (
-            select(Prediction)
-            .distinct(Prediction.site_id)
-            .order_by(
-                Prediction.site_id,
-                Prediction.target_at.desc(),
-                Prediction.prediction_id.desc(),
-            )
-        )
-        return (await self._session.scalars(requete)).all()

apps/backend/app/repositories/reading.py

@@ -34,21 +34,6 @@ class ReadingRepository:
         lecture: Reading | None = await self._session.scalar(requete)
         return lecture
 
-    async def list_since(self, *, since: datetime, site_id: str | None = None) -> Sequence[Reading]:
-        # Trié par site puis par heure croissante : la détection d'alertes (spike) a besoin de
-        # comparer chaque lecture à celle qui la précède immédiatement pour le même site.
-        # `reading_id` en dernier départage : `uq_reading_source` autorise deux lignes au même
-        # `site_id`+`timestamp` quand la `source` diffère (même piège que `latest_for_site`), sans
-        # quoi l'ordre entre elles ne serait pas garanti d'un appel à l'autre.
-        requete = (
-            select(Reading)
-            .where(Reading.timestamp >= since)
-            .order_by(Reading.site_id, Reading.timestamp, Reading.reading_id)
-        )
-        if site_id is not None:
-            requete = requete.where(Reading.site_id == site_id)
-        return (await self._session.scalars(requete)).all()
-
     async def list_history(
         self,
         *,

apps/backend/app/repositories/recommendation.py

@@ -1,24 +1,11 @@
 from collections.abc import Sequence
-from dataclasses import asdict, dataclass
 
 from sqlalchemy import select
-from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.energy import Recommendation
 
 
-@dataclass(frozen=True, slots=True)
-class NouvelleRecommandation:
-    alert_id: int
-    action: str
-    explanation: str
-    rule_reference: str
-
-
-TAILLE_DE_LOT = 1000
-
-
 class RecommendationRepository:
     def __init__(self, session: AsyncSession) -> None:
         self._session = session
@@ -33,19 +20,3 @@ class RecommendationRepository:
         )
         recommendation: Recommendation | None = await self._session.scalar(requete)
         return recommendation
-
-    # Pourquoi : l'idempotence est déléguée à `uq_recommendation_alert_rule` plutôt qu'à une
-    # lecture préalable, qui laisserait une fenêtre entre le contrôle et l'insertion.
-    async def create_missing(self, nouvelles: Sequence[NouvelleRecommandation]) -> int:
-        creees = 0
-        # Piège : asyncpg plafonne une requête à 32 767 paramètres, soit 8 191 lignes de quatre
-        # colonnes. Au-delà de ce seuil un `INSERT` d'un seul tenant échouerait.
-        for debut in range(0, len(nouvelles), TAILLE_DE_LOT):
-            requete = (
-                insert(Recommendation)
-                .values([asdict(nouvelle) for nouvelle in nouvelles[debut : debut + TAILLE_DE_LOT]])
-                .on_conflict_do_nothing(constraint="uq_recommendation_alert_rule")
-                .returning(Recommendation.recommendation_id)
-            )
-            creees += len((await self._session.scalars(requete)).all())
-        return creees

apps/backend/app/schemas/prediction.py

@@ -1,43 +0,0 @@
-from datetime import datetime
-from enum import StrEnum
-
-from pydantic import BaseModel, ConfigDict
-
-
-class PredictionTargetMetric(StrEnum):
-    CONSUMPTION_KWH = "consumption_kwh"
-    CONSUMPTION_KW = "consumption_kw"
-
-
-class PredictionStatus(StrEnum):
-    AVAILABLE = "available"
-    INSUFFICIENT_DATA = "insufficient_data"
-    ERROR = "error"
-
-
-class SitePredictionResponse(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    target_at: datetime
-    target_metric: PredictionTargetMetric
-    period_minutes: int | None
-    predicted_value: float | None
-    status: PredictionStatus
-    failure_reason: str | None
-    model_reference: str
-    created_at: datetime
-
-
-class SitePredictionSummaryResponse(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    site_id: str
-    site_name: str
-    prediction: SitePredictionResponse | None
-
-
-class PredictionSummaryResponse(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    timestamp: datetime
-    sites: list[SitePredictionSummaryResponse]

apps/backend/app/schemas/recommendation.py

@@ -12,9 +12,3 @@ class RecommendationResponse(BaseModel):
     explanation: str
     rule_reference: str
     created_at: datetime
-
-
-class RecommendationGenerationResponse(BaseModel):
-    alerts_examined: int
-    recommendations_created: int
-    already_present: int

apps/backend/app/services/alert.py

@@ -1,323 +1,14 @@
 from collections.abc import Sequence
-from datetime import UTC, datetime, timedelta
 
-from app.models.energy import Alert, Prediction, Reading, Site
+from app.models.energy import Alert
 from app.repositories.alert import AlertRepository
-from app.repositories.prediction import PredictionRepository
-from app.repositories.reading import ReadingRepository
-from app.repositories.site import SiteRepository
-
-# Fenêtre de lectures/prédictions analysée à chaque exécution : assez large pour couvrir une paire
-# de lectures consécutives (spike) et une coupure prolongée (outage), sans réanalyser tout
-# l'historique à chaque lancement manuel du script de détection.
-LOOKBACK = timedelta(hours=48)
-
-# Cadence nominale d'une lecture : le CSV historique comme l'API Mock livrent un pas horaire.
-EXPECTED_INTERVAL = timedelta(hours=1)
-# Au-delà de trois pas manqués, on parle de coupure plutôt que d'un simple retard d'ingestion.
-OUTAGE_THRESHOLD = EXPECTED_INTERVAL * 3
-
-# +/-50% entre deux lectures consécutives du même site.
-SPIKE_RELATIVE_THRESHOLD = 0.5
-# 30% d'écart entre la consommation réelle et la prévision du même site/instant.
-ANOMALY_RELATIVE_THRESHOLD = 0.3
-# Une prévision quasi nulle rend l'écart relatif ininterprétable ; on l'ignore plutôt.
-ANOMALY_MINIMUM_PREDICTED_VALUE = 1e-6
-
-THRESHOLD_METRIC = "consumption_kw"
-ANOMALY_METRIC = "consumption_kwh"
-# `data_quality` -> sévérité du capteur défaillant. `good` est volontairement absent : il ne
-# déclenche jamais d'alerte.
-QUALITE_VERS_SEVERITE: dict[str, str] = {
-    "partial": "low",
-    "degraded": "medium",
-    "critical": "critical",
-}
 
 
 class AlertService:
-    def __init__(
-        self,
-        *,
-        alerts: AlertRepository,
-        readings: ReadingRepository,
-        predictions: PredictionRepository,
-        sites: SiteRepository,
-    ) -> None:
+    def __init__(self, *, alerts: AlertRepository) -> None:
         self._alerts = alerts
-        self._readings = readings
-        self._predictions = predictions
-        self._sites = sites
 
     async def list_all(
         self, *, site_id: str | None = None, severity: str | None = None
     ) -> Sequence[Alert]:
         return await self._alerts.list_all(site_id=site_id, severity=severity)
-
-    async def detect(
-        self, *, now: datetime | None = None, site_id: str | None = None
-    ) -> Sequence[Alert]:
-        """Compare les lectures/prévisions récentes aux cinq règles internes et enregistre les
-        alertes déclenchées (`source='enervision'`). Idempotent grâce à `source_alert_id` :
-        rejouer sur une fenêtre déjà analysée ne recrée pas les mêmes lignes."""
-        instant = now or datetime.now(UTC)
-        depuis = instant - LOOKBACK
-
-        sites = await self._sites.list_all()
-        if site_id is not None:
-            sites = [site for site in sites if site.site_id == site_id]
-        sites_par_id = {site.site_id: site for site in sites}
-        if not sites_par_id:
-            return []
-
-        lectures = [
-            lecture
-            for lecture in await self._readings.list_since(since=depuis, site_id=site_id)
-            if lecture.site_id in sites_par_id
-        ]
-        predictions = [
-            prediction
-            for prediction in await self._predictions.list_since(since=depuis, site_id=site_id)
-            if prediction.site_id in sites_par_id
-        ]
-        dernieres_lectures = {
-            lecture.site_id: lecture
-            for lecture in await self._readings.latest_by_site()
-            if lecture.site_id in sites_par_id
-        }
-
-        candidates = [
-            *_detect_threshold(lectures, sites_par_id),
-            *_detect_spike(lectures),
-            *_detect_anomaly(lectures, predictions),
-            *_detect_outage(sites, dernieres_lectures, instant),
-            *_detect_sensor(lectures),
-        ]
-        if not candidates:
-            return []
-        return await self._alerts.create_many(candidates)
-
-
-def _severity_from_ratio(ratio: float) -> str:
-    if ratio >= 2.0:
-        return "critical"
-    if ratio >= 1.5:
-        return "high"
-    if ratio >= 1.2:
-        return "medium"
-    return "low"
-
-
-def _detect_threshold(lectures: Sequence[Reading], sites_par_id: dict[str, Site]) -> list[Alert]:
-    # Seuil fixe = la capacité déclarée du site : dépasser `capacity_kw` est un dépassement
-    # matériel, pas une simple variation, et évite un seuil arbitraire non fourni par le domaine.
-    alertes = []
-    for lecture in lectures:
-        site = sites_par_id[lecture.site_id]
-        valeur = lecture.consumption_kw
-        if site.capacity_kw is None or site.capacity_kw <= 0 or valeur is None:
-            continue
-        if valeur <= site.capacity_kw:
-            continue
-        alertes.append(
-            Alert(
-                source_alert_id=f"threshold:{THRESHOLD_METRIC}:{lecture.timestamp.isoformat()}",
-                site_id=lecture.site_id,
-                source="enervision",
-                timestamp=lecture.timestamp,
-                type="threshold",
-                severity=_severity_from_ratio(valeur / site.capacity_kw),
-                message=(
-                    f"Puissance appelée {valeur:.1f} kW au-dessus de la capacité du site "
-                    f"({site.capacity_kw:.1f} kW)"
-                ),
-                value=valeur,
-                threshold=site.capacity_kw,
-                metric=THRESHOLD_METRIC,
-                prediction_id=None,
-                raw_data={},
-            )
-        )
-    return alertes
-
-
-def _detect_spike(lectures: Sequence[Reading]) -> list[Alert]:
-    # `lectures` est triée par site, heure puis `reading_id` (cf. `ReadingRepository.list_since`) :
-    # deux lignes consécutives du même site sont donc deux mesures consécutives dans le temps,
-    # sauf lorsqu'elles partagent le même horodatage (deux `source` différentes pour le même
-    # instant, permises par `uq_reading_source`) : ce n'est alors pas une variation réelle, on
-    # l'ignore plutôt que de générer une fausse alerte figée par son `source_alert_id`.
-    alertes = []
-    precedente: Reading | None = None
-    for lecture in lectures:
-        if (
-            precedente is None
-            or precedente.site_id != lecture.site_id
-            or precedente.timestamp == lecture.timestamp
-        ):
-            precedente = lecture
-            continue
-        avant, apres = precedente.consumption_kw, lecture.consumption_kw
-        precedente = lecture
-        if avant is None or apres is None:
-            continue
-        if avant == 0:
-            # Une variation relative n'a pas de sens depuis zéro, mais un redémarrage direct à
-            # une consommation positive reste le signal le plus alarmant du lot : `critical`
-            # plutôt qu'un ratio indéfini.
-            if apres > 0:
-                alertes.append(_spike_alert(lecture, avant, apres, severity="critical"))
-            continue
-        variation = abs(apres - avant) / abs(avant)
-        if variation < SPIKE_RELATIVE_THRESHOLD:
-            continue
-        alertes.append(
-            _spike_alert(
-                lecture,
-                avant,
-                apres,
-                severity=_severity_from_ratio(variation / SPIKE_RELATIVE_THRESHOLD),
-            )
-        )
-    return alertes
-
-
-def _spike_alert(lecture: Reading, avant: float, apres: float, *, severity: str) -> Alert:
-    return Alert(
-        source_alert_id=f"spike:{THRESHOLD_METRIC}:{lecture.timestamp.isoformat()}",
-        site_id=lecture.site_id,
-        source="enervision",
-        timestamp=lecture.timestamp,
-        type="spike",
-        severity=severity,
-        message=(
-            f"Variation brutale entre deux lectures consécutives ({avant:.1f} kW -> {apres:.1f} kW)"
-        ),
-        value=apres,
-        threshold=avant,
-        metric=THRESHOLD_METRIC,
-        prediction_id=None,
-        raw_data={},
-    )
-
-
-def _detect_anomaly(lectures: Sequence[Reading], predictions: Sequence[Prediction]) -> list[Alert]:
-    # Alignement strict (site_id, target_at == timestamp) : `enervision_ml.score` produit une
-    # cible à l'heure pile suivant la dernière lecture, sur la même grille horaire que `reading`.
-    predictions_par_cle = {
-        (prediction.site_id, prediction.target_at): prediction
-        for prediction in predictions
-        if prediction.target_metric == ANOMALY_METRIC
-    }
-    alertes = []
-    for lecture in lectures:
-        prediction = predictions_par_cle.get((lecture.site_id, lecture.timestamp))
-        reel = lecture.consumption_kwh
-        if prediction is None or reel is None or prediction.predicted_value is None:
-            continue
-        predite = prediction.predicted_value
-        if abs(predite) < ANOMALY_MINIMUM_PREDICTED_VALUE:
-            continue
-        ecart = abs(reel - predite) / abs(predite)
-        if ecart < ANOMALY_RELATIVE_THRESHOLD:
-            continue
-        alertes.append(
-            Alert(
-                source_alert_id=f"anomaly:{ANOMALY_METRIC}:{lecture.timestamp.isoformat()}",
-                site_id=lecture.site_id,
-                source="enervision",
-                timestamp=lecture.timestamp,
-                type="anomaly",
-                severity=_severity_from_ratio(ecart / ANOMALY_RELATIVE_THRESHOLD),
-                message=(
-                    f"Écart de {ecart * 100:.0f}% entre la consommation mesurée ({reel:.1f} kWh) "
-                    f"et la prévision ({predite:.1f} kWh)"
-                ),
-                value=reel,
-                threshold=predite,
-                metric=ANOMALY_METRIC,
-                prediction_id=prediction.prediction_id,
-                raw_data={},
-            )
-        )
-    return alertes
-
-
-def _detect_outage(
-    sites: Sequence[Site], dernieres_lectures: dict[str, Reading], now: datetime
-) -> list[Alert]:
-    alertes = []
-    for site in sites:
-        derniere = dernieres_lectures.get(site.site_id)
-        if derniere is None:
-            alertes.append(
-                _outage_alert(
-                    site.site_id,
-                    now,
-                    reference=None,
-                    message="Aucune lecture n'a jamais été reçue pour ce site",
-                    severity="critical",
-                )
-            )
-            continue
-        absence = now - derniere.timestamp
-        if absence < OUTAGE_THRESHOLD:
-            continue
-        alertes.append(
-            _outage_alert(
-                site.site_id,
-                now,
-                reference=derniere.timestamp,
-                message=(
-                    f"Aucune lecture depuis {absence} (dernière lecture : "
-                    f"{derniere.timestamp.isoformat()})"
-                ),
-                severity=_severity_from_ratio(absence / OUTAGE_THRESHOLD),
-            )
-        )
-    return alertes
-
-
-def _outage_alert(
-    site_id: str, now: datetime, *, reference: datetime | None, message: str, severity: str
-) -> Alert:
-    return Alert(
-        source_alert_id=f"outage:{reference.isoformat() if reference is not None else 'jamais'}",
-        site_id=site_id,
-        source="enervision",
-        timestamp=now,
-        type="outage",
-        severity=severity,
-        message=message,
-        value=None,
-        threshold=None,
-        metric=None,
-        prediction_id=None,
-        raw_data={},
-    )
-
-
-def _detect_sensor(lectures: Sequence[Reading]) -> list[Alert]:
-    alertes = []
-    for lecture in lectures:
-        severite = QUALITE_VERS_SEVERITE.get(lecture.data_quality or "")
-        if severite is None:
-            continue
-        raisons = ", ".join(lecture.null_reasons or []) or "raison non précisée"
-        alertes.append(
-            Alert(
-                source_alert_id=f"sensor:{lecture.timestamp.isoformat()}",
-                site_id=lecture.site_id,
-                source="enervision",
-                timestamp=lecture.timestamp,
-                type="sensor",
-                severity=severite,
-                message=f"Qualité de mesure {lecture.data_quality} ({raisons})",
-                value=None,
-                threshold=None,
-                metric=None,
-                prediction_id=None,
-                raw_data={},
-            )
-        )
-    return alertes

apps/backend/app/services/prediction.py

@@ -1,68 +0,0 @@
-from dataclasses import dataclass
-from datetime import UTC, datetime
-
-from app.models.energy import Prediction, Site
-from app.repositories.prediction import PredictionRepository
-from app.repositories.site import SiteRepository
-
-
-@dataclass(frozen=True, slots=True)
-class SitePrediction:
-    target_at: datetime
-    target_metric: str
-    period_minutes: int | None
-    predicted_value: float | None
-    status: str
-    failure_reason: str | None
-    model_reference: str
-    created_at: datetime
-
-
-@dataclass(frozen=True, slots=True)
-class SitePredictionSummary:
-    site_id: str
-    site_name: str
-    prediction: SitePrediction | None
-
-
-@dataclass(frozen=True, slots=True)
-class PredictionSummary:
-    timestamp: datetime
-    sites: list[SitePredictionSummary]
-
-
-class PredictionService:
-    def __init__(self, sites: SiteRepository, predictions: PredictionRepository) -> None:
-        self._sites = sites
-        self._predictions = predictions
-
-    async def summary(self) -> PredictionSummary:
-        sites = await self._sites.list_all()
-        dernieres = {p.site_id: p for p in await self._predictions.latest_by_site()}
-
-        return PredictionSummary(
-            timestamp=datetime.now(UTC),
-            sites=[_resume_site(site, dernieres.get(site.site_id)) for site in sites],
-        )
-
-
-def _resume_site(site: Site, derniere: Prediction | None) -> SitePredictionSummary:
-    # Piège : l'absence de ligne signifie « jamais scoré », pas une valeur pseudo-statut, qui
-    # n'existe pas dans la contrainte de la table. `prediction` reste `None` plutôt que de
-    # fabriquer un statut absent du domaine `available`/`insufficient_data`/`error`.
-    prediction = None
-    if derniere is not None:
-        prediction = SitePrediction(
-            target_at=derniere.target_at,
-            target_metric=derniere.target_metric,
-            period_minutes=derniere.period_minutes,
-            predicted_value=derniere.predicted_value,
-            status=derniere.status,
-            failure_reason=derniere.failure_reason,
-            model_reference=derniere.model_reference,
-            created_at=derniere.created_at,
-        )
-
-    return SitePredictionSummary(
-        site_id=site.site_id, site_name=site.site_name, prediction=prediction
-    )

apps/backend/app/services/recommendation.py

@@ -1,15 +1,7 @@
 from collections.abc import Sequence
-from dataclasses import dataclass
-from typing import Protocol
 
 from app.models.energy import Recommendation
-from app.repositories.alert import AlertRepository
 from app.repositories.recommendation import RecommendationRepository
-from app.services.recommendation_rules import applique_les_regles
-
-
-class Transaction(Protocol):
-    async def commit(self) -> None: ...
 
 
 class RecommendationError(Exception):
@@ -20,24 +12,9 @@ class RecommendationNotFoundError(RecommendationError):
     pass
 
 
-@dataclass(frozen=True, slots=True)
-class RapportGeneration:
-    alertes_examinees: int
-    recommandations_creees: int
-    deja_presentes: int
-
-
 class RecommendationService:
-    def __init__(
-        self,
-        *,
-        recommendations: RecommendationRepository,
-        alerts: AlertRepository,
-        transaction: Transaction,
-    ) -> None:
+    def __init__(self, *, recommendations: RecommendationRepository) -> None:
         self._recommendations = recommendations
-        self._alerts = alerts
-        self._transaction = transaction
 
     async def list_all(self) -> Sequence[Recommendation]:
         return await self._recommendations.list_all()
@@ -47,16 +24,3 @@ class RecommendationService:
         if recommendation is None:
             raise RecommendationNotFoundError(recommendation_id)
         return recommendation
-
-    async def generate(self, *, site_id: str | None = None) -> RapportGeneration:
-        alertes = await self._alerts.list_all(site_id=site_id)
-        nouvelles = [nouvelle for alerte in alertes for nouvelle in applique_les_regles(alerte)]
-
-        creees = await self._recommendations.create_missing(nouvelles)
-        await self._transaction.commit()
-
-        return RapportGeneration(
-            alertes_examinees=len(alertes),
-            recommandations_creees=creees,
-            deja_presentes=len(nouvelles) - creees,
-        )

apps/backend/app/services/recommendation_rules.py

@@ -1,117 +0,0 @@
-# Piège : `rule_reference` est la clé d'idempotence en base, portée par la contrainte
-# `uq_recommendation_alert_rule`. Renommer une référence déjà livrée ne remplace pas les
-# recommandations existantes, il en crée de nouvelles à côté. Une règle qui change de sens
-# prend donc une référence suffixée `-v2` - REGLES.
-
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Final
-
-from app.models.energy import Alert
-from app.repositories.recommendation import NouvelleRecommandation
-from app.schemas.alert import AlertSeverity, AlertType
-
-FACTEUR_DEPASSEMENT_MAJEUR: Final = 1.2
-POURCENTAGE_DEPASSEMENT_MAJEUR: Final = round((FACTEUR_DEPASSEMENT_MAJEUR - 1) * 100)
-
-
-@dataclass(frozen=True, slots=True)
-class Regle:
-    reference: str
-    action: str
-    declencheur: Callable[[Alert], bool]
-    motif: Callable[[Alert], str]
-
-
-def _du_type(attendu: AlertType) -> Callable[[Alert], bool]:
-    return lambda alerte: alerte.type == attendu
-
-
-def _de_severite(attendue: AlertSeverity) -> Callable[[Alert], bool]:
-    return lambda alerte: alerte.severity == attendue
-
-
-# Un seuil nul ou négatif rendrait le rapport `value / threshold` arbitraire : l'alerte ne
-# renseigne alors aucun dépassement exploitable, et la règle ne se déclenche pas.
-def _depasse_largement_le_seuil(alerte: Alert) -> bool:
-    if alerte.value is None or alerte.threshold is None or alerte.threshold <= 0:
-        return False
-    return alerte.value >= alerte.threshold * FACTEUR_DEPASSEMENT_MAJEUR
-
-
-REGLES: Final[tuple[Regle, ...]] = (
-    Regle(
-        reference="spike-delestage-v1",
-        action="Délester les équipements non prioritaires sur le créneau du pic",
-        declencheur=_du_type(AlertType.SPIKE),
-        motif=lambda alerte: f"Pic de consommation signalé sur le site {alerte.site_id}",
-    ),
-    Regle(
-        reference="threshold-reduction-v1",
-        action="Ramener la puissance appelée sous le seuil contractuel",
-        declencheur=_du_type(AlertType.THRESHOLD),
-        motif=lambda alerte: f"Seuil de consommation dépassé sur le site {alerte.site_id}",
-    ),
-    Regle(
-        reference="outage-secours-v1",
-        action="Basculer sur l'alimentation de secours et prévenir l'exploitant",
-        declencheur=_du_type(AlertType.OUTAGE),
-        motif=lambda alerte: (
-            f"Risque de surcharge ou de coupure imminente sur le site {alerte.site_id}"
-        ),
-    ),
-    Regle(
-        reference="sensor-maintenance-v1",
-        action="Planifier une intervention de maintenance sur le capteur",
-        declencheur=_du_type(AlertType.SENSOR),
-        motif=lambda alerte: (
-            f"Capteur défaillant sur le site {alerte.site_id}, les mesures ne sont plus fiables"
-        ),
-    ),
-    Regle(
-        reference="anomaly-verification-v1",
-        action="Confronter la mesure à la prévision et vérifier le paramétrage du site",
-        declencheur=_du_type(AlertType.ANOMALY),
-        motif=lambda alerte: (
-            f"Écart anormal entre la mesure et le comportement attendu du site {alerte.site_id}"
-        ),
-    ),
-    Regle(
-        reference="escalade-astreinte-v1",
-        action="Escalader à l'astreinte sous une heure",
-        declencheur=_de_severite(AlertSeverity.CRITICAL),
-        motif=lambda alerte: f"Alerte de sévérité critique sur le site {alerte.site_id}",
-    ),
-    Regle(
-        reference="contrat-puissance-v1",
-        action="Réévaluer la puissance souscrite au contrat",
-        declencheur=_depasse_largement_le_seuil,
-        motif=lambda alerte: (
-            f"Dépassement d'au moins {POURCENTAGE_DEPASSEMENT_MAJEUR} % du seuil "
-            f"sur le site {alerte.site_id}"
-        ),
-    ),
-)
-
-
-def applique_les_regles(alerte: Alert) -> list[NouvelleRecommandation]:
-    contexte = _contexte_de_mesure(alerte)
-    return [
-        NouvelleRecommandation(
-            alert_id=alerte.alert_id,
-            action=regle.action,
-            explanation=f"{regle.motif(alerte)}{contexte}.",
-            rule_reference=regle.reference,
-        )
-        for regle in REGLES
-        if regle.declencheur(alerte)
-    ]
-
-
-def _contexte_de_mesure(alerte: Alert) -> str:
-    if alerte.value is None:
-        return ""
-    grandeur = alerte.metric or "valeur"
-    if alerte.threshold is None:
-        return f" ({grandeur} mesurée à {alerte.value})"
-    return f" ({grandeur} mesurée à {alerte.value}, seuil {alerte.threshold})"

apps/backend/openapi.json

@@ -1453,90 +1453,6 @@
         }
       }
     },
-    "/api/v1/recommendations/generate": {
-      "post": {
-        "tags": [
-          "recommendations"
-        ],
-        "summary": "Génère les recommandations à partir des alertes",
-        "operationId": "generate_recommendations_api_v1_recommendations_generate_post",
-        "security": [
-          {
-            "Jeton d'accès": []
-          }
-        ],
-        "parameters": [
-          {
-            "name": "site_id",
-            "in": "query",
-            "required": false,
-            "schema": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ],
-              "title": "Site Id"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/RecommendationGenerationResponse"
-                }
-              }
-            }
-          },
-          "500": {
-            "description": "Erreur interne. `correlation` identifie la trace côté serveur, qui n'est pas renvoyée au client.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InternalErrorResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "Jeton absent, illisible, périmé, ou rendu caduc par un changement de rôle ou une désactivation. L'en-tête `WWW-Authenticate` porte la cause dans `error=`.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ErrorResponse"
-                }
-              }
-            }
-          },
-          "403": {
-            "description": "Droits insuffisants, ou mot de passe provisoire à changer quand `detail` vaut `password_change_required`.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ErrorResponse"
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Corps invalide. Le détail nomme le champ fautif et le type d'erreur, jamais la valeur envoyée.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ValidationErrorResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
     "/api/v1/stats/summary": {
       "get": {
         "tags": [
@@ -1803,62 +1719,6 @@
           }
         ]
       }
-    },
-    "/api/v1/predictions": {
-      "get": {
-        "tags": [
-          "predictions"
-        ],
-        "summary": "Dernière prédiction de consommation par site",
-        "operationId": "get_predictions_api_v1_predictions_get",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/PredictionSummaryResponse"
-                }
-              }
-            }
-          },
-          "500": {
-            "description": "Erreur interne. `correlation` identifie la trace côté serveur, qui n'est pas renvoyée au client.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InternalErrorResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "Jeton absent, illisible, périmé, ou rendu caduc par un changement de rôle ou une désactivation. L'en-tête `WWW-Authenticate` porte la cause dans `error=`.",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ErrorResponse"
-                }
-              }
-            }
-          },
-          "403": {
-            "description": "Mot de passe provisoire à changer (`detail` vaut `password_change_required`).",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ErrorResponse"
-                }
-              }
-            }
-          }
-        },
-        "security": [
-          {
-            "Jeton d'accès": []
-          }
-        ]
-      }
     }
   },
   "components": {
@@ -2112,45 +1972,6 @@
         ],
         "title": "PasswordChangeRequest"
       },
-      "PredictionStatus": {
-        "type": "string",
-        "enum": [
-          "available",
-          "insufficient_data",
-          "error"
-        ],
-        "title": "PredictionStatus"
-      },
-      "PredictionSummaryResponse": {
-        "properties": {
-          "timestamp": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Timestamp"
-          },
-          "sites": {
-            "items": {
-              "$ref": "#/components/schemas/SitePredictionSummaryResponse"
-            },
-            "type": "array",
-            "title": "Sites"
-          }
-        },
-        "type": "object",
-        "required": [
-          "timestamp",
-          "sites"
-        ],
-        "title": "PredictionSummaryResponse"
-      },
-      "PredictionTargetMetric": {
-        "type": "string",
-        "enum": [
-          "consumption_kwh",
-          "consumption_kw"
-        ],
-        "title": "PredictionTargetMetric"
-      },
       "PrincipalResponse": {
         "properties": {
           "id": {
@@ -2428,29 +2249,6 @@
         ],
         "title": "ReadingSource"
       },
-      "RecommendationGenerationResponse": {
-        "properties": {
-          "alerts_examined": {
-            "type": "integer",
-            "title": "Alerts Examined"
-          },
-          "recommendations_created": {
-            "type": "integer",
-            "title": "Recommendations Created"
-          },
-          "already_present": {
-            "type": "integer",
-            "title": "Already Present"
-          }
-        },
-        "type": "object",
-        "required": [
-          "alerts_examined",
-          "recommendations_created",
-          "already_present"
-        ],
-        "title": "RecommendationGenerationResponse"
-      },
       "RecommendationResponse": {
         "properties": {
           "recommendation_id": {
@@ -2720,104 +2518,6 @@
         ],
         "title": "SiteCurrentResponse"
       },
-      "SitePredictionResponse": {
-        "properties": {
-          "target_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Target At"
-          },
-          "target_metric": {
-            "$ref": "#/components/schemas/PredictionTargetMetric"
-          },
-          "period_minutes": {
-            "anyOf": [
-              {
-                "type": "integer"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Period Minutes"
-          },
-          "predicted_value": {
-            "anyOf": [
-              {
-                "type": "number"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Predicted Value"
-          },
-          "status": {
-            "$ref": "#/components/schemas/PredictionStatus"
-          },
-          "failure_reason": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Failure Reason"
-          },
-          "model_reference": {
-            "type": "string",
-            "title": "Model Reference"
-          },
-          "created_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Created At"
-          }
-        },
-        "type": "object",
-        "required": [
-          "target_at",
-          "target_metric",
-          "period_minutes",
-          "predicted_value",
-          "status",
-          "failure_reason",
-          "model_reference",
-          "created_at"
-        ],
-        "title": "SitePredictionResponse"
-      },
-      "SitePredictionSummaryResponse": {
-        "properties": {
-          "site_id": {
-            "type": "string",
-            "title": "Site Id"
-          },
-          "site_name": {
-            "type": "string",
-            "title": "Site Name"
-          },
-          "prediction": {
-            "anyOf": [
-              {
-                "$ref": "#/components/schemas/SitePredictionResponse"
-              },
-              {
-                "type": "null"
-              }
-            ]
-          }
-        },
-        "type": "object",
-        "required": [
-          "site_id",
-          "site_name",
-          "prediction"
-        ],
-        "title": "SitePredictionSummaryResponse"
-      },
       "SiteResponse": {
         "properties": {
           "site_id": {
@@ -3260,7 +2960,7 @@
     },
     {
       "name": "recommendations",
-      "description": "Consultation des recommandations issues des alertes. Accessible à partir du rôle `lecteur`. Leur génération par le moteur de règles est réservée au rôle `admin`."
+      "description": "Consultation des recommandations issues des alertes. Accessible à partir du rôle `lecteur`."
     },
     {
       "name": "stats",
@@ -3273,10 +2973,6 @@
     {
       "name": "sensors",
       "description": "État de santé des capteurs par site. Réservé au rôle `admin`."
-    },
-    {
-      "name": "predictions",
-      "description": "Dernière prévision de consommation par site, calculée hors ligne par le pipeline de scoring (`ml/`) et simplement lue ici. Accessible à partir du rôle `lecteur`."
     }
   ]
 }

apps/backend/pyproject.toml

@@ -17,7 +17,6 @@ dependencies = [
     "argon2-cffi>=23.1",
     "anyio>=4.0",
     "aiosmtplib>=5.1.3",
-    "httpx>=0.28.1",
     "pandas>=3.0.5",
 ]
 
@@ -28,6 +27,7 @@ dev = [
     "pytest>=9.1.1",
     "pytest-asyncio>=1.4.0",
     "pytest-cov>=7.1.0",
+    "httpx>=0.28.1",
     "pandas-stubs>=3.0.5.260914",
 ]
 

apps/backend/tests/api/acces.py

@@ -1,88 +0,0 @@
-# Pourquoi : classification unique des routes du contrat, lue par test_route_protection.py,
-# test_openapi.py et test_matrice_acces.py. Trois listes séparées dérivaient auparavant chacune
-# de leur côté, et deux entrées de ROUTES_A_ROLE ne correspondaient plus à aucune route sans que
-# rien ne le signale.
-# Piège : les trois ensembles doivent rester disjoints et couvrir tout le schéma. C'est
-# `test_every_declared_route_is_classified` qui le vérifie, pas la relecture.
-
-from typing import Final
-
-from app.core.roles import Role
-
-Route = tuple[str, str]
-
-ROUTES_PUBLIQUES: Final[frozenset[Route]] = frozenset(
-    {
-        ("GET", "/api/v1/health/live"),
-        ("GET", "/api/v1/health/ready"),
-        ("POST", "/api/v1/auth/login"),
-        # Sans cookie, la déconnexion ne fait rien et répond 204 : elle est idempotente.
-        ("POST", "/api/v1/auth/logout"),
-        ("POST", "/api/v1/auth/forgot-password"),
-        # Protégée par le jeton dans le corps de la requête, pas par un `Principal` : aucune
-        # authentification préalable ne s'applique, c'est la validité du jeton qui tranche.
-        ("POST", "/api/v1/auth/reset-password"),
-        # Même raison : lecture seule, protégée par le jeton passé en paramètre, pas par un
-        # `Principal`. Le jeton est un secret de 256 bits, non brute-forçable.
-        ("GET", "/api/v1/auth/reset-password/validate"),
-        ("GET", "/metrics"),
-    }
-)
-
-# Le cookie opaque porte seul l'autorisation : sans lui la route rend 401, mais aucun `Principal`
-# n'est construit et `require_role` n'entre jamais en jeu.
-ROUTE_COOKIE: Final[frozenset[Route]] = frozenset({("POST", "/api/v1/auth/refresh")})
-
-# Authentifiées par `CurrentPrincipalDep` nu, donc hors de `require_role` et, avec lui, hors du
-# refus `password_change_required`. Volontaire pour `/auth/password`, qui est la sortie de l'état
-# provisoire ; subi pour `/auth/logout-all`, cf. test_matrice_acces.py.
-ROUTES_SANS_ROLE: Final[frozenset[Route]] = frozenset(
-    {
-        ("GET", "/api/v1/auth/me"),
-        ("POST", "/api/v1/auth/password"),
-        ("POST", "/api/v1/auth/logout-all"),
-    }
-)
-
-ROLE_MINIMUM: Final[dict[Route, Role]] = {
-    ("GET", "/api/v1/sites"): Role.LECTEUR,
-    ("GET", "/api/v1/sites/{site_id}"): Role.LECTEUR,
-    ("GET", "/api/v1/sites/{site_id}/current"): Role.LECTEUR,
-    ("GET", "/api/v1/alerts"): Role.LECTEUR,
-    ("GET", "/api/v1/recommendations"): Role.LECTEUR,
-    ("GET", "/api/v1/recommendations/{recommendation_id}"): Role.LECTEUR,
-    ("POST", "/api/v1/recommendations/generate"): Role.ADMIN,
-    ("GET", "/api/v1/stats/summary"): Role.LECTEUR,
-    ("GET", "/api/v1/readings"): Role.LECTEUR,
-    ("GET", "/api/v1/predictions"): Role.LECTEUR,
-    ("GET", "/api/v1/sensors/status"): Role.ADMIN,
-    ("GET", "/api/v1/users"): Role.ADMIN,
-    ("POST", "/api/v1/users"): Role.ADMIN,
-    ("PATCH", "/api/v1/users/{user_id}"): Role.ADMIN,
-    ("POST", "/api/v1/users/{user_id}/password-reset"): Role.ADMIN,
-}
-
-# Piège : `{recommendation_id}` est typé `int` et `{user_id}` est un UUID. Une substitution
-# uniforme par une chaîne quelconque rendrait 422 avant d'atteindre la garde de rôle, et le test
-# passerait en prouvant autre chose que ce qu'il annonce.
-SUBSTITUTIONS: Final[dict[str, str]] = {
-    "{user_id}": "00000000-0000-0000-0000-000000000000",
-    "{site_id}": "site-absent-du-jeu-de-donnees",
-    "{recommendation_id}": "999999999",
-}
-
-
-def chemin_concret(chemin: str) -> str:
-    for gabarit, valeur in SUBSTITUTIONS.items():
-        chemin = chemin.replace(gabarit, valeur)
-    return chemin
-
-
-def routes_du_schema(schema: dict[str, object]) -> list[Route]:
-    chemins: dict[str, dict[str, object]] = schema["paths"]  # type: ignore[assignment]
-    return [
-        (methode.upper(), chemin)
-        for chemin, operations in chemins.items()
-        for methode in operations
-        if methode.upper() in {"GET", "POST", "PATCH", "PUT", "DELETE"}
-    ]

apps/backend/tests/api/test_matrice_acces.py

@@ -1,279 +0,0 @@
-# Pourquoi : la matrice rôle x route sur les routes réelles. `test_authorization.py` la joue déjà,
-# mais contre une route jetable montée par une fixture, ce qui ne dit rien du niveau effectivement
-# posé sur `/sites` ou `/users`. `ROLE_MINIMUM` (tests/api/acces.py) est la référence, et ce
-# fichier est ce qui la confronte au comportement observé.
-# Piège : l'assertion porte sur le refus de la garde, pas sur un 200. Un rôle suffisant peut
-# légitimement recevoir 404 ou 422 selon les données ; ce qui compte est qu'il ne reçoive pas le
-# 403 `Droits insuffisants`. Sans cette nuance, le test dépendrait du contenu de la base.
-# Les tests `integration` en fin de fichier rejouent la même matrice avec de vrais jetons, donc en
-# traversant le décodage du JWT et la relecture du compte, ce que l'override court-circuite.
-
-import uuid
-from collections.abc import AsyncIterator, Callable, Iterator
-
-import pytest
-from fastapi import FastAPI
-from httpx import AsyncClient, Response
-from sqlalchemy import text
-
-from app.api.deps import get_current_principal
-from app.core.hashing import build_hasher
-from app.core.principal import Principal
-from app.core.roles import AccountKind, Role, has_at_least
-from app.db.session import get_session, get_session_factory
-from app.repositories.user import UserRepository
-from tests.api.acces import ROLE_MINIMUM, chemin_concret
-
-ROLES = [Role.LECTEUR, Role.OPERATEUR, Role.ADMIN]
-IDS_DE_ROLE = ["lecteur", "operateur", "admin"]
-REFUS_DE_DROITS = "Droits insuffisants"
-REFUS_DE_MOT_DE_PASSE = "password_change_required"
-MOT_DE_PASSE = "un-mot-de-passe-de-recette"
-
-
-# `FakeSession` de tests/factories.py rend un unique objet pour les trois formes d'appel, ce qui
-# suffit à un test d'endpoint ciblé mais pas à balayer 13 routes qui interrogent chacune la base
-# à sa façon. Ce double rend un résultat vide quelle que soit la forme demandée, pour que la
-# réponse observée vienne de la garde de rôle et jamais d'un double mal ajusté.
-class ResultatVide:
-    def scalars(self) -> ResultatVide:
-        return self
-
-    def all(self) -> list[object]:
-        return []
-
-    def first(self) -> None:
-        return None
-
-    def one_or_none(self) -> None:
-        return None
-
-    def scalar_one_or_none(self) -> None:
-        return None
-
-    def mappings(self) -> ResultatVide:
-        return self
-
-    def __iter__(self) -> Iterator[object]:
-        return iter(())
-
-
-class SessionMuette:
-    async def scalar(self, *_: object, **__: object) -> None:
-        return None
-
-    async def execute(self, *_: object, **__: object) -> ResultatVide:
-        return ResultatVide()
-
-    async def scalars(self, *_: object, **__: object) -> ResultatVide:
-        return ResultatVide()
-
-    async def get(self, *_: object, **__: object) -> None:
-        return None
-
-    async def flush(self) -> None:
-        return None
-
-    async def commit(self) -> None:
-        return None
-
-    async def rollback(self) -> None:
-        return None
-
-    def add(self, *_: object, **__: object) -> None:
-        return None
-
-
-@pytest.fixture
-def base_muette(app: FastAPI) -> None:
-    async def override() -> AsyncIterator[SessionMuette]:
-        yield SessionMuette()
-
-    app.dependency_overrides[get_session] = override
-
-
-def principal(role: Role, *, must_change_password: bool = False) -> Principal:
-    return Principal(
-        id=uuid.uuid4(),
-        email=f"matrice-{role.value}@enervision.fr",
-        role=role,
-        kind=AccountKind.HUMAIN,
-        must_change_password=must_change_password,
-    )
-
-
-@pytest.fixture
-def connecte(app: FastAPI) -> Iterator[Callable[[Principal], None]]:
-    def installe(acteur: Principal) -> None:
-        app.dependency_overrides[get_current_principal] = lambda: acteur
-
-    yield installe
-    app.dependency_overrides.pop(get_current_principal, None)
-
-
-async def appelle(client: AsyncClient, methode: str, chemin: str, **kwargs: object) -> Response:
-    return await client.request(methode, chemin_concret(chemin), json={}, **kwargs)  # type: ignore[arg-type]
-
-
-def motif_du_refus(response: Response) -> str | None:
-    if response.status_code != 403:
-        return None
-    detail = response.json().get("detail")
-    return detail if isinstance(detail, str) else None
-
-
-@pytest.mark.parametrize("role", ROLES, ids=IDS_DE_ROLE)
-async def test_a_role_below_the_minimum_is_refused_on_every_guarded_route(
-    connecte: Callable[[Principal], None],
-    client: AsyncClient,
-    base_muette: None,
-    role: Role,
-) -> None:
-    connecte(principal(role))
-    laissees_passer: list[tuple[str, str, int]] = []
-
-    for (methode, chemin), minimum in ROLE_MINIMUM.items():
-        if has_at_least(role, minimum):
-            continue
-        response = await appelle(client, methode, chemin)
-        if motif_du_refus(response) != REFUS_DE_DROITS:
-            laissees_passer.append((methode, chemin, response.status_code))
-
-    assert laissees_passer == []
-
-
-# Le pendant du test précédent : sans lui, une garde posée trop haut, par exemple `AdminDep` sur
-# `/sites`, ne ferait échouer aucun test du dépôt.
-@pytest.mark.parametrize("role", ROLES, ids=IDS_DE_ROLE)
-async def test_a_role_at_or_above_the_minimum_is_never_refused_by_the_guard(
-    connecte: Callable[[Principal], None],
-    client: AsyncClient,
-    base_muette: None,
-    role: Role,
-) -> None:
-    connecte(principal(role))
-    refusees: list[tuple[str, str]] = []
-
-    for (methode, chemin), minimum in ROLE_MINIMUM.items():
-        if not has_at_least(role, minimum):
-            continue
-        response = await appelle(client, methode, chemin)
-        if motif_du_refus(response) == REFUS_DE_DROITS:
-            refusees.append((methode, chemin))
-
-    assert refusees == []
-
-
-async def test_a_pending_password_change_is_refused_on_every_guarded_route(
-    connecte: Callable[[Principal], None],
-    client: AsyncClient,
-    base_muette: None,
-) -> None:
-    connecte(principal(Role.ADMIN, must_change_password=True))
-    laissees_passer: list[tuple[str, str, int]] = []
-
-    for methode, chemin in ROLE_MINIMUM:
-        response = await appelle(client, methode, chemin)
-        if motif_du_refus(response) != REFUS_DE_MOT_DE_PASSE:
-            laissees_passer.append((methode, chemin, response.status_code))
-
-    assert laissees_passer == []
-
-
-@pytest.fixture
-async def comptes_par_role() -> AsyncIterator[dict[Role, str]]:
-    marque = uuid.uuid4().hex[:12]
-    hacheur = build_hasher(time_cost=1, memory_cost_kib=8192, parallelism=1, max_concurrency=2)
-    empreinte = await hacheur.hash(MOT_DE_PASSE)
-    adresses = {role: f"matrice-{marque}-{role.value}@enervision.fr" for role in ROLES}
-
-    async with get_session_factory()() as session:
-        depot = UserRepository(session)
-        for role, email in adresses.items():
-            await depot.create(email=email, password_hash=empreinte, role=role)
-        await session.commit()
-
-    yield adresses
-
-    async with get_session_factory()() as session:
-        await session.execute(
-            text("delete from app_user where email like :motif"), {"motif": f"matrice-{marque}-%"}
-        )
-        await session.commit()
-
-
-async def authentifie(client: AsyncClient, email: str) -> dict[str, str]:
-    reponse = await client.post(
-        "/api/v1/auth/login", json={"email": email, "password": MOT_DE_PASSE}
-    )
-    assert reponse.status_code == 200, reponse.text
-    return {"Authorization": f"Bearer {reponse.json()['access_token']}"}
-
-
-@pytest.mark.integration
-@pytest.mark.parametrize("role", ROLES, ids=IDS_DE_ROLE)
-async def test_a_real_token_reaches_exactly_the_routes_of_its_rank(
-    comptes_par_role: dict[Role, str], client: AsyncClient, role: Role
-) -> None:
-    entetes = await authentifie(client, comptes_par_role[role])
-    ecarts: list[tuple[str, str, int, str]] = []
-
-    for (methode, chemin), minimum in ROLE_MINIMUM.items():
-        response = await appelle(client, methode, chemin, headers=entetes)
-        refuse = motif_du_refus(response) == REFUS_DE_DROITS
-        if refuse is has_at_least(role, minimum):
-            ecarts.append((methode, chemin, response.status_code, response.text[:120]))
-
-    assert ecarts == []
-
-
-# Contrainte : `operateur` n'ouvre aujourd'hui aucune route de plus que `lecteur`, faute d'écriture
-# métier dans l'API. Figer l'égalité rend la régression visible le jour où une route d'opérateur
-# arrive sans que `ROLE_MINIMUM` soit mis à jour.
-@pytest.mark.integration
-async def test_the_operator_rank_opens_nothing_more_than_the_reader_rank(
-    comptes_par_role: dict[Role, str], client: AsyncClient
-) -> None:
-    lecteur = await authentifie(client, comptes_par_role[Role.LECTEUR])
-    operateur = await authentifie(client, comptes_par_role[Role.OPERATEUR])
-    divergences: list[tuple[str, str]] = []
-
-    for methode, chemin in ROLE_MINIMUM:
-        cote_lecteur = await appelle(client, methode, chemin, headers=lecteur)
-        cote_operateur = await appelle(client, methode, chemin, headers=operateur)
-        if cote_lecteur.status_code != cote_operateur.status_code:
-            divergences.append((methode, chemin))
-
-    assert divergences == []
-
-
-# Piège : `/auth/logout-all` prend un `CurrentPrincipalDep` nu, donc elle échappe au gate
-# `must_change_password` que seul `require_role` applique. Comportement figé ici, pas corrigé.
-@pytest.mark.integration
-async def test_a_temporary_password_blocks_the_business_routes_but_not_logout_all(
-    client: AsyncClient,
-) -> None:
-    marque = uuid.uuid4().hex[:12]
-    email = f"matrice-{marque}-provisoire@enervision.fr"
-    hacheur = build_hasher(time_cost=1, memory_cost_kib=8192, parallelism=1, max_concurrency=2)
-    empreinte = await hacheur.hash(MOT_DE_PASSE)
-
-    async with get_session_factory()() as session:
-        await UserRepository(session).create(
-            email=email, password_hash=empreinte, role=Role.ADMIN, must_change_password=True
-        )
-        await session.commit()
-
-    try:
-        entetes = await authentifie(client, email)
-        sites = await client.get("/api/v1/sites", headers=entetes)
-        identite = await client.get("/api/v1/auth/me", headers=entetes)
-        fermeture = await client.post("/api/v1/auth/logout-all", headers=entetes)
-
-        assert motif_du_refus(sites) == REFUS_DE_MOT_DE_PASSE
-        assert identite.status_code == 200
-        assert fermeture.status_code == 204
-    finally:
-        async with get_session_factory()() as session:
-            await session.execute(text("delete from app_user where email = :e"), {"e": email})
-            await session.commit()

apps/backend/tests/api/test_openapi.py

@@ -8,7 +8,6 @@ from typing import Any
 import pytest
 
 from app import cli
-from tests.api.acces import ROLE_MINIMUM
 
 METHODES = {"get", "post", "patch", "put", "delete"}
 
@@ -25,11 +24,21 @@ ORIGINE_VERIFIEE = {
 
 # Toute route derrière `require_role` (LecteurDep, OperateurDep, AdminDep) peut rendre 403 pour
 # `password_change_required`, pas seulement les routes `admin`.
-# Piège : cette liste était recopiée ici, et deux de ses entrées portaient `{id}` là où le contrat
-# expose `{user_id}`. Elles ne correspondaient donc à aucune opération, et le test ci-dessous
-# passait au vert sans rien vérifier sur ces deux routes. Elle est maintenant dérivée, et
-# `test_every_declared_route_is_classified` interdit l'entrée morte.
-ROUTES_A_ROLE = frozenset(ROLE_MINIMUM)
+ROUTES_A_ROLE = {
+    ("GET", "/api/v1/users"),
+    ("POST", "/api/v1/users"),
+    ("PATCH", "/api/v1/users/{id}"),
+    ("POST", "/api/v1/users/{id}/password-reset"),
+    ("GET", "/api/v1/sites"),
+    ("GET", "/api/v1/sites/{site_id}"),
+    ("GET", "/api/v1/sites/{site_id}/current"),
+    ("GET", "/api/v1/alerts"),
+    ("GET", "/api/v1/recommendations"),
+    ("GET", "/api/v1/recommendations/{recommendation_id}"),
+    ("GET", "/api/v1/stats/summary"),
+    ("GET", "/api/v1/readings"),
+    ("GET", "/api/v1/sensors/status"),
+}
 
 
 @pytest.fixture(scope="module")

apps/backend/tests/api/test_predictions.py

@@ -1,85 +0,0 @@
-from collections.abc import Callable, Iterator
-from datetime import UTC, datetime
-from uuid import uuid4
-
-import pytest
-from fastapi import FastAPI
-from httpx import AsyncClient
-
-from app.api.deps import get_current_principal, get_prediction_service
-from app.core.principal import Principal
-from app.core.roles import AccountKind, Role
-from app.services.prediction import PredictionSummary, SitePrediction, SitePredictionSummary
-
-TARGET_AT = datetime(2026, 9, 16, 13, 0, tzinfo=UTC)
-CREATED_AT = datetime(2026, 9, 16, 12, 0, tzinfo=UTC)
-
-
-def lecteur() -> Principal:
-    # Le garde-fou de rôle (`lecteur` minimum) est déjà couvert par l'ensemble `ROUTES_A_ROLE`
-    # de `tests/api/test_openapi.py` : pas besoin ici d'un paramètre de rôle jamais appelé avec
-    # autre chose que sa valeur par défaut.
-    return Principal(
-        id=uuid4(),
-        email="lecteur@enervision.fr",
-        role=Role.LECTEUR,
-        kind=AccountKind.HUMAIN,
-        must_change_password=False,
-    )
-
-
-class FauxService:
-    def __init__(self) -> None:
-        self.resume = PredictionSummary(
-            timestamp=datetime.now(UTC),
-            sites=[
-                SitePredictionSummary(
-                    site_id="SITE001",
-                    site_name="Bureau Paris La Défense",
-                    prediction=SitePrediction(
-                        target_at=TARGET_AT,
-                        target_metric="consumption_kwh",
-                        period_minutes=60,
-                        predicted_value=812.5,
-                        status="available",
-                        failure_reason=None,
-                        model_reference="lightgbm-abc123",
-                        created_at=CREATED_AT,
-                    ),
-                ),
-                SitePredictionSummary(site_id="SITE002", site_name="Usine Lyon", prediction=None),
-            ],
-        )
-
-    async def summary(self) -> PredictionSummary:
-        return self.resume
-
-
-@pytest.fixture
-def servi(app: FastAPI) -> Iterator[Callable[[], FauxService]]:
-    def installe() -> FauxService:
-        service = FauxService()
-        app.dependency_overrides[get_prediction_service] = lambda: service
-        app.dependency_overrides[get_current_principal] = lambda: lecteur()
-        return service
-
-    yield installe
-    app.dependency_overrides.pop(get_prediction_service, None)
-    app.dependency_overrides.pop(get_current_principal, None)
-
-
-async def test_get_predictions_returns_the_service_result(
-    servi: Callable[[], FauxService], client: AsyncClient
-) -> None:
-    servi()
-
-    response = await client.get("/api/v1/predictions")
-
-    assert response.status_code == 200
-    corps = response.json()
-    premier, second = corps["sites"]
-    assert premier["site_id"] == "SITE001"
-    assert premier["prediction"]["predicted_value"] == 812.5
-    assert premier["prediction"]["status"] == "available"
-    assert second["site_id"] == "SITE002"
-    assert second["prediction"] is None

apps/backend/tests/api/test_recommendations.py

@@ -10,7 +10,7 @@ from app.api.deps import get_current_principal, get_recommendation_service
 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role
 from app.models.energy import Recommendation
-from app.services.recommendation import RapportGeneration, RecommendationNotFoundError
+from app.services.recommendation import RecommendationNotFoundError
 
 MOMENT = datetime(2024, 1, 1, tzinfo=UTC)
 
@@ -40,7 +40,6 @@ class FauxService:
     def __init__(self, erreur: Exception | None = None) -> None:
         self._erreur = erreur
         self.recommendation = recommendation()
-        self.site_demande: str | None = None
 
     async def list_all(self) -> list[Recommendation]:
         return [self.recommendation]
@@ -50,10 +49,6 @@ class FauxService:
             raise self._erreur
         return self.recommendation
 
-    async def generate(self, *, site_id: str | None = None) -> RapportGeneration:
-        self.site_demande = site_id
-        return RapportGeneration(alertes_examinees=2, recommandations_creees=3, deja_presentes=1)
-
 
 @pytest.fixture
 def lecteur_connecte(app: FastAPI) -> Iterator[None]:
@@ -147,56 +142,3 @@ async def test_get_recommendation_returns_404_when_the_session_finds_nothing(
     response = await client.get("/api/v1/recommendations/404")
 
     assert response.status_code == 404
-
-
-@pytest.fixture
-def admin_connecte(app: FastAPI) -> Iterator[None]:
-    app.dependency_overrides[get_current_principal] = lambda: principal(Role.ADMIN)
-    yield
-    app.dependency_overrides.pop(get_current_principal, None)
-
-
-@pytest.fixture
-def servi_en_admin(app: FastAPI, admin_connecte: None) -> Iterator[Callable[[], FauxService]]:
-    def installe() -> FauxService:
-        service = FauxService()
-        app.dependency_overrides[get_recommendation_service] = lambda: service
-        return service
-
-    yield installe
-    app.dependency_overrides.pop(get_recommendation_service, None)
-
-
-async def test_generate_recommendations_returns_the_generation_report(
-    servi_en_admin: Callable[[], FauxService], client: AsyncClient
-) -> None:
-    servi_en_admin()
-
-    response = await client.post("/api/v1/recommendations/generate")
-
-    assert response.status_code == 200
-    assert response.json() == {
-        "alerts_examined": 2,
-        "recommendations_created": 3,
-        "already_present": 1,
-    }
-
-
-async def test_generate_recommendations_forwards_the_requested_site(
-    servi_en_admin: Callable[[], FauxService], client: AsyncClient
-) -> None:
-    service = servi_en_admin()
-
-    await client.post("/api/v1/recommendations/generate", params={"site_id": "SITE002"})
-
-    assert service.site_demande == "SITE002"
-
-
-async def test_generate_recommendations_refuses_a_reader(
-    servi: Callable[..., FauxService], client: AsyncClient
-) -> None:
-    servi()
-
-    response = await client.post("/api/v1/recommendations/generate")
-
-    assert response.status_code == 403

apps/backend/tests/api/test_route_protection.py

@@ -1,6 +1,6 @@
 # Ce test est le garde-fou de l'autorisation : rendre une route publique oblige à modifier
-# `ROUTES_PUBLIQUES` dans `tests/api/acces.py`, ce qui apparaît en clair dans la diff d'une pull
-# request et demande une justification au relecteur.
+# `ROUTES_PUBLIQUES` ci-dessous, ce qui apparaît en clair dans la diff d'une pull request et
+# demande une justification au relecteur.
 # Pourquoi : il interroge réellement chaque route sans jeton au lieu d'inspecter l'arbre de
 # dépendances. L'arbre n'est accessible que par l'API privée de FastAPI, et surtout une route
 # peut porter la bonne dépendance tout en répondant quand même.
@@ -11,64 +11,58 @@ import pytest
 from fastapi import FastAPI
 from httpx import AsyncClient
 
-from tests.api.acces import (
-    ROLE_MINIMUM,
-    ROUTE_COOKIE,
-    ROUTES_PUBLIQUES,
-    ROUTES_SANS_ROLE,
-    Route,
-    chemin_concret,
-    routes_du_schema,
+ROUTES_PUBLIQUES = frozenset(
+    {
+        ("GET", "/api/v1/health/live"),
+        ("GET", "/api/v1/health/ready"),
+        ("POST", "/api/v1/auth/login"),
+        # Sans cookie, la déconnexion ne fait rien et répond 204 : elle est idempotente.
+        ("POST", "/api/v1/auth/logout"),
+        ("POST", "/api/v1/auth/forgot-password"),
+        # Protégée par le jeton dans le corps de la requête, pas par un `Principal` : aucune
+        # authentification préalable ne s'applique, c'est la validité du jeton qui tranche.
+        ("POST", "/api/v1/auth/reset-password"),
+        # Même raison : lecture seule, protégée par le jeton passé en paramètre, pas par un
+        # `Principal`. Le jeton est un secret de 256 bits, non brute-forçable.
+        ("GET", "/api/v1/auth/reset-password/validate"),
+        ("GET", "/metrics"),
+    }
 )
 
+VALEURS_DE_SUBSTITUTION = "00000000-0000-0000-0000-000000000000"
 STATUTS_DE_REFUS = {401, 403}
-HORS_SCHEMA = {("GET", "/metrics")}
 
 
-def routes_declarees(app: FastAPI) -> list[Route]:
+def routes_declarees(app: FastAPI) -> list[tuple[str, str]]:
     schema: dict[str, Any] = app.openapi()
-    return routes_du_schema(schema)
+    return [
+        (methode.upper(), chemin)
+        for chemin, operations in schema["paths"].items()
+        for methode in operations
+        if methode.upper() in {"GET", "POST", "PATCH", "PUT", "DELETE"}
+    ]
 
 
-def routes_protegees(app: FastAPI) -> list[Route]:
+def routes_protegees(app: FastAPI) -> list[tuple[str, str]]:
     return [route for route in routes_declarees(app) if route not in ROUTES_PUBLIQUES]
 
 
 def test_the_public_allow_list_has_no_stale_entry(app: FastAPI) -> None:
-    declarees = set(routes_declarees(app)) | HORS_SCHEMA
+    declarees = set(routes_declarees(app)) | {("GET", "/metrics")}
 
     inconnues = ROUTES_PUBLIQUES - declarees
 
     assert inconnues == set()
 
 
-# Sans lui, une route ajoutée sans être classée n'est vue par aucun test de rôle : elle hérite
-# du seul contrôle anonyme, et une garde posée au mauvais niveau passe inaperçue.
-def test_every_declared_route_is_classified(app: FastAPI) -> None:
-    classees = ROUTES_PUBLIQUES | ROUTE_COOKIE | ROUTES_SANS_ROLE | set(ROLE_MINIMUM)
-
-    non_classees = set(routes_declarees(app)) - classees
-    fantomes = classees - set(routes_declarees(app)) - HORS_SCHEMA
-
-    assert non_classees == set(), "classer la route dans tests/api/acces.py"
-    assert fantomes == set(), "entrée morte : la route n'existe plus sous ce chemin"
-
-
-def test_the_four_classes_of_routes_stay_disjoint() -> None:
-    classes = [ROUTES_PUBLIQUES, ROUTE_COOKIE, ROUTES_SANS_ROLE, frozenset(ROLE_MINIMUM)]
-
-    for rang, classe in enumerate(classes):
-        for autre in classes[rang + 1 :]:
-            assert classe & autre == frozenset()
-
-
 async def test_every_route_rejects_an_anonymous_caller_unless_explicitly_public(
     app: FastAPI, client: AsyncClient
 ) -> None:
     ouvertes: list[tuple[str, str, int]] = []
 
     for methode, chemin in routes_protegees(app):
-        response = await client.request(methode, chemin_concret(chemin), json={})
+        concret = chemin.replace("{user_id}", VALEURS_DE_SUBSTITUTION)
+        response = await client.request(methode, concret, json={})
         if response.status_code not in STATUTS_DE_REFUS:
             ouvertes.append((methode, chemin, response.status_code))
 
@@ -101,5 +95,4 @@ async def test_the_documentation_routes_are_public_by_design(
     app: FastAPI, client: AsyncClient, chemin: str
 ) -> None:
     response = await client.get(chemin)
-
     assert response.status_code == 200

apps/backend/tests/db/test_data_schema.py

@@ -112,10 +112,8 @@ async def test_duplicate_reading_is_rejected_when_key_matches(
     )
     await data_connection.execute(statement)
 
-    savepoint = data_connection.begin_nested()
-
     with pytest.raises(IntegrityError):
-        async with savepoint:
+        async with data_connection.begin_nested():
             await data_connection.execute(statement)
 
 
@@ -149,12 +147,9 @@ async def test_invalid_reading_is_rejected_when_constraints_fail(
     }
     values.update(changes)
 
-    statement = insert(Reading).values(**values)
-    savepoint = data_connection.begin_nested()
-
     with pytest.raises(IntegrityError):
-        async with savepoint:
-            await data_connection.execute(statement)
+        async with data_connection.begin_nested():
+            await data_connection.execute(insert(Reading).values(**values))
 
 
 async def test_prediction_requires_period_when_energy_is_predicted(
@@ -169,10 +164,8 @@ async def test_prediction_requires_period_when_energy_is_predicted(
         model_reference="test-model/1",
     )
 
-    savepoint = data_connection.begin_nested()
-
     with pytest.raises(IntegrityError):
-        async with savepoint:
+        async with data_connection.begin_nested():
             await data_connection.execute(statement)
 
 
@@ -219,22 +212,21 @@ async def test_alert_rejects_prediction_when_site_differs(
         )
     ).scalar_one()
 
-    statement = insert(Alert).values(
-        source_alert_id=str(uuid4()),
-        site_id=other_site,
-        source="enervision",
-        timestamp=MOMENT,
-        type="spike",
-        severity="high",
-        message="Test",
-        prediction_id=prediction_id,
-        raw_data={},
-    )
-    savepoint = data_connection.begin_nested()
-
     with pytest.raises(IntegrityError):
-        async with savepoint:
-            await data_connection.execute(statement)
+        async with data_connection.begin_nested():
+            await data_connection.execute(
+                insert(Alert).values(
+                    source_alert_id=str(uuid4()),
+                    site_id=other_site,
+                    source="enervision",
+                    timestamp=MOMENT,
+                    type="spike",
+                    severity="high",
+                    message="Test",
+                    prediction_id=prediction_id,
+                    raw_data={},
+                )
+            )
 
 
 async def test_recommendation_is_unique_when_alert_and_rule_match(
@@ -264,8 +256,6 @@ async def test_recommendation_is_unique_when_alert_and_rule_match(
     )
     await data_connection.execute(statement)
 
-    savepoint = data_connection.begin_nested()
-
     with pytest.raises(IntegrityError):
-        async with savepoint:
+        async with data_connection.begin_nested():
             await data_connection.execute(statement)

apps/backend/tests/etl/test_historical_import.py

@@ -1,245 +1,239 @@
-import hashlib
-import json
-
-import pandas as pd
-import pytest
-
-from app.etl.historical_import import (
-    SOURCE_NAME,
-    build_reading_batch,
-    classify_quality,
-    compute_sha256,
-    load_metadata,
-    normalize_timestamps,
-    validate_source,
-)
-
-
-def make_metadata() -> dict:
-    return {
-        "total_records": 2,
-        "sites": {
-            "SITE001": {},
-        },
-    }
-
-
-def make_dataframe() -> pd.DataFrame:
-    return pd.DataFrame(
-        [
-            {
-                "timestamp": "2023-01-01 00:00:00",
-                "site_id": "SITE001",
-                "site_type": "office",
-                "site_name": "Site 1",
-                "consumption_kwh": 10.5,
-                "consumption_euros": 2.5,
-                "temperature_celsius": 20.0,
-                "humidity_percent": 50.0,
-                "solar_irradiance_wm2": 0.0,
-                "hour": 0,
-                "day_of_week": 6,
-                "day_name": "Sunday",
-                "month": 1,
-                "is_weekend": True,
-                "is_working_hours": False,
-            },
-            {
-                "timestamp": "2023-01-01 01:00:00",
-                "site_id": "SITE001",
-                "site_type": "office",
-                "site_name": "Site 1",
-                "consumption_kwh": 11.0,
-                "consumption_euros": 2.7,
-                "temperature_celsius": 19.5,
-                "humidity_percent": 52.0,
-                "solar_irradiance_wm2": 0.0,
-                "hour": 1,
-                "day_of_week": 6,
-                "day_name": "Sunday",
-                "month": 1,
-                "is_weekend": True,
-                "is_working_hours": False,
-            },
-        ]
-    )
-
-
-def test_compute_sha256(tmp_path):
-    file_path = tmp_path / "dataset.csv"
-    content = b"hello-enervision"
-
-    file_path.write_bytes(content)
-
-    expected = hashlib.sha256(content).hexdigest()
-
-    assert compute_sha256(file_path) == expected
-
-
-def test_load_metadata(tmp_path):
-    metadata_path = tmp_path / "metadata.json"
-
-    metadata = {
-        "total_records": 2,
-        "sites": {
-            "SITE001": {},
-        },
-    }
-
-    metadata_path.write_text(
-        json.dumps(metadata),
-        encoding="utf-8",
-    )
-
-    assert load_metadata(metadata_path) == metadata
-
-
-def test_validate_source_accepts_valid_dataset():
-    frame = make_dataframe()
-
-    validate_source(
-        frame,
-        make_metadata(),
-    )
-
-
-def test_validate_source_rejects_missing_column():
-    frame = make_dataframe().drop(columns=["consumption_kwh"])
-
-    metadata = make_metadata()
-
-    with pytest.raises(
-        ValueError,
-        match="Colonnes obligatoires absentes",
-    ):
-        validate_source(
-            frame,
-            metadata,
-        )
-
-
-def test_validate_source_rejects_duplicates():
-    frame = make_dataframe()
-
-    frame.loc[1, "timestamp"] = frame.loc[
-        0,
-        "timestamp",
-    ]
-
-    metadata = make_metadata()
-
-    with pytest.raises(
-        ValueError,
-        match="doublons",
-    ):
-        validate_source(
-            frame,
-            metadata,
-        )
-
-
-def test_validate_source_rejects_unknown_site():
-    frame = make_dataframe()
-
-    frame.loc[1, "site_id"] = "SITE999"
-
-    metadata = make_metadata()
-
-    with pytest.raises(
-        ValueError,
-        match="Sites incohérents",
-    ):
-        validate_source(
-            frame,
-            metadata,
-        )
-
-
-def test_normalize_timestamps_adds_timezone():
-    frame = make_dataframe()
-
-    normalized = normalize_timestamps(
-        frame,
-        "UTC",
-    )
-
-    assert normalized["timestamp"].dt.tz is not None
-
-    assert "_source_timestamp" in normalized.columns
-
-
-def test_classify_quality_good():
-    row = make_dataframe().iloc[0].to_dict()
-
-    quality, reasons = classify_quality(row)
-
-    assert quality == "good"
-    assert reasons == []
-
-
-def test_classify_quality_degraded_when_consumption_missing():
-    row = make_dataframe().iloc[0].to_dict()
-    row["consumption_kwh"] = None
-
-    quality, reasons = classify_quality(row)
-
-    assert quality == "degraded"
-
-    assert "missing:consumption_kwh" in reasons
-
-
-def test_build_reading_batch_respects_database_contract():
-    frame = normalize_timestamps(
-        make_dataframe(),
-        "UTC",
-    )
-
-    rows = build_reading_batch(
-        frame.iloc[:1],
-        dataset_id=3,
-    )
-
-    assert len(rows) == 1
-
-    row = rows[0]
-
-    assert row["dataset_id"] == 3
-
-    # Important :
-    # contrainte ck_reading_dataset_source.
-    assert row["source"] == "csv"
-    assert SOURCE_NAME == "csv"
-
-    # Important :
-    # contrainte ck_reading_imputation.
-    assert row["imputed_values"] is None
-    assert row["imputation_method"] is None
-
-    assert row["data_quality"] == "good"
-    assert row["null_reasons"] == []
-
-
-def test_build_reading_batch_keeps_missing_values():
-    frame = make_dataframe()
-
-    frame.loc[0, "temperature_celsius"] = None
-
-    frame = normalize_timestamps(
-        frame,
-        "UTC",
-    )
-
-    rows = build_reading_batch(
-        frame.iloc[:1],
-        dataset_id=3,
-    )
-
-    row = rows[0]
-
-    assert row["temperature_celsius"] is None
-
-    assert "missing:temperature_celsius" in row["null_reasons"]
-
-    # RAW ingestion : aucune imputation.
-    assert row["imputed_values"] is None
-    assert row["imputation_method"] is None
+import hashlib
+import json
+
+import pandas as pd
+import pytest
+
+from app.etl.historical_import import (
+    SOURCE_NAME,
+    build_reading_batch,
+    classify_quality,
+    compute_sha256,
+    load_metadata,
+    normalize_timestamps,
+    validate_source,
+)
+
+
+def make_metadata() -> dict:
+    return {
+        "total_records": 2,
+        "sites": {
+            "SITE001": {},
+        },
+    }
+
+
+def make_dataframe() -> pd.DataFrame:
+    return pd.DataFrame(
+        [
+            {
+                "timestamp": "2023-01-01 00:00:00",
+                "site_id": "SITE001",
+                "site_type": "office",
+                "site_name": "Site 1",
+                "consumption_kwh": 10.5,
+                "consumption_euros": 2.5,
+                "temperature_celsius": 20.0,
+                "humidity_percent": 50.0,
+                "solar_irradiance_wm2": 0.0,
+                "hour": 0,
+                "day_of_week": 6,
+                "day_name": "Sunday",
+                "month": 1,
+                "is_weekend": True,
+                "is_working_hours": False,
+            },
+            {
+                "timestamp": "2023-01-01 01:00:00",
+                "site_id": "SITE001",
+                "site_type": "office",
+                "site_name": "Site 1",
+                "consumption_kwh": 11.0,
+                "consumption_euros": 2.7,
+                "temperature_celsius": 19.5,
+                "humidity_percent": 52.0,
+                "solar_irradiance_wm2": 0.0,
+                "hour": 1,
+                "day_of_week": 6,
+                "day_name": "Sunday",
+                "month": 1,
+                "is_weekend": True,
+                "is_working_hours": False,
+            },
+        ]
+    )
+
+
+def test_compute_sha256(tmp_path):
+    file_path = tmp_path / "dataset.csv"
+    content = b"hello-enervision"
+
+    file_path.write_bytes(content)
+
+    expected = hashlib.sha256(content).hexdigest()
+
+    assert compute_sha256(file_path) == expected
+
+
+def test_load_metadata(tmp_path):
+    metadata_path = tmp_path / "metadata.json"
+
+    metadata = {
+        "total_records": 2,
+        "sites": {
+            "SITE001": {},
+        },
+    }
+
+    metadata_path.write_text(
+        json.dumps(metadata),
+        encoding="utf-8",
+    )
+
+    assert load_metadata(metadata_path) == metadata
+
+
+def test_validate_source_accepts_valid_dataset():
+    frame = make_dataframe()
+
+    validate_source(
+        frame,
+        make_metadata(),
+    )
+
+
+def test_validate_source_rejects_missing_column():
+    frame = make_dataframe().drop(columns=["consumption_kwh"])
+
+    with pytest.raises(
+        ValueError,
+        match="Colonnes obligatoires absentes",
+    ):
+        validate_source(
+            frame,
+            make_metadata(),
+        )
+
+
+def test_validate_source_rejects_duplicates():
+    frame = make_dataframe()
+
+    frame.loc[1, "timestamp"] = frame.loc[
+        0,
+        "timestamp",
+    ]
+
+    with pytest.raises(
+        ValueError,
+        match="doublons",
+    ):
+        validate_source(
+            frame,
+            make_metadata(),
+        )
+
+
+def test_validate_source_rejects_unknown_site():
+    frame = make_dataframe()
+
+    frame.loc[1, "site_id"] = "SITE999"
+
+    with pytest.raises(
+        ValueError,
+        match="Sites incohérents",
+    ):
+        validate_source(
+            frame,
+            make_metadata(),
+        )
+
+
+def test_normalize_timestamps_adds_timezone():
+    frame = make_dataframe()
+
+    normalized = normalize_timestamps(
+        frame,
+        "UTC",
+    )
+
+    assert normalized["timestamp"].dt.tz is not None
+
+    assert "_source_timestamp" in normalized.columns
+
+
+def test_classify_quality_good():
+    row = make_dataframe().iloc[0].to_dict()
+
+    quality, reasons = classify_quality(row)
+
+    assert quality == "good"
+    assert reasons == []
+
+
+def test_classify_quality_degraded_when_consumption_missing():
+    row = make_dataframe().iloc[0].to_dict()
+    row["consumption_kwh"] = None
+
+    quality, reasons = classify_quality(row)
+
+    assert quality == "degraded"
+
+    assert "missing:consumption_kwh" in reasons
+
+
+def test_build_reading_batch_respects_database_contract():
+    frame = normalize_timestamps(
+        make_dataframe(),
+        "UTC",
+    )
+
+    rows = build_reading_batch(
+        frame.iloc[:1],
+        dataset_id=3,
+    )
+
+    assert len(rows) == 1
+
+    row = rows[0]
+
+    assert row["dataset_id"] == 3
+
+    # Important :
+    # contrainte ck_reading_dataset_source.
+    assert row["source"] == "csv"
+    assert SOURCE_NAME == "csv"
+
+    # Important :
+    # contrainte ck_reading_imputation.
+    assert row["imputed_values"] is None
+    assert row["imputation_method"] is None
+
+    assert row["data_quality"] == "good"
+    assert row["null_reasons"] == []
+
+
+def test_build_reading_batch_keeps_missing_values():
+    frame = make_dataframe()
+
+    frame.loc[0, "temperature_celsius"] = None
+
+    frame = normalize_timestamps(
+        frame,
+        "UTC",
+    )
+
+    rows = build_reading_batch(
+        frame.iloc[:1],
+        dataset_id=3,
+    )
+
+    row = rows[0]
+
+    assert row["temperature_celsius"] is None
+
+    assert "missing:temperature_celsius" in row["null_reasons"]
+
+    # RAW ingestion : aucune imputation.
+    assert row["imputed_values"] is None
+    assert row["imputation_method"] is None

apps/backend/tests/etl/test_mock_api_import.py

@@ -1,834 +0,0 @@
-import json
-import sys
-from datetime import datetime
-from types import SimpleNamespace
-from typing import Any
-from unittest.mock import AsyncMock, MagicMock
-
-import httpx
-import pytest
-from httpx import AsyncClient, MockTransport, Request, Response
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession
-
-import app.etl.mock_api_import as mock_api_import
-from app.etl.mock_api_import import (
-    MAX_SITES,
-    READING_INSERT,
-    SOURCE_HISTORY,
-    build_reading_batch,
-    build_reading_row,
-    build_site_row,
-    fetch_readings,
-    fetch_sites,
-    upsert_sites,
-)
-
-
-def make_site() -> dict[str, Any]:
-    return {
-        "site_id": "SITE001",
-        "site_type": "office",
-        "site_name": "Bureau Paris La Défense",
-        "location": "Paris, France",
-        "capacity_kw": 200,
-        "status": "active",
-    }
-
-
-def make_reading() -> dict[str, Any]:
-    return {
-        "timestamp": "2024-06-15T12:00:00Z",
-        "site_id": "SITE001",
-        "site_type": "office",
-        "consumption_kw": 87.34,
-        "consumption_kwh": 87.34,
-        "voltage_v": 401.2,
-        "current_a": 132.5,
-        "power_factor": 0.923,
-        "temperature_celsius": 22.1,
-        "humidity_percent": 58.4,
-        "null_reasons": [],
-        "data_quality": "good",
-    }
-
-
-async def test_fetch_sites_returns_sites() -> None:
-    def handler(request: Request) -> Response:
-        assert request.url.path == "/api/v1/sites"
-
-        return Response(
-            status_code=200,
-            json=[make_site()],
-        )
-
-    transport = MockTransport(handler)
-
-    async with AsyncClient(
-        transport=transport,
-        base_url="https://mock.test",
-    ) as client:
-        sites = await fetch_sites(client)
-
-    assert len(sites) == 1
-    assert sites[0]["site_id"] == "SITE001"
-    assert sites[0]["site_type"] == "office"
-
-
-async def test_fetch_sites_rejects_non_list_response() -> None:
-    def handler(request: Request) -> Response:
-        return Response(
-            status_code=200,
-            json={"unexpected": "payload"},
-        )
-
-    transport = MockTransport(handler)
-
-    async with AsyncClient(
-        transport=transport,
-        base_url="https://mock.test",
-    ) as client:
-        with pytest.raises(
-            ValueError,
-            match="La réponse /api/v1/sites doit être une liste",
-        ):
-            await fetch_sites(client)
-
-
-async def test_fetch_readings_sends_expected_query_parameters() -> None:
-    captured_params: dict[str, str] = {}
-
-    def handler(request: Request) -> Response:
-        nonlocal captured_params
-
-        captured_params = dict(request.url.params)
-
-        return Response(
-            status_code=200,
-            json=[make_reading()],
-        )
-
-    transport = MockTransport(handler)
-
-    start_time = datetime.fromisoformat("2024-06-15T12:00:00")
-    end_time = datetime.fromisoformat("2024-06-15T13:00:00")
-
-    async with AsyncClient(
-        transport=transport,
-        base_url="https://mock.test",
-    ) as client:
-        readings = await fetch_readings(
-            client=client,
-            site_id="SITE001",
-            start_time=start_time,
-            end_time=end_time,
-            limit=60,
-        )
-
-    assert len(readings) == 1
-    assert captured_params["site_id"] == "SITE001"
-    assert captured_params["start_time"] == "2024-06-15T12:00:00"
-    assert captured_params["end_time"] == "2024-06-15T13:00:00"
-    assert captured_params["limit"] == "60"
-
-
-async def test_fetch_readings_rejects_non_list_response() -> None:
-    def handler(request: Request) -> Response:
-        return Response(
-            status_code=200,
-            json={"unexpected": "payload"},
-        )
-
-    transport = MockTransport(handler)
-
-    async with AsyncClient(
-        transport=transport,
-        base_url="https://mock.test",
-    ) as client:
-        with pytest.raises(
-            ValueError,
-            match="La réponse /api/v1/readings doit être une liste",
-        ):
-            await fetch_readings(
-                client=client,
-                site_id="SITE001",
-                start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
-                end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
-                limit=60,
-            )
-
-
-async def test_fetch_readings_raises_on_http_error() -> None:
-    def handler(request: Request) -> Response:
-        return Response(
-            status_code=404,
-            json={"detail": "Site non trouvé"},
-        )
-
-    transport = MockTransport(handler)
-
-    async with AsyncClient(
-        transport=transport,
-        base_url="https://mock.test",
-    ) as client:
-        with pytest.raises(httpx.HTTPStatusError):
-            await fetch_readings(
-                client=client,
-                site_id="SITE999",
-                start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
-                end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
-                limit=60,
-            )
-
-
-def test_build_reading_row_respects_database_contract() -> None:
-    reading = make_reading()
-
-    row = build_reading_row(reading)
-
-    assert row["site_id"] == "SITE001"
-    assert row["source"] == SOURCE_HISTORY
-    assert row["source"] == "api_history"
-    assert row["dataset_id"] is None
-
-    assert row["timestamp"] == datetime.fromisoformat("2024-06-15T12:00:00+00:00")
-
-    assert row["consumption_kw"] == 87.34
-    assert row["consumption_kwh"] == 87.34
-    assert row["data_quality"] == "good"
-    assert row["null_reasons"] == []
-
-    assert row["imputed_values"] is None
-    assert row["imputation_method"] is None
-
-
-def test_build_reading_row_keeps_null_values_and_quality() -> None:
-    reading = make_reading()
-
-    reading["consumption_kw"] = None
-    reading["consumption_kwh"] = None
-    reading["voltage_v"] = None
-    reading["current_a"] = None
-    reading["power_factor"] = None
-    reading["data_quality"] = "degraded"
-    reading["null_reasons"] = [
-        "consumption_sensor_failure",
-        "electrical_sensor_failure",
-    ]
-
-    row = build_reading_row(reading)
-
-    assert row["consumption_kw"] is None
-    assert row["consumption_kwh"] is None
-    assert row["voltage_v"] is None
-    assert row["current_a"] is None
-    assert row["power_factor"] is None
-
-    assert row["data_quality"] == "degraded"
-    assert row["null_reasons"] == [
-        "consumption_sensor_failure",
-        "electrical_sensor_failure",
-    ]
-
-    assert row["imputed_values"] is None
-    assert row["imputation_method"] is None
-
-
-def test_build_reading_row_keeps_raw_source_data() -> None:
-    reading = make_reading()
-
-    row = build_reading_row(reading)
-
-    raw_data = json.loads(row["raw_data"])
-
-    assert raw_data == reading
-
-
-def test_build_reading_batch_transforms_all_readings() -> None:
-    first = make_reading()
-
-    second = make_reading()
-    second["timestamp"] = "2024-06-15T12:01:00Z"
-    second["consumption_kw"] = 90.5
-
-    rows = build_reading_batch([first, second])
-
-    assert len(rows) == 2
-
-    assert rows[0]["site_id"] == "SITE001"
-    assert rows[0]["consumption_kw"] == 87.34
-
-    assert rows[1]["site_id"] == "SITE001"
-    assert rows[1]["consumption_kw"] == 90.5
-
-
-def test_create_mock_api_client_requires_credentials(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    settings = SimpleNamespace(
-        mock_api_username=None,
-        mock_api_password=None,
-    )
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "get_settings",
-        lambda: settings,
-    )
-
-    with pytest.raises(
-        ValueError,
-        match="Les identifiants de l'API Mock ne sont pas configurés",
-    ):
-        mock_api_import.create_mock_api_client()
-
-
-async def test_create_mock_api_client_uses_configuration(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    password = MagicMock()
-    password.get_secret_value.return_value = "test-password"
-
-    settings = SimpleNamespace(
-        mock_api_base_url="https://mock.test/",
-        mock_api_username="test-user",
-        mock_api_password=password,
-        mock_api_timeout_seconds=10.0,
-    )
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "get_settings",
-        lambda: settings,
-    )
-
-    client = mock_api_import.create_mock_api_client()
-
-    try:
-        assert str(client.base_url) == "https://mock.test"
-        assert client.timeout.connect == 10.0
-    finally:
-        await client.aclose()
-
-
-async def test_upsert_sites_with_empty_list_does_nothing() -> None:
-    connection = AsyncMock()
-
-    await upsert_sites(
-        connection,
-        [],
-    )
-
-    connection.execute.assert_not_awaited()
-
-
-async def test_import_mock_api_history_dry_run_does_not_write(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    def handler(request: Request) -> Response:
-        if request.url.path == "/api/v1/sites":
-            return Response(
-                status_code=200,
-                json=[make_site()],
-            )
-
-        if request.url.path == "/api/v1/readings":
-            return Response(
-                status_code=200,
-                json=[make_reading()],
-            )
-
-        return Response(status_code=404)
-
-    transport = MockTransport(handler)
-
-    client = AsyncClient(
-        transport=transport,
-        base_url="https://mock.test",
-    )
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "create_mock_api_client",
-        lambda: client,
-    )
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "get_settings",
-        lambda: SimpleNamespace(
-            database_url="postgresql+asyncpg://unused",
-        ),
-    )
-
-    create_engine_mock = MagicMock()
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "create_async_engine",
-        create_engine_mock,
-    )
-
-    await mock_api_import.import_mock_api_history(
-        start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
-        end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
-        limit=60,
-        dry_run=True,
-    )
-
-    create_engine_mock.assert_not_called()
-
-
-async def test_import_mock_api_history_loads_data(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    def handler(request: Request) -> Response:
-        if request.url.path == "/api/v1/sites":
-            return Response(
-                status_code=200,
-                json=[make_site()],
-            )
-
-        if request.url.path == "/api/v1/readings":
-            return Response(
-                status_code=200,
-                json=[make_reading()],
-            )
-
-        return Response(status_code=404)
-
-    transport = MockTransport(handler)
-
-    client = AsyncClient(
-        transport=transport,
-        base_url="https://mock.test",
-    )
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "create_mock_api_client",
-        lambda: client,
-    )
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "get_settings",
-        lambda: SimpleNamespace(
-            database_url="postgresql+asyncpg://test:test@localhost/test",
-        ),
-    )
-
-    connection = AsyncMock()
-
-    transaction_context = MagicMock()
-    transaction_context.__aenter__ = AsyncMock(
-        return_value=connection,
-    )
-    transaction_context.__aexit__ = AsyncMock(
-        return_value=None,
-    )
-
-    engine = MagicMock()
-    engine.begin.return_value = transaction_context
-    engine.dispose = AsyncMock()
-
-    create_engine_mock = MagicMock(
-        return_value=engine,
-    )
-
-    upsert_sites_mock = AsyncMock()
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "create_async_engine",
-        create_engine_mock,
-    )
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "upsert_sites",
-        upsert_sites_mock,
-    )
-
-    await mock_api_import.import_mock_api_history(
-        start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
-        end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
-        limit=60,
-        dry_run=False,
-    )
-
-    create_engine_mock.assert_called_once_with(
-        "postgresql+asyncpg://test:test@localhost/test",
-        pool_pre_ping=True,
-    )
-
-    upsert_sites_mock.assert_awaited_once_with(
-        connection,
-        [make_site()],
-    )
-
-    connection.execute.assert_awaited_once()
-    engine.dispose.assert_awaited_once()
-
-
-def test_parse_datetime_accepts_z_suffix() -> None:
-    result = mock_api_import.parse_datetime(
-        "2024-06-15T12:00:00Z",
-    )
-
-    assert result == datetime.fromisoformat(
-        "2024-06-15T12:00:00+00:00",
-    )
-
-
-def test_parse_args_reads_cli_parameters(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        sys,
-        "argv",
-        [
-            "mock_api_import",
-            "--start-time",
-            "2024-06-15T12:00:00Z",
-            "--end-time",
-            "2024-06-15T13:00:00Z",
-            "--limit",
-            "60",
-            "--dry-run",
-        ],
-    )
-
-    args = mock_api_import.parse_args()
-
-    assert args.start_time == datetime.fromisoformat(
-        "2024-06-15T12:00:00+00:00",
-    )
-    assert args.end_time == datetime.fromisoformat(
-        "2024-06-15T13:00:00+00:00",
-    )
-    assert args.limit == 60
-    assert args.dry_run is True
-
-
-def test_main_rejects_limit_out_of_bounds(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        sys,
-        "argv",
-        [
-            "mock_api_import",
-            "--start-time",
-            "2024-06-15T12:00:00Z",
-            "--end-time",
-            "2024-06-15T13:00:00Z",
-            "--limit",
-            "0",
-        ],
-    )
-
-    with pytest.raises(
-        ValueError,
-        match="--limit doit être compris entre 1 et 1000",
-    ):
-        mock_api_import.main()
-
-
-def test_main_rejects_invalid_period(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        sys,
-        "argv",
-        [
-            "mock_api_import",
-            "--start-time",
-            "2024-06-15T14:00:00Z",
-            "--end-time",
-            "2024-06-15T13:00:00Z",
-            "--limit",
-            "60",
-        ],
-    )
-
-    with pytest.raises(
-        ValueError,
-        match="--start-time doit être antérieur à --end-time",
-    ):
-        mock_api_import.main()
-
-
-def test_main_runs_import(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    start_time = datetime.fromisoformat(
-        "2024-06-15T12:00:00+00:00",
-    )
-    end_time = datetime.fromisoformat(
-        "2024-06-15T13:00:00+00:00",
-    )
-
-    import_mock = AsyncMock()
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "parse_args",
-        lambda: SimpleNamespace(
-            start_time=start_time,
-            end_time=end_time,
-            limit=60,
-            dry_run=True,
-        ),
-    )
-
-    monkeypatch.setattr(
-        mock_api_import,
-        "import_mock_api_history",
-        import_mock,
-    )
-
-    mock_api_import.main()
-
-    import_mock.assert_awaited_once_with(
-        start_time=start_time,
-        end_time=end_time,
-        limit=60,
-        dry_run=True,
-    )
-
-
-async def test_fetch_sites_rejects_a_response_above_the_cap() -> None:
-    def handler(request: Request) -> Response:
-        return Response(
-            status_code=200,
-            json=[make_site() for _ in range(MAX_SITES + 1)],
-        )
-
-    transport = MockTransport(handler)
-
-    async with AsyncClient(
-        transport=transport,
-        base_url="https://mock.test",
-    ) as client:
-        with pytest.raises(
-            ValueError,
-            match=f"dépasse le plafond de {MAX_SITES} sites",
-        ):
-            await fetch_sites(client)
-
-
-async def test_fetch_readings_rejects_a_response_above_the_requested_limit() -> None:
-    def handler(request: Request) -> Response:
-        return Response(
-            status_code=200,
-            json=[make_reading(), make_reading(), make_reading()],
-        )
-
-    transport = MockTransport(handler)
-
-    async with AsyncClient(
-        transport=transport,
-        base_url="https://mock.test",
-    ) as client:
-        with pytest.raises(
-            ValueError,
-            match="dépasse la limite demandée de 2",
-        ):
-            await fetch_readings(
-                client=client,
-                site_id="SITE001",
-                start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
-                end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
-                limit=2,
-            )
-
-
-def test_build_reading_row_neutralises_values_outside_physical_bounds() -> None:
-    reading = make_reading()
-
-    reading["power_factor"] = 42.0
-    reading["temperature_celsius"] = 1e30
-    reading["humidity_percent"] = -1.0
-
-    row = build_reading_row(reading)
-
-    assert row["power_factor"] is None
-    assert row["temperature_celsius"] is None
-    assert row["humidity_percent"] is None
-
-    assert row["null_reasons"] == [
-        "out_of_physical_bounds:power_factor",
-        "out_of_physical_bounds:temperature_celsius",
-        "out_of_physical_bounds:humidity_percent",
-    ]
-
-    assert row["data_quality"] == "degraded"
-
-    assert json.loads(row["raw_data"])["power_factor"] == 42.0
-
-
-def test_build_reading_row_rejects_a_measure_that_is_not_a_number() -> None:
-    reading = make_reading()
-
-    reading["consumption_kw"] = "87.34"
-
-    row = build_reading_row(reading)
-
-    assert row["consumption_kw"] is None
-    assert "out_of_physical_bounds:consumption_kw" in row["null_reasons"]
-
-
-def test_build_reading_row_drops_a_quality_the_database_refuses() -> None:
-    reading = make_reading()
-
-    reading["data_quality"] = "unknown"
-
-    row = build_reading_row(reading)
-
-    assert row["data_quality"] is None
-
-
-def test_build_reading_row_requires_an_identifier() -> None:
-    reading = make_reading()
-
-    del reading["site_id"]
-
-    with pytest.raises(
-        ValueError,
-        match="Champ site_id absent ou invalide",
-    ):
-        build_reading_row(reading)
-
-
-def test_build_site_row_keeps_only_the_expected_columns() -> None:
-    site = make_site()
-
-    site["unexpected"] = "valeur hostile"
-    site["capacity_kw"] = -5.0
-    site["status"] = 12
-
-    row = build_site_row(site)
-
-    assert set(row) == {
-        "site_id",
-        "site_type",
-        "site_name",
-        "location",
-        "capacity_kw",
-        "status",
-    }
-
-    assert row["capacity_kw"] is None
-    assert row["status"] is None
-
-
-async def test_upsert_sites_sends_only_the_expected_columns() -> None:
-    connection = AsyncMock()
-
-    site = make_site()
-    site["unexpected"] = "valeur hostile"
-
-    await upsert_sites(
-        connection,
-        [site],
-    )
-
-    rows = connection.execute.await_args.args[1]
-
-    assert "unexpected" not in rows[0]
-    assert rows[0]["site_id"] == "SITE001"
-
-
-@pytest.mark.integration
-async def test_reading_insert_is_idempotent(
-    session: AsyncSession,
-) -> None:
-    reading = make_reading()
-    row = build_reading_row(reading)
-
-    connection = await session.connection()
-
-    await upsert_sites(
-        connection,
-        [make_site()],
-    )
-
-    await session.execute(
-        READING_INSERT,
-        [row],
-    )
-
-    await session.execute(
-        READING_INSERT,
-        [row],
-    )
-
-    result = await session.execute(
-        text(
-            """
-            SELECT COUNT(*)
-            FROM reading
-            WHERE site_id = :site_id
-              AND timestamp = :timestamp
-              AND source = :source
-            """
-        ),
-        {
-            "site_id": row["site_id"],
-            "timestamp": row["timestamp"],
-            "source": row["source"],
-        },
-    )
-
-    assert result.scalar_one() == 1
-
-    await session.rollback()
-
-
-@pytest.mark.integration
-async def test_out_of_bounds_reading_is_stored_neutralised(
-    session: AsyncSession,
-) -> None:
-    reading = make_reading()
-    reading["power_factor"] = 42.0
-
-    row = build_reading_row(reading)
-
-    connection = await session.connection()
-
-    await upsert_sites(
-        connection,
-        [make_site()],
-    )
-
-    await session.execute(
-        READING_INSERT,
-        [row],
-    )
-
-    result = await session.execute(
-        text(
-            """
-            SELECT power_factor, data_quality, null_reasons, raw_data ->> 'power_factor'
-            FROM reading
-            WHERE site_id = :site_id
-              AND timestamp = :timestamp
-              AND source = :source
-            """
-        ),
-        {
-            "site_id": row["site_id"],
-            "timestamp": row["timestamp"],
-            "source": row["source"],
-        },
-    )
-
-    stored = result.one()
-
-    await session.rollback()
-
-    assert stored[0] is None
-    assert stored[1] == "degraded"
-    assert stored[2] == ["out_of_physical_bounds:power_factor"]
-    assert stored[3] == "42.0"

apps/backend/tests/repositories/test_alert.py

@@ -5,7 +5,6 @@ import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.energy import Alert
-from app.repositories import alert as module_alert
 from app.repositories.alert import AlertRepository
 from app.schemas.alert import AlertSeverity
 from tests.repositories.test_site import creer as creer_site
@@ -90,77 +89,3 @@ async def test_list_all_returns_an_empty_list_when_there_is_nothing(
     alertes = await depot.list_all(site_id=identifiant_site())
 
     assert list(alertes) == []
-
-
-def _alerte_a_inserer(*, site_id: str, source_alert_id: str) -> Alert:
-    return Alert(
-        source_alert_id=source_alert_id,
-        site_id=site_id,
-        source="enervision",
-        timestamp=datetime(2026, 9, 16, tzinfo=UTC),
-        type="threshold",
-        severity="high",
-        message="Dépassement du seuil configuré",
-        value=812.5,
-        threshold=720.0,
-        metric="consumption_kw",
-        prediction_id=None,
-        raw_data={},
-    )
-
-
-async def test_create_many_inserts_every_alert(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = AlertRepository(session)
-
-    creees = await depot.create_many(
-        [
-            _alerte_a_inserer(site_id=site.site_id, source_alert_id="threshold:a"),
-            _alerte_a_inserer(site_id=site.site_id, source_alert_id="threshold:b"),
-        ]
-    )
-    identifiants = [a.alert_id for a in creees]
-    await session.rollback()
-
-    assert len(identifiants) == 2
-    assert all(identifiant is not None for identifiant in identifiants)
-
-
-async def test_create_many_skips_a_duplicate_source_alert_id(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = AlertRepository(session)
-    await depot.create_many(
-        [_alerte_a_inserer(site_id=site.site_id, source_alert_id="threshold:rejouee")]
-    )
-
-    rejouees = await depot.create_many(
-        [_alerte_a_inserer(site_id=site.site_id, source_alert_id="threshold:rejouee")]
-    )
-    await session.rollback()
-
-    assert rejouees == []
-
-
-async def test_create_many_does_nothing_for_an_empty_list(session: AsyncSession) -> None:
-    depot = AlertRepository(session)
-
-    creees = await depot.create_many([])
-
-    assert creees == []
-
-
-async def test_create_many_inserts_every_alert_across_several_batches(
-    session: AsyncSession, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    monkeypatch.setattr(module_alert, "TAILLE_DE_LOT", 2)
-    site = await creer_site(session)
-    depot = AlertRepository(session)
-    a_inserer = [
-        _alerte_a_inserer(site_id=site.site_id, source_alert_id=f"threshold:lot-{index}")
-        for index in range(5)
-    ]
-
-    creees = await depot.create_many(a_inserer)
-    await session.rollback()
-
-    assert len(creees) == 5

apps/backend/tests/repositories/test_audit_log.py

@@ -49,10 +49,8 @@ async def test_the_database_refuses_to_mutate_the_audit_log(
 ) -> None:
     await une_ligne(session)
 
-    requete = text(instruction)
-
     with pytest.raises(DBAPIError, match="ajout seul"):
-        await session.execute(requete)
+        await session.execute(text(instruction))
     await session.rollback()
 
 

apps/backend/tests/repositories/test_password_reset_token.py

@@ -131,14 +131,11 @@ async def test_the_database_refuses_two_tokens_sharing_a_fingerprint(
         user_agent=None,
     )
 
-    empreinte = fingerprint_refresh(secret)
-    expiration = datetime.now(UTC) + DUREE
-
     with pytest.raises(IntegrityError):
         await depot.create(
             user_id=compte,
-            token_hash=empreinte,
-            expires_at=expiration,
+            token_hash=fingerprint_refresh(secret),
+            expires_at=datetime.now(UTC) + DUREE,
             client_ip=None,
             user_agent=None,
         )

apps/backend/tests/repositories/test_prediction.py

@@ -1,171 +0,0 @@
-from datetime import UTC, datetime
-
-import pytest
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.models.energy import Prediction
-from app.repositories.prediction import PredictionRepository
-from tests.repositories.test_site import creer as creer_site
-from tests.repositories.test_site import identifiant as identifiant_site
-
-pytestmark = pytest.mark.integration
-
-
-async def creer_prediction(
-    session: AsyncSession, *, site_id: str, **overrides: object
-) -> Prediction:
-    prediction = Prediction(
-        site_id=site_id,
-        target_at=overrides.get("target_at", datetime(2026, 9, 16, tzinfo=UTC)),
-        target_metric=overrides.get("target_metric", "consumption_kwh"),
-        period_minutes=overrides.get("period_minutes", 60),
-        predicted_value=overrides.get("predicted_value", 42.0),
-        model_reference=overrides.get("model_reference", "lightgbm-test"),
-        status=overrides.get("status", "available"),
-        failure_reason=overrides.get("failure_reason"),
-    )
-    session.add(prediction)
-    await session.flush()
-    return prediction
-
-
-async def test_list_since_excludes_predictions_before_the_cutoff(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    dedans = await creer_prediction(
-        session, site_id=site.site_id, target_at=datetime(2026, 9, 16, tzinfo=UTC)
-    )
-    await creer_prediction(
-        session, site_id=site.site_id, target_at=datetime(2026, 9, 1, tzinfo=UTC)
-    )
-
-    resultats = await depot.list_since(
-        since=datetime(2026, 9, 10, tzinfo=UTC), site_id=site.site_id
-    )
-    identifiants = [p.prediction_id for p in resultats]
-    await session.rollback()
-
-    assert identifiants == [dedans.prediction_id]
-
-
-async def test_list_since_excludes_predictions_that_are_not_available(
-    session: AsyncSession,
-) -> None:
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    await creer_prediction(
-        session,
-        site_id=site.site_id,
-        target_at=datetime(2026, 9, 16, tzinfo=UTC),
-        status="insufficient_data",
-        predicted_value=None,
-        failure_reason="pas assez d'historique",
-    )
-
-    resultats = await depot.list_since(since=datetime(2026, 9, 1, tzinfo=UTC), site_id=site.site_id)
-    await session.rollback()
-
-    assert list(resultats) == []
-
-
-async def test_list_since_breaks_a_target_at_tie_by_ascending_prediction_id(
-    session: AsyncSession,
-) -> None:
-    # `prediction` n'a pas d'unicité sur `(site_id, target_at)` : deux runs de scoring sans
-    # nouvelle lecture entre-temps produisent deux lignes `available` à la même cible. Sans ce
-    # départage, `_detect_anomaly` retiendrait une ligne au hasard plutôt que le run le plus
-    # récent.
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    cible = datetime(2026, 9, 16, tzinfo=UTC)
-    premier_run = await creer_prediction(
-        session, site_id=site.site_id, target_at=cible, predicted_value=10.0
-    )
-    second_run = await creer_prediction(
-        session, site_id=site.site_id, target_at=cible, predicted_value=20.0
-    )
-
-    resultats = await depot.list_since(since=datetime(2026, 9, 1, tzinfo=UTC), site_id=site.site_id)
-    identifiants = [p.prediction_id for p in resultats]
-    await session.rollback()
-
-    assert identifiants == [premier_run.prediction_id, second_run.prediction_id]
-
-
-async def test_list_since_filters_by_site_id(session: AsyncSession) -> None:
-    premier = await creer_site(session)
-    second = await creer_site(session)
-    depot = PredictionRepository(session)
-    voulue = await creer_prediction(session, site_id=premier.site_id)
-    await creer_prediction(session, site_id=second.site_id)
-
-    resultats = await depot.list_since(
-        since=datetime(2026, 8, 1, tzinfo=UTC), site_id=premier.site_id
-    )
-    identifiants = [p.prediction_id for p in resultats]
-    await session.rollback()
-
-    assert identifiants == [voulue.prediction_id]
-
-
-async def test_latest_by_site_keeps_only_the_most_recent_target(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    ancienne = await creer_prediction(
-        session, site_id=site.site_id, target_at=datetime(2026, 9, 1, tzinfo=UTC)
-    )
-    recente = await creer_prediction(
-        session, site_id=site.site_id, target_at=datetime(2026, 9, 15, tzinfo=UTC)
-    )
-
-    resultats = await depot.latest_by_site()
-    identifiants = [
-        p.prediction_id
-        for p in resultats
-        if p.prediction_id in (ancienne.prediction_id, recente.prediction_id)
-    ]
-    await session.rollback()
-
-    assert identifiants == [recente.prediction_id]
-
-
-async def test_latest_by_site_returns_one_row_per_site(session: AsyncSession) -> None:
-    premier = await creer_site(session)
-    second = await creer_site(session)
-    depot = PredictionRepository(session)
-    voulue_premier = await creer_prediction(session, site_id=premier.site_id)
-    voulue_second = await creer_prediction(session, site_id=second.site_id)
-
-    resultats = await depot.latest_by_site()
-    identifiants = {p.site_id for p in resultats if p.site_id in (premier.site_id, second.site_id)}
-    await session.rollback()
-
-    assert identifiants == {voulue_premier.site_id, voulue_second.site_id}
-
-
-async def test_latest_by_site_keeps_an_insufficient_data_prediction(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = PredictionRepository(session)
-    voulue = await creer_prediction(
-        session,
-        site_id=site.site_id,
-        status="insufficient_data",
-        predicted_value=None,
-        failure_reason="pas assez d'historique",
-    )
-
-    resultats = await depot.latest_by_site()
-    identifiants = [p.prediction_id for p in resultats if p.site_id == site.site_id]
-    await session.rollback()
-
-    assert identifiants == [voulue.prediction_id]
-
-
-async def test_latest_by_site_returns_an_empty_list_when_there_is_nothing(
-    session: AsyncSession,
-) -> None:
-    depot = PredictionRepository(session)
-
-    resultats = [p for p in await depot.latest_by_site() if p.site_id == identifiant_site()]
-
-    assert resultats == []

apps/backend/tests/repositories/test_reading.py

@@ -155,79 +155,6 @@ async def test_latest_for_site_ignores_the_readings_of_the_other_sites(
     assert trouvee is None
 
 
-async def test_list_since_orders_by_site_then_by_time_ascending(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = ReadingRepository(session)
-    plus_recente = await creer_lecture(
-        session, site_id=site.site_id, timestamp=datetime(2026, 9, 16, tzinfo=UTC)
-    )
-    plus_ancienne = await creer_lecture(
-        session, site_id=site.site_id, timestamp=datetime(2026, 9, 15, tzinfo=UTC)
-    )
-
-    resultats = await depot.list_since(since=datetime(2026, 9, 1, tzinfo=UTC), site_id=site.site_id)
-    identifiants = [r.reading_id for r in resultats]
-    await session.rollback()
-
-    assert identifiants == [plus_ancienne.reading_id, plus_recente.reading_id]
-
-
-async def test_list_since_excludes_readings_before_the_cutoff(session: AsyncSession) -> None:
-    site = await creer_site(session)
-    depot = ReadingRepository(session)
-    dedans = await creer_lecture(
-        session, site_id=site.site_id, timestamp=datetime(2026, 9, 16, tzinfo=UTC)
-    )
-    await creer_lecture(session, site_id=site.site_id, timestamp=datetime(2026, 9, 1, tzinfo=UTC))
-
-    resultats = await depot.list_since(
-        since=datetime(2026, 9, 10, tzinfo=UTC), site_id=site.site_id
-    )
-    identifiants = [r.reading_id for r in resultats]
-    await session.rollback()
-
-    assert identifiants == [dedans.reading_id]
-
-
-async def test_list_since_breaks_a_timestamp_tie_by_ascending_reading_id(
-    session: AsyncSession,
-) -> None:
-    # `uq_reading_source` autorise deux lignes au même `site_id`+`timestamp` quand la `source`
-    # diffère (même piège que `latest_for_site`). Sans ce départage, `_detect_spike` traiterait
-    # cette paire comme une variation réelle selon un ordre non garanti par le plan d'exécution.
-    site = await creer_site(session)
-    depot = ReadingRepository(session)
-    horodatage = datetime(2026, 9, 16, tzinfo=UTC)
-    premiere = await creer_lecture(
-        session, site_id=site.site_id, timestamp=horodatage, source="api_history", consumption_kw=10
-    )
-    seconde = await creer_lecture(
-        session, site_id=site.site_id, timestamp=horodatage, source="api_current", consumption_kw=42
-    )
-
-    resultats = await depot.list_since(since=datetime(2026, 9, 1, tzinfo=UTC), site_id=site.site_id)
-    identifiants = [r.reading_id for r in resultats]
-    await session.rollback()
-
-    assert identifiants == [premiere.reading_id, seconde.reading_id]
-
-
-async def test_list_since_filters_by_site_id(session: AsyncSession) -> None:
-    premier = await creer_site(session)
-    second = await creer_site(session)
-    depot = ReadingRepository(session)
-    voulue = await creer_lecture(session, site_id=premier.site_id)
-    await creer_lecture(session, site_id=second.site_id)
-
-    resultats = await depot.list_since(
-        since=datetime(2026, 8, 1, tzinfo=UTC), site_id=premier.site_id
-    )
-    identifiants = [r.reading_id for r in resultats]
-    await session.rollback()
-
-    assert identifiants == [voulue.reading_id]
-
-
 async def test_list_history_orders_the_readings_by_timestamp_descending(
     session: AsyncSession,
 ) -> None:

apps/backend/tests/repositories/test_recommendation.py

@@ -5,8 +5,7 @@ import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.energy import Alert, Recommendation, Site
-from app.repositories import recommendation as module_recommendation
-from app.repositories.recommendation import NouvelleRecommandation, RecommendationRepository
+from app.repositories.recommendation import RecommendationRepository
 
 pytestmark = pytest.mark.integration
 
@@ -84,59 +83,3 @@ async def test_list_all_returns_the_recommendations_sorted_by_identifier(
     await session.rollback()
 
     assert identifiants == sorted(identifiants)
-
-
-def nouvelle(alert_id: int, reference: str = "spike-delestage-v1") -> NouvelleRecommandation:
-    return NouvelleRecommandation(
-        alert_id=alert_id,
-        action="Délester les équipements non prioritaires",
-        explanation="Pic de consommation signalé.",
-        rule_reference=reference,
-    )
-
-
-async def test_create_missing_inserts_the_proposals(session: AsyncSession) -> None:
-    depot = RecommendationRepository(session)
-    alert_id = await creer_alerte(session)
-
-    creees = await depot.create_missing(
-        [nouvelle(alert_id), nouvelle(alert_id, "escalade-astreinte-v1")]
-    )
-    await session.rollback()
-
-    assert creees == 2
-
-
-async def test_create_missing_ignores_a_rule_already_held_for_the_alert(
-    session: AsyncSession,
-) -> None:
-    depot = RecommendationRepository(session)
-    alert_id = await creer_alerte(session)
-    await depot.create_missing([nouvelle(alert_id)])
-
-    creees = await depot.create_missing([nouvelle(alert_id)])
-    await session.rollback()
-
-    assert creees == 0
-
-
-async def test_create_missing_returns_zero_without_any_proposal(session: AsyncSession) -> None:
-    creees = await RecommendationRepository(session).create_missing([])
-
-    assert creees == 0
-
-
-async def test_create_missing_inserts_every_proposal_across_several_batches(
-    session: AsyncSession, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    monkeypatch.setattr(module_recommendation, "TAILLE_DE_LOT", 2)
-    depot = RecommendationRepository(session)
-    alert_id = await creer_alerte(session)
-    propositions = [nouvelle(alert_id, f"regle-{index}-v1") for index in range(5)]
-
-    creees = await depot.create_missing(propositions)
-    enregistrees = [r for r in await depot.list_all() if r.alert_id == alert_id]
-    await session.rollback()
-
-    assert creees == 5
-    assert len(enregistrees) == 5

apps/backend/tests/repositories/test_refresh_token.py

@@ -178,16 +178,12 @@ async def test_the_database_refuses_two_tokens_sharing_a_fingerprint(
         user_agent=None,
     )
 
-    famille = uuid.uuid4()
-    empreinte = fingerprint_refresh(secret)
-    expiration = datetime.now(UTC) + DUREE
-
     with pytest.raises(IntegrityError):
         await depot.create(
             user_id=compte,
-            family_id=famille,
-            token_hash=empreinte,
-            expires_at=expiration,
+            family_id=uuid.uuid4(),
+            token_hash=fingerprint_refresh(secret),
+            expires_at=datetime.now(UTC) + DUREE,
             client_ip=None,
             user_agent=None,
         )

apps/backend/tests/repositories/test_user.py

@@ -31,12 +31,14 @@ async def test_the_database_refuses_an_email_written_in_upper_case(
 ) -> None:
     saisie = adresse().upper()
 
-    requete = text(
-        "insert into app_user (email, password_hash, role) values (:e, '$argon2id$x', 'lecteur')"
-    )
-
     with pytest.raises(IntegrityError):
-        await session.execute(requete, {"e": saisie})
+        await session.execute(
+            text(
+                "insert into app_user (email, password_hash, role) "
+                "values (:e, '$argon2id$x', 'lecteur')"
+            ),
+            {"e": saisie},
+        )
     await session.rollback()
 
 

apps/backend/tests/services/test_alert.py

@@ -1,10 +1,7 @@
-from dataclasses import dataclass, field
-from datetime import UTC, datetime, timedelta
+from datetime import UTC, datetime
 
 from app.models.energy import Alert
-from app.services.alert import OUTAGE_THRESHOLD, AlertService, _severity_from_ratio
-
-NOW = datetime(2026, 9, 16, 12, 0, tzinfo=UTC)
+from app.services.alert import AlertService
 
 
 def alert(
@@ -29,36 +26,10 @@ def alert(
     )
 
 
-@dataclass
-class FauxSite:
-    site_id: str
-    capacity_kw: float | None = None
-
-
-@dataclass
-class FauxLecture:
-    site_id: str
-    timestamp: datetime
-    consumption_kw: float | None = None
-    consumption_kwh: float | None = None
-    data_quality: str | None = None
-    null_reasons: list[str] | None = None
-
-
-@dataclass
-class FauxPrediction:
-    site_id: str
-    target_at: datetime
-    predicted_value: float | None
-    target_metric: str = "consumption_kwh"
-    prediction_id: int = 1
-
-
 class FakeRepository:
     def __init__(self, alerts: list[Alert]) -> None:
         self._alerts = alerts
         self.appels: list[tuple[str | None, str | None]] = []
-        self.crees: list[Alert] = []
 
     async def list_all(
         self, *, site_id: str | None = None, severity: str | None = None
@@ -66,392 +37,19 @@ class FakeRepository:
         self.appels.append((site_id, severity))
         return self._alerts
 
-    async def create_many(self, alerts: list[Alert]) -> list[Alert]:
-        self.crees = list(alerts)
-        return self.crees
-
-
-@dataclass
-class FauxDepotLectures:
-    depuis: list[FauxLecture] = field(default_factory=list)
-    dernieres: list[FauxLecture] = field(default_factory=list)
-
-    async def list_since(self, *, since: datetime, site_id: str | None = None) -> list[FauxLecture]:
-        return [lecture for lecture in self.depuis if site_id is None or lecture.site_id == site_id]
-
-    async def latest_by_site(self) -> list[FauxLecture]:
-        return self.dernieres
-
-
-@dataclass
-class FauxDepotPredictions:
-    predictions: list[FauxPrediction] = field(default_factory=list)
-
-    async def list_since(
-        self, *, since: datetime, site_id: str | None = None
-    ) -> list[FauxPrediction]:
-        return [p for p in self.predictions if site_id is None or p.site_id == site_id]
-
-
-@dataclass
-class FauxDepotSites:
-    sites: list[FauxSite]
-
-    async def list_all(self) -> list[FauxSite]:
-        return self.sites
-
-
-def service(
-    *,
-    sites: list[FauxSite],
-    lectures: list[FauxLecture] | None = None,
-    dernieres: list[FauxLecture] | None = None,
-    predictions: list[FauxPrediction] | None = None,
-    alerts: FakeRepository | None = None,
-) -> tuple[AlertService, FakeRepository]:
-    depot_alertes = alerts or FakeRepository([])
-    dernieres_lectures = dernieres if dernieres is not None else (lectures or [])
-    return (
-        AlertService(
-            alerts=depot_alertes,  # type: ignore[arg-type]
-            readings=FauxDepotLectures(depuis=lectures or [], dernieres=dernieres_lectures),  # type: ignore[arg-type]
-            predictions=FauxDepotPredictions(predictions or []),  # type: ignore[arg-type]
-            sites=FauxDepotSites(sites),  # type: ignore[arg-type]
-        ),
-        depot_alertes,
-    )
-
 
 async def test_list_all_returns_the_repository_alerts() -> None:
-    svc, _ = service(sites=[], alerts=FakeRepository([alert(1), alert(2)]))
+    service = AlertService(alerts=FakeRepository([alert(1), alert(2)]))
 
-    alertes = await svc.list_all()
+    alertes = await service.list_all()
 
     assert [a.alert_id for a in alertes] == [1, 2]
 
 
 async def test_list_all_relays_the_filters_to_the_repository() -> None:
     depot = FakeRepository([])
-    svc, _ = service(sites=[], alerts=depot)
+    service = AlertService(alerts=depot)
 
-    await svc.list_all(site_id="site-1", severity="critical")
+    await service.list_all(site_id="site-1", severity="critical")
 
     assert depot.appels == [("site-1", "critical")]
-
-
-async def test_detect_raises_a_threshold_alert_above_site_capacity() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=100.0)],
-        lectures=[FauxLecture("A", NOW, consumption_kw=150.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = depot.crees
-    assert candidate.type == "threshold"
-    assert candidate.severity == "high"
-    assert candidate.value == 150.0
-    assert candidate.threshold == 100.0
-    assert candidate.metric == "consumption_kw"
-
-
-async def test_detect_ignores_a_reading_within_capacity() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=100.0)],
-        lectures=[FauxLecture("A", NOW, consumption_kw=80.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert depot.crees == []
-
-
-async def test_detect_ignores_threshold_when_the_site_has_no_declared_capacity() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=None)],
-        lectures=[FauxLecture("A", NOW, consumption_kw=9999.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert depot.crees == []
-
-
-async def test_detect_raises_a_spike_alert_on_a_brutal_consecutive_variation() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=100.0),
-            FauxLecture("A", NOW, consumption_kw=160.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "spike"]
-    assert candidate.value == 160.0
-    assert candidate.threshold == 100.0
-    assert candidate.timestamp == NOW
-
-
-async def test_detect_ignores_a_moderate_consecutive_variation() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=100.0),
-            FauxLecture("A", NOW, consumption_kw=110.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_never_compares_consecutive_readings_across_two_sites() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A"), FauxSite("B")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=10.0),
-            FauxLecture("B", NOW, consumption_kw=1000.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_raises_an_anomaly_alert_far_from_the_matching_prediction() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=100.0)],
-        predictions=[FauxPrediction("A", target_at=NOW, predicted_value=70.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "anomaly"]
-    assert candidate.value == 100.0
-    assert candidate.threshold == 70.0
-    assert candidate.metric == "consumption_kwh"
-    assert candidate.prediction_id == 1
-
-
-async def test_detect_ignores_a_reading_close_to_its_prediction() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=100.0)],
-        predictions=[FauxPrediction("A", target_at=NOW, predicted_value=95.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "anomaly"] == []
-
-
-async def test_detect_ignores_a_prediction_whose_target_at_does_not_match_the_reading() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=100.0)],
-        predictions=[FauxPrediction("A", target_at=NOW - timedelta(hours=1), predicted_value=1.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "anomaly"] == []
-
-
-async def test_detect_keeps_the_most_recent_run_when_two_predictions_share_the_same_target() -> (
-    None
-):
-    # `PredictionRepository.list_since` départage les égalités de `target_at` par `prediction_id`
-    # croissant : le repository fait donc déjà passer le run le plus récent en dernier dans la
-    # liste, et c'est ce dernier que le dict de `_detect_anomaly` doit retenir.
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=100.0)],
-        predictions=[
-            FauxPrediction("A", target_at=NOW, predicted_value=100.0, prediction_id=1),
-            FauxPrediction("A", target_at=NOW, predicted_value=70.0, prediction_id=2),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "anomaly"]
-    assert candidate.threshold == 70.0
-    assert candidate.prediction_id == 2
-
-
-async def test_detect_raises_an_outage_alert_past_the_threshold() -> None:
-    derniere = NOW - OUTAGE_THRESHOLD - timedelta(minutes=1)
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[],
-        dernieres=[FauxLecture("A", derniere)],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "outage"]
-    assert candidate.severity in {"low", "medium", "high", "critical"}
-
-
-async def test_detect_ignores_a_site_still_within_the_outage_threshold() -> None:
-    derniere = NOW - OUTAGE_THRESHOLD + timedelta(minutes=1)
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[],
-        dernieres=[FauxLecture("A", derniere)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "outage"] == []
-
-
-async def test_detect_raises_a_critical_outage_alert_for_a_site_never_read() -> None:
-    svc, depot = service(sites=[FauxSite("A")], lectures=[], dernieres=[])
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "outage"]
-    assert candidate.severity == "critical"
-    assert candidate.source_alert_id == "outage:jamais"
-
-
-async def test_detect_raises_a_sensor_alert_on_a_degraded_reading() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, data_quality="critical", null_reasons=["missing:x"])],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "sensor"]
-    assert candidate.severity == "critical"
-
-
-async def test_detect_ignores_a_good_quality_reading_for_the_sensor_rule() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, data_quality="good")],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "sensor"] == []
-
-
-async def test_detect_scopes_to_a_single_site_when_asked() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=100.0), FauxSite("B", capacity_kw=100.0)],
-        lectures=[
-            FauxLecture("A", NOW, consumption_kw=150.0),
-            FauxLecture("B", NOW, consumption_kw=150.0),
-        ],
-    )
-
-    await svc.detect(now=NOW, site_id="A")
-
-    assert {a.site_id for a in depot.crees} == {"A"}
-
-
-async def test_detect_returns_early_when_there_is_no_site() -> None:
-    svc, depot = service(sites=[])
-
-    resultat = await svc.detect(now=NOW)
-
-    assert resultat == []
-    assert depot.crees == []
-
-
-async def test_detect_ignores_a_spike_pair_with_a_missing_measurement() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=None),
-            FauxLecture("A", NOW, consumption_kw=160.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_ignores_a_reading_still_at_zero_after_a_previous_zero() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=0.0),
-            FauxLecture("A", NOW, consumption_kw=0.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_raises_a_critical_spike_when_a_site_restarts_from_zero() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW - timedelta(hours=1), consumption_kw=0.0),
-            FauxLecture("A", NOW, consumption_kw=50.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    (candidate,) = [a for a in depot.crees if a.type == "spike"]
-    assert candidate.severity == "critical"
-    assert candidate.value == 50.0
-    assert candidate.threshold == 0.0
-
-
-async def test_detect_ignores_a_spike_pair_sharing_the_same_timestamp() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[
-            FauxLecture("A", NOW, consumption_kw=100.0),
-            FauxLecture("A", NOW, consumption_kw=160.0),
-        ],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "spike"] == []
-
-
-async def test_detect_ignores_an_anomaly_when_the_prediction_is_near_zero() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A")],
-        lectures=[FauxLecture("A", NOW, consumption_kwh=5.0)],
-        predictions=[FauxPrediction("A", target_at=NOW, predicted_value=0.0)],
-    )
-
-    await svc.detect(now=NOW)
-
-    assert [a for a in depot.crees if a.type == "anomaly"] == []
-
-
-def test_severity_from_ratio_covers_every_band() -> None:
-    assert _severity_from_ratio(1.0) == "low"
-    assert _severity_from_ratio(1.2) == "medium"
-    assert _severity_from_ratio(1.5) == "high"
-    assert _severity_from_ratio(2.0) == "critical"
-
-
-async def test_detect_does_not_call_create_many_when_nothing_triggers() -> None:
-    svc, depot = service(
-        sites=[FauxSite("A", capacity_kw=100.0)],
-        lectures=[FauxLecture("A", NOW, consumption_kw=10.0, data_quality="good")],
-    )
-
-    resultat = await svc.detect(now=NOW)
-
-    assert resultat == []
-    assert depot.crees == []

apps/backend/tests/services/test_prediction.py

@@ -1,121 +0,0 @@
-from dataclasses import dataclass
-from datetime import UTC, datetime
-
-from app.services.prediction import PredictionService
-
-TARGET_AT = datetime(2026, 9, 16, 13, 0, tzinfo=UTC)
-CREATED_AT = datetime(2026, 9, 16, 12, 0, tzinfo=UTC)
-
-
-@dataclass
-class FauxSite:
-    site_id: str
-    site_name: str
-
-
-@dataclass
-class FauxPrediction:
-    site_id: str
-    target_at: datetime
-    target_metric: str
-    period_minutes: int | None
-    predicted_value: float | None
-    status: str
-    failure_reason: str | None
-    model_reference: str
-    created_at: datetime
-
-
-class FauxDepotSites:
-    def __init__(self, sites: list[FauxSite]) -> None:
-        self._sites = sites
-
-    async def list_all(self) -> list[FauxSite]:
-        return self._sites
-
-
-class FauxDepotPredictions:
-    def __init__(self, predictions: list[FauxPrediction]) -> None:
-        self._predictions = predictions
-
-    async def latest_by_site(self) -> list[FauxPrediction]:
-        return self._predictions
-
-
-def prediction_disponible(site_id: str = "A") -> FauxPrediction:
-    return FauxPrediction(
-        site_id=site_id,
-        target_at=TARGET_AT,
-        target_metric="consumption_kwh",
-        period_minutes=60,
-        predicted_value=812.5,
-        status="available",
-        failure_reason=None,
-        model_reference="lightgbm-abc123",
-        created_at=CREATED_AT,
-    )
-
-
-async def test_summary_attaches_the_latest_prediction_to_its_site() -> None:
-    service = PredictionService(
-        sites=FauxDepotSites([FauxSite("A", "Site A")]),  # type: ignore[arg-type]
-        predictions=FauxDepotPredictions([prediction_disponible("A")]),  # type: ignore[arg-type]
-    )
-
-    resume = await service.summary()
-
-    site = resume.sites[0]
-    assert site.site_id == "A"
-    assert site.prediction is not None
-    assert site.prediction.predicted_value == 812.5
-    assert site.prediction.status == "available"
-
-
-async def test_summary_leaves_prediction_none_for_a_site_never_scored() -> None:
-    service = PredictionService(
-        sites=FauxDepotSites([FauxSite("A", "Site A")]),  # type: ignore[arg-type]
-        predictions=FauxDepotPredictions([]),  # type: ignore[arg-type]
-    )
-
-    resume = await service.summary()
-
-    assert resume.sites[0].prediction is None
-
-
-async def test_summary_carries_an_insufficient_data_prediction_without_a_value() -> None:
-    insuffisante = FauxPrediction(
-        site_id="A",
-        target_at=TARGET_AT,
-        target_metric="consumption_kwh",
-        period_minutes=60,
-        predicted_value=None,
-        status="insufficient_data",
-        failure_reason="pas assez d'historique",
-        model_reference="lightgbm-abc123",
-        created_at=CREATED_AT,
-    )
-    service = PredictionService(
-        sites=FauxDepotSites([FauxSite("A", "Site A")]),  # type: ignore[arg-type]
-        predictions=FauxDepotPredictions([insuffisante]),  # type: ignore[arg-type]
-    )
-
-    resume = await service.summary()
-
-    site = resume.sites[0]
-    assert site.prediction is not None
-    assert site.prediction.status == "insufficient_data"
-    assert site.prediction.predicted_value is None
-    assert site.prediction.failure_reason == "pas assez d'historique"
-
-
-async def test_summary_covers_every_site_even_with_a_single_prediction_in_the_repository() -> None:
-    service = PredictionService(
-        sites=FauxDepotSites([FauxSite("A", "Site A"), FauxSite("B", "Site B")]),  # type: ignore[arg-type]
-        predictions=FauxDepotPredictions([prediction_disponible("A")]),  # type: ignore[arg-type]
-    )
-
-    resume = await service.summary()
-
-    par_site = {site.site_id: site for site in resume.sites}
-    assert par_site["A"].prediction is not None
-    assert par_site["B"].prediction is None

apps/backend/tests/services/test_reading.py

@@ -116,11 +116,13 @@ async def test_list_history_normalizes_naive_datetimes_to_utc() -> None:
 async def test_list_history_raises_when_start_is_after_end() -> None:
     service = ReadingService(readings=FakeRepository([]))
 
-    debut = datetime(2026, 9, 2, tzinfo=UTC)
-    fin = datetime(2026, 9, 1, tzinfo=UTC)
-
     with pytest.raises(FenetreInverseeError):
-        await service.list_history(start=debut, end=fin, limit=500, offset=0)
+        await service.list_history(
+            start=datetime(2026, 9, 2, tzinfo=UTC),
+            end=datetime(2026, 9, 1, tzinfo=UTC),
+            limit=500,
+            offset=0,
+        )
 
 
 async def test_list_history_raises_when_start_equals_end() -> None:

apps/backend/tests/services/test_recommendation.py

@@ -1,14 +1,10 @@
-from collections.abc import Sequence
 from datetime import UTC, datetime
 
 import pytest
 
-from app.models.energy import Alert, Recommendation
-from app.repositories.recommendation import NouvelleRecommandation
+from app.models.energy import Recommendation
 from app.services.recommendation import RecommendationNotFoundError, RecommendationService
 
-MOMENT = datetime(2024, 1, 1, tzinfo=UTC)
-
 
 def recommendation(recommendation_id: int = 1) -> Recommendation:
     return Recommendation(
@@ -17,33 +13,13 @@ def recommendation(recommendation_id: int = 1) -> Recommendation:
         action="Vérifier la consommation",
         explanation="Pic détecté",
         rule_reference="spike-v1",
-        created_at=MOMENT,
-    )
-
-
-def alerte(alert_id: int = 1, site_id: str = "SITE001", severity: str = "high") -> Alert:
-    return Alert(
-        alert_id=alert_id,
-        source_alert_id=f"ALR-{alert_id}",
-        site_id=site_id,
-        source="api_mock",
-        timestamp=MOMENT,
-        type="spike",
-        severity=severity,
-        message="Pic de consommation",
-        value=None,
-        threshold=None,
-        metric=None,
-        prediction_id=None,
-        raw_data={},
+        created_at=datetime(2024, 1, 1, tzinfo=UTC),
     )
 
 
 class FakeRepository:
-    def __init__(self, recommendations: list[Recommendation], creees: int | None = None) -> None:
+    def __init__(self, recommendations: list[Recommendation]) -> None:
         self._recommendations = recommendations
-        self._creees = creees
-        self.recues: list[NouvelleRecommandation] = []
 
     async def list_all(self) -> list[Recommendation]:
         return self._recommendations
@@ -53,111 +29,27 @@ class FakeRepository:
             (r for r in self._recommendations if r.recommendation_id == recommendation_id), None
         )
 
-    async def create_missing(self, nouvelles: Sequence[NouvelleRecommandation]) -> int:
-        self.recues = list(nouvelles)
-        return len(self.recues) if self._creees is None else self._creees
-
-
-class FakeAlertRepository:
-    def __init__(self, alertes: list[Alert]) -> None:
-        self._alertes = alertes
-        self.site_demande: str | None = None
-
-    async def list_all(
-        self, *, site_id: str | None = None, severity: str | None = None
-    ) -> list[Alert]:
-        self.site_demande = site_id
-        if site_id is None:
-            return self._alertes
-        return [a for a in self._alertes if a.site_id == site_id]
-
-
-class FakeTransaction:
-    def __init__(self) -> None:
-        self.commits = 0
-
-    async def commit(self) -> None:
-        self.commits += 1
-
-
-def service(
-    recommendations: FakeRepository | None = None,
-    alerts: FakeAlertRepository | None = None,
-    transaction: FakeTransaction | None = None,
-) -> RecommendationService:
-    return RecommendationService(
-        recommendations=recommendations or FakeRepository([]),
-        alerts=alerts or FakeAlertRepository([]),
-        transaction=transaction or FakeTransaction(),
-    )
-
 
 async def test_list_all_returns_the_repository_recommendations() -> None:
-    depot = FakeRepository([recommendation(1), recommendation(2)])
+    service = RecommendationService(
+        recommendations=FakeRepository([recommendation(1), recommendation(2)])
+    )
 
-    recommendations = await service(recommendations=depot).list_all()
+    recommendations = await service.list_all()
 
     assert [r.recommendation_id for r in recommendations] == [1, 2]
 
 
 async def test_get_by_id_returns_the_matching_recommendation() -> None:
-    trouve = await service(recommendations=FakeRepository([recommendation(1)])).get_by_id(1)
+    service = RecommendationService(recommendations=FakeRepository([recommendation(1)]))
+
+    trouve = await service.get_by_id(1)
 
     assert trouve.recommendation_id == 1
 
 
 async def test_get_by_id_raises_when_the_recommendation_is_unknown() -> None:
+    service = RecommendationService(recommendations=FakeRepository([]))
+
     with pytest.raises(RecommendationNotFoundError):
-        await service().get_by_id(404)
-
-
-async def test_generate_persists_one_proposal_per_triggered_rule() -> None:
-    depot = FakeRepository([])
-
-    rapport = await service(
-        recommendations=depot, alerts=FakeAlertRepository([alerte(severity="critical")])
-    ).generate()
-
-    assert {n.rule_reference for n in depot.recues} == {
-        "spike-delestage-v1",
-        "escalade-astreinte-v1",
-    }
-    assert rapport.recommandations_creees == 2
-
-
-async def test_generate_commits_once() -> None:
-    transaction = FakeTransaction()
-
-    await service(alerts=FakeAlertRepository([alerte()]), transaction=transaction).generate()
-
-    assert transaction.commits == 1
-
-
-async def test_generate_restricts_the_alerts_to_the_requested_site() -> None:
-    alertes = FakeAlertRepository([alerte(1, site_id="SITE001"), alerte(2, site_id="SITE002")])
-    depot = FakeRepository([])
-
-    rapport = await service(recommendations=depot, alerts=alertes).generate(site_id="SITE002")
-
-    assert alertes.site_demande == "SITE002"
-    assert rapport.alertes_examinees == 1
-    assert {n.alert_id for n in depot.recues} == {2}
-
-
-async def test_generate_reports_nothing_when_no_alert_matches() -> None:
-    rapport = await service().generate()
-
-    assert rapport.alertes_examinees == 0
-    assert rapport.recommandations_creees == 0
-    assert rapport.deja_presentes == 0
-
-
-async def test_generate_counts_the_proposals_the_database_already_held() -> None:
-    depot = FakeRepository([], creees=0)
-
-    rapport = await service(
-        recommendations=depot, alerts=FakeAlertRepository([alerte()])
-    ).generate()
-
-    assert rapport.recommandations_creees == 0
-    assert rapport.deja_presentes == 1
+        await service.get_by_id(404)

apps/backend/tests/services/test_recommendation_rules.py

@@ -1,142 +0,0 @@
-from datetime import UTC, datetime
-
-import pytest
-
-from app.models.energy import Alert
-from app.services.recommendation_rules import FACTEUR_DEPASSEMENT_MAJEUR, applique_les_regles
-
-MOMENT = datetime(2024, 1, 1, tzinfo=UTC)
-
-
-def alerte(
-    *,
-    alert_id: int = 1,
-    type_alerte: str = "spike",
-    severity: str = "high",
-    value: float | None = None,
-    threshold: float | None = None,
-    metric: str | None = None,
-    site_id: str = "SITE001",
-) -> Alert:
-    return Alert(
-        alert_id=alert_id,
-        source_alert_id=f"ALR-{alert_id}",
-        site_id=site_id,
-        source="api_mock",
-        timestamp=MOMENT,
-        type=type_alerte,
-        severity=severity,
-        message="Alerte de test",
-        value=value,
-        threshold=threshold,
-        metric=metric,
-        prediction_id=None,
-        raw_data={},
-    )
-
-
-@pytest.mark.parametrize(
-    ("type_alerte", "attendue"),
-    [
-        ("spike", "spike-delestage-v1"),
-        ("threshold", "threshold-reduction-v1"),
-        ("outage", "outage-secours-v1"),
-        ("sensor", "sensor-maintenance-v1"),
-        ("anomaly", "anomaly-verification-v1"),
-    ],
-    ids=["pic", "seuil", "coupure", "capteur", "anomalie"],
-)
-def test_each_alert_type_yields_its_own_rule(type_alerte: str, attendue: str) -> None:
-    proposees = applique_les_regles(alerte(type_alerte=type_alerte))
-
-    assert [p.rule_reference for p in proposees] == [attendue]
-
-
-def test_a_critical_alert_adds_the_escalation_rule() -> None:
-    proposees = applique_les_regles(alerte(severity="critical"))
-
-    assert "escalade-astreinte-v1" in {p.rule_reference for p in proposees}
-
-
-@pytest.mark.parametrize("severity", ["low", "medium", "high"], ids=["faible", "moyenne", "haute"])
-def test_a_non_critical_alert_does_not_escalate(severity: str) -> None:
-    proposees = applique_les_regles(alerte(severity=severity))
-
-    assert "escalade-astreinte-v1" not in {p.rule_reference for p in proposees}
-
-
-def test_a_large_overshoot_adds_the_contract_rule() -> None:
-    proposees = applique_les_regles(
-        alerte(value=720.0 * FACTEUR_DEPASSEMENT_MAJEUR, threshold=720.0)
-    )
-
-    assert "contrat-puissance-v1" in {p.rule_reference for p in proposees}
-
-
-def test_an_overshoot_below_the_factor_does_not_add_the_contract_rule() -> None:
-    proposees = applique_les_regles(alerte(value=800.0, threshold=720.0))
-
-    assert "contrat-puissance-v1" not in {p.rule_reference for p in proposees}
-
-
-@pytest.mark.parametrize(
-    ("value", "threshold"),
-    [(None, 720.0), (900.0, None), (900.0, 0.0), (900.0, -10.0)],
-    ids=["sans mesure", "sans seuil", "seuil nul", "seuil negatif"],
-)
-def test_the_contract_rule_stays_silent_without_an_exploitable_threshold(
-    value: float | None, threshold: float | None
-) -> None:
-    proposees = applique_les_regles(alerte(value=value, threshold=threshold))
-
-    assert "contrat-puissance-v1" not in {p.rule_reference for p in proposees}
-
-
-def test_the_explanation_quotes_the_measure_and_the_threshold() -> None:
-    proposees = applique_les_regles(alerte(value=812.5, threshold=720.0, metric="consumption_kw"))
-
-    assert "(consumption_kw mesurée à 812.5, seuil 720.0)" in proposees[0].explanation
-
-
-def test_the_explanation_quotes_the_measure_alone_when_no_threshold_is_known() -> None:
-    proposees = applique_les_regles(alerte(value=812.5, metric="consumption_kw"))
-
-    assert "(consumption_kw mesurée à 812.5)" in proposees[0].explanation
-
-
-def test_the_explanation_omits_the_measure_when_the_alert_carries_none() -> None:
-    proposees = applique_les_regles(alerte())
-
-    assert "(" not in proposees[0].explanation
-
-
-def test_the_explanation_names_the_site() -> None:
-    proposees = applique_les_regles(alerte(site_id="SITE042"))
-
-    assert "SITE042" in proposees[0].explanation
-
-
-def test_every_proposal_carries_the_alert_identifier() -> None:
-    proposees = applique_les_regles(alerte(alert_id=77, severity="critical"))
-
-    assert {p.alert_id for p in proposees} == {77}
-
-
-def test_an_alert_never_yields_the_same_rule_twice() -> None:
-    proposees = applique_les_regles(
-        alerte(severity="critical", value=900.0, threshold=720.0, metric="consumption_kw")
-    )
-
-    assert len(proposees) == len({p.rule_reference for p in proposees})
-
-
-def test_a_critical_alert_over_the_threshold_yields_the_three_rules() -> None:
-    proposees = applique_les_regles(
-        alerte(severity="critical", value=900.0, threshold=720.0, metric="consumption_kw")
-    )
-
-    assert {p.rule_reference for p in proposees} == {
-        "spike-delestage-v1",
-        "escalade-astreinte-v1",
-        "contrat-puissance-v1",
-    }

apps/backend/tests/services/test_user.py

@@ -235,7 +235,5 @@ async def test_every_operation_refuses_an_unknown_account(action: str) -> None:
     if action == "set_active":
         arguments["is_active"] = False
 
-    methode = getattr(attirail.service, action)
-
     with pytest.raises(UserNotFoundError):
-        await methode(**arguments)
+        await getattr(attirail.service, action)(**arguments)

apps/backend/tests/test_cli.py

@@ -19,17 +19,13 @@ def test_build_parser_reads_the_create_admin_arguments() -> None:
 
 
 def test_build_parser_requires_a_subcommand() -> None:
-    parser = cli.build_parser()
-
     with pytest.raises(SystemExit):
-        parser.parse_args([])
+        cli.build_parser().parse_args([])
 
 
 def test_build_parser_requires_an_email() -> None:
-    parser = cli.build_parser()
-
     with pytest.raises(SystemExit):
-        parser.parse_args(["create-admin"])
+        cli.build_parser().parse_args(["create-admin"])
 
 
 def test_read_password_generates_a_long_secret_when_asked(
@@ -122,30 +118,3 @@ def test_main_exports_the_contract_without_asking_for_a_password(
     assert code == 0
     assert destination.exists()
     assert str(destination) in capsys.readouterr().out
-
-
-def test_build_parser_reads_the_generate_recommendations_arguments() -> None:
-    arguments = cli.build_parser().parse_args(["generate-recommendations", "--site-id", "SITE002"])
-
-    assert arguments.commande == "generate-recommendations"
-    assert arguments.site_id == "SITE002"
-
-
-def test_build_parser_defaults_the_generation_to_every_site() -> None:
-    arguments = cli.build_parser().parse_args(["generate-recommendations"])
-
-    assert arguments.site_id is None
-
-
-def test_main_generates_the_recommendations_without_asking_for_a_password(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    async def fausse_generation(*, site_id: str | None) -> str:
-        return f"génération lancée pour {site_id}"
-
-    monkeypatch.setattr(cli, "generate_recommendations", fausse_generation)
-
-    code = cli.main(["generate-recommendations", "--site-id", "SITE002"])
-
-    assert code == 0
-    assert "SITE002" in capsys.readouterr().out

apps/backend/tests/test_internal_alerts.py

@@ -1,87 +0,0 @@
-from datetime import UTC, datetime
-
-import pytest
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.session import get_session_factory
-from app.detection import internal_alerts
-from app.repositories.alert import AlertRepository
-from tests.repositories.test_reading import creer_lecture
-from tests.repositories.test_site import creer as creer_site
-
-
-def test_parse_args_defaults_to_no_site_and_no_instant() -> None:
-    arguments = internal_alerts.parse_args([])
-
-    assert arguments.site_id is None
-    assert arguments.now is None
-
-
-def test_parse_args_reads_the_site_id() -> None:
-    arguments = internal_alerts.parse_args(["--site-id", "site-1"])
-
-    assert arguments.site_id == "site-1"
-
-
-def test_parse_args_parses_the_instant_option() -> None:
-    arguments = internal_alerts.parse_args(["--now", "2026-09-16T12:00:00+00:00"])
-
-    assert arguments.now == datetime(2026, 9, 16, 12, tzinfo=UTC)
-
-
-def test_parse_instant_treats_a_naive_datetime_as_utc() -> None:
-    assert internal_alerts._parse_instant("2026-09-16T12:00:00") == datetime(
-        2026, 9, 16, 12, tzinfo=UTC
-    )
-
-
-def test_main_prints_how_many_alerts_were_recorded(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    async def fausse_execution(*, now: datetime | None, site_id: str | None) -> int:
-        return 3
-
-    monkeypatch.setattr(internal_alerts, "run_detection", fausse_execution)
-
-    code = internal_alerts.main([])
-
-    assert code == 0
-    assert "3 nouvelle" in capsys.readouterr().out
-
-
-@pytest.mark.integration
-async def test_run_detection_writes_a_threshold_alert_end_to_end(session: AsyncSession) -> None:
-    # `run_detection` ouvre sa propre session et commite : `session.rollback()` seul ne défait
-    # rien ici (contrairement au reste de la suite), d'où le nettoyage explicite ci-dessous, sur
-    # le modèle de `tests/api/test_matrice_acces.py`.
-    site = await creer_site(session, capacity_kw=100.0)
-    site_id = site.site_id
-    instant = datetime(2026, 9, 16, 12, tzinfo=UTC)
-    await creer_lecture(session, site_id=site_id, timestamp=instant, consumption_kw=150.0)
-    await session.commit()
-
-    try:
-        nombre = await internal_alerts.run_detection(now=instant, site_id=site_id)
-
-        alertes = await AlertRepository(session).list_all(site_id=site_id)
-        types = [a.type for a in alertes]
-        await session.rollback()
-
-        assert nombre == 1
-        assert types == ["threshold"]
-    finally:
-        # `site.site_id` n'est plus sûr après `session.rollback()` : le rollback expire tous les
-        # objets de la session (indépendamment d'`expire_on_commit`), et y accéder ici relance une
-        # requête hors contexte async. D'où `site_id`, capturé avant.
-        async with get_session_factory()() as nettoyage:
-            await nettoyage.execute(
-                text("delete from alert where site_id = :site_id"), {"site_id": site_id}
-            )
-            await nettoyage.execute(
-                text("delete from reading where site_id = :site_id"), {"site_id": site_id}
-            )
-            await nettoyage.execute(
-                text("delete from site where site_id = :site_id"), {"site_id": site_id}
-            )
-            await nettoyage.commit()

apps/backend/uv.lock

@@ -326,7 +326,6 @@ dependencies = [
     { name = "argon2-cffi" },
     { name = "asyncpg" },
     { name = "fastapi" },
-    { name = "httpx" },
     { name = "pandas" },
     { name = "prometheus-fastapi-instrumentator" },
     { name = "pydantic", extra = ["email"] },
@@ -339,6 +338,7 @@ dependencies = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "httpx" },
     { name = "mypy" },
     { name = "pandas-stubs" },
     { name = "pytest" },
@@ -355,7 +355,6 @@ requires-dist = [
     { name = "argon2-cffi", specifier = ">=23.1" },
     { name = "asyncpg", specifier = ">=0.31.0" },
     { name = "fastapi", specifier = ">=0.141.1" },
-    { name = "httpx", specifier = ">=0.28.1" },
     { name = "pandas", specifier = ">=3.0.5" },
     { name = "prometheus-fastapi-instrumentator", specifier = ">=8.1.0" },
     { name = "pydantic", extras = ["email"], specifier = ">=2.13.5" },
@@ -368,6 +367,7 @@ requires-dist = [
 
 [package.metadata.requires-dev]
 dev = [
+    { name = "httpx", specifier = ">=0.28.1" },
     { name = "mypy", specifier = ">=2.3.1" },
     { name = "pandas-stubs", specifier = ">=3.0.5.260914" },
     { name = "pytest", specifier = ">=9.1.1" },

apps/frontend/Dockerfile

@@ -23,7 +23,7 @@ RUN npm run build
 # ==================
 
 
-FROM nginx:1.28-alpine AS runner
+FROM dhi.io/nginx:1.28.0-alpine3.21-dev AS runner
 
 # Copie de la configuration de nginx
 COPY --chown=root:root --chmod=755 nginx.conf /etc/nginx/nginx.conf

apps/frontend/TESTING.md

@@ -1,4 +1,4 @@
-# Conventions de tests unitaires : Frontend
+# Conventions de tests unitaires — Frontend
 
 ## Outil
 Vitest (intégré nativement à Angular CLI, pas d'installation à faire).
@@ -83,6 +83,3 @@ describe('MonComposant', () => {
 ## Lancer les tests
 - Développement (mode watch) : `npm test`
 - Rapport de couverture (CI) : `npm run test:ci -- --coverage`, puis ouvrir `coverage/index.html`
-- Un fichier ou un dossier seulement :
-  `npx ng test --watch=false --coverage=false --include=src/app/core/services/alerts.service.spec.ts`
-  (répéter `--include` pour plusieurs cibles ; un dossier joue tous ses specs)

apps/frontend/angular.json

@@ -34,11 +34,6 @@
           },
           "configurations": {
             "production": {
-              "optimization": {
-                "styles": {
-                  "inlineCritical": false
-                }
-              },
               "budgets": [
                 {
                   "type": "initial",

apps/frontend/sonar-project.properties

@@ -1,18 +0,0 @@
-sonar.projectKey=ProjetPiscine_EnerVision
-sonar.organization=groupe3-ener-vision
-sonar.sourceEncoding=UTF-8
-
-#  Dossier contenant le code source
-sonar.sources=apps/frontend/src,apps/backend/app
-sonar.tests=apps/backend/tests
-
-#  Liste des fichiers et dossiers à exclure de l'analyse
-#  Liste des fichiers et dossiers à exclure de l'analyse
-sonar.exclusions=**/node_modules/**,**/dist/**,**/*.spec.js,**/*.test.js,github,db,ml,docker-compose.yml,**/**/Dockerfile,**/**/proxy.conf.json,**/**/package.json,**/**/angular.json
-
-#  Chemin vers le rapport de couverture de code
-#  Fichier généré par Vitest
-#  Chemin vers le rapport de couverture de code
-#  Fichier généré par Vitest
-sonar.javascript.lcov.reportPaths=apps/frontend/coverage/frontend/lcov.info
-sonar.python.coverage.reportPaths=apps/backend/cov.info

apps/frontend/src/app/app.routes.ts

@@ -1,54 +1,28 @@
 import { Routes } from '@angular/router';
-import { authGuard } from './core/guards/auth-guard';
+import {authGuard} from './core/guards/auth-guard';
 
 export const routes: Routes = [
   { path: '', redirectTo: 'dashboard', pathMatch: 'full' },
-  {
-    path: 'login',
-    loadComponent: () => import('./features/auth/login/login').then((m) => m.Login),
-  },
-  {
-    path: 'change-password',
-    loadComponent: () =>
-      import('./features/auth/change-password/change-password').then((m) => m.ChangePassword),
-  },
-  {
-    path: 'forgot-password',
-    loadComponent: () =>
-      import('./features/auth/forgot-password/forgot-password').then((m) => m.ForgotPassword),
-  },
-  {
-    path: 'reset-password',
-    loadComponent: () =>
-      import('./features/auth/reset-password/reset-password').then((m) => m.ResetPassword),
-  },
+  { path: 'login', loadComponent: () => import('./features/auth/login/login').then(m => m.Login) },
+  { path: 'change-password', loadComponent: () => import('./features/auth/change-password/change-password').then(m => m.ChangePassword) },
+  { path: 'forgot-password', loadComponent: () => import('./features/auth/forgot-password/forgot-password').then(m => m.ForgotPassword) },
+  { path: 'reset-password', loadComponent: () => import('./features/auth/reset-password/reset-password').then(m => m.ResetPassword) },
   {
     path: 'dashboard',
     canActivate: [authGuard],
-    loadComponent: () => import('./features/dashboard/dashboard').then((m) => m.Dashboard),
+    loadComponent: () => import('./features/dashboard/dashboard').then(m => m.Dashboard),
   },
   {
     path: 'sites',
     canActivate: [authGuard],
-    loadComponent: () => import('./features/sites/site-list/site-list').then((m) => m.SiteList),
+    loadComponent: () => import('./features/sites/site-list/site-list').then(m => m.SiteList),
   },
   {
     path: 'sites/:siteId',
     canActivate: [authGuard],
     loadComponent: () =>
-      import('./features/sites/site-detail/site-detail').then((m) => m.SiteDetail),
-  },
-  {
-    path: 'recommendations',
-    canActivate: [authGuard],
-    loadComponent: () =>
-      import('./features/recommendations/recommendations').then((m) => m.RecommendationsView),
-  },
-  {
-    path: 'monitoring/sensors',
-    canActivate: [authGuard],
-    data: { role: 'admin' },
-    loadComponent: () =>
-      import('./features/monitoring/sensor-status/sensor-status').then((m) => m.SensorStatusView),
+      import('./features/sites/site-detail-placeholder/site-detail-placeholder').then(
+        (m) => m.SiteDetailPlaceholder,
+      ),
   },
 ];

apps/frontend/src/app/core/interceptors/mock-api-interceptor.spec.ts

@@ -8,10 +8,8 @@ import { STATS_SUMMARY_FIXTURE } from '../mocks/stats-summary.fixture';
 describe('mockApiInterceptor', () => {
   let http: HttpClient;
   let httpMock: HttpTestingController;
-  let useMockFixturesInitial: boolean;
 
   beforeEach(() => {
-    useMockFixturesInitial = environment.useMockFixtures;
     TestBed.configureTestingModule({
       providers: [
         provideHttpClient(withInterceptors([mockApiInterceptor])),
@@ -23,7 +21,7 @@ describe('mockApiInterceptor', () => {
   });
 
   afterEach(() => {
-    environment.useMockFixtures = useMockFixturesInitial;
+    environment.useMockFixtures = true;
     httpMock.verify();
   });
 
@@ -66,13 +64,4 @@ describe('mockApiInterceptor', () => {
     httpMock.expectNone(`${environment.apiUrl}/alerts`);
     expect((result as unknown[]).length).toBeGreaterThan(0);
   });
-
-  it('laisse toujours passer /predictions vers le réseau, même avec useMockFixtures activé', () => {
-    environment.useMockFixtures = true;
-
-    http.get(`${environment.apiUrl}/predictions`).subscribe();
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/predictions`);
-    req.flush({ timestamp: '2026-09-18T09:00:00Z', sites: [] });
-  });
 });

apps/frontend/src/app/core/interceptors/mock-api-interceptor.ts

@@ -26,7 +26,5 @@ export const mockApiInterceptor: HttpInterceptorFn = (req, next) => {
   if (req.url.endsWith(`${environment.apiUrl}/alerts`)) {
     return of(new HttpResponse({ status: 200, body: ALERTS_FIXTURE }));
   }
-  // Volontairement jamais mocké, contrairement à `stats`/`alerts` : les prévisions sont servies
-  // par l'API réelle dès maintenant (au même titre que `/auth/*`, déjà toujours réel).
   return next(req);
 };

apps/frontend/src/app/core/mocks/alerts.fixture.ts

@@ -2,63 +2,53 @@ import { Alert } from '../../shared/models/alert.model';
 
 export const ALERTS_FIXTURE: Alert[] = [
   {
-    alert_id: 5,
+    alert_id: 'ALR-SITE002-1718458320',
+    timestamp: '2026-09-15T11:12:00',
     site_id: 'SITE002',
-    timestamp: '2026-09-15T11:12:00Z',
-    type: 'threshold',
     severity: 'critical',
-    message: 'Puissance appelée 812.5 kW au-dessus de la capacité du site (720.0 kW)',
+    type: 'outage',
+    message: 'Risque de surcharge sur Usine Lyon Vénissieux',
     value: 812.5,
     threshold: 720.0,
-    metric: 'consumption_kw',
-    prediction_id: null,
   },
   {
-    alert_id: 4,
+    alert_id: 'ALR-SITE003-1718458321',
+    timestamp: '2026-09-15T11:05:00',
     site_id: 'SITE003',
-    timestamp: '2026-09-15T11:05:00Z',
-    type: 'outage',
     severity: 'critical',
-    message: 'Aucune lecture depuis 5:00:00 (dernière lecture : 2026-09-15T06:05:00+00:00)',
-    value: null,
-    threshold: null,
-    metric: null,
-    prediction_id: null,
-  },
-  {
-    alert_id: 3,
-    site_id: 'SITE005',
-    timestamp: '2026-09-15T10:47:00Z',
-    type: 'spike',
-    severity: 'high',
-    message: 'Variation brutale entre deux lectures consécutives (260.0 kW -> 410.0 kW)',
-    value: 410.0,
-    threshold: 260.0,
-    metric: 'consumption_kw',
-    prediction_id: null,
-  },
-  {
-    alert_id: 2,
-    site_id: 'SITE006',
-    timestamp: '2026-09-15T10:30:00Z',
     type: 'sensor',
-    severity: 'medium',
-    message: 'Qualité de mesure degraded (capteur hors ligne, valeur nulle)',
-    value: null,
-    threshold: null,
-    metric: null,
-    prediction_id: null,
+    message: 'Perte réseau totale sur Data Center Marseille',
+    value: 0,
+    threshold: 0,
   },
   {
-    alert_id: 1,
+    alert_id: 'ALR-SITE005-1718458322',
+    timestamp: '2026-09-15T10:47:00',
+    site_id: 'SITE005',
+    severity: 'high',
+    type: 'threshold',
+    message: 'Usine Toulouse approche de son seuil de capacité',
+    value: 410.0,
+    threshold: 480.0,
+  },
+  {
+    alert_id: 'ALR-SITE006-1718458323',
+    timestamp: '2026-09-15T10:30:00',
+    site_id: 'SITE006',
+    severity: 'medium',
+    type: 'sensor',
+    message: 'Capteur de température défaillant sur Bureau Lille',
+    value: 0,
+    threshold: 0,
+  },
+  {
+    alert_id: 'ALR-SITE004-1718458324',
+    timestamp: '2026-09-15T09:58:00',
     site_id: 'SITE004',
-    timestamp: '2026-09-15T09:58:00Z',
-    type: 'anomaly',
     severity: 'low',
-    message: 'Écart de 13% entre la consommation mesurée (62.0 kWh) et la prévision (55.0 kWh)',
+    type: 'anomaly',
+    message: 'Comportement de consommation inhabituel sur Bureau Bordeaux',
     value: 62.0,
     threshold: 55.0,
-    metric: 'consumption_kwh',
-    prediction_id: 42,
   },
 ];

apps/frontend/src/app/core/services/alerts.service.spec.ts

@@ -3,20 +3,6 @@ import { provideHttpClient } from '@angular/common/http';
 import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
 import { AlertsService } from './alerts.service';
 import { environment } from '../../../environments/environment';
-import { Alert } from '../../shared/models/alert.model';
-
-const ALERT_API: Alert = {
-  alert_id: 1,
-  site_id: 'site-1',
-  timestamp: '2026-09-16T00:00:00Z',
-  type: 'threshold',
-  severity: 'high',
-  message: 'Dépassement du seuil configuré',
-  value: 812.5,
-  threshold: 720.0,
-  metric: 'consumption_kw',
-  prediction_id: null,
-};
 
 describe('AlertsService', () => {
   let service: AlertsService;
@@ -32,35 +18,26 @@ describe('AlertsService', () => {
 
   afterEach(() => httpMock.verify());
 
-  it("appelle le bon endpoint sans paramètre et retourne un tableau d'alertes", () => {
-    let result: Alert[] = [];
+  it("appelle le bon endpoint et retourne un tableau d'alertes", () => {
+    let result: unknown;
     service.getAlerts().subscribe((r) => (result = r));
 
-    const req = httpMock.expectOne(
-      (r) => r.url === `${environment.apiUrl}/alerts` && r.method === 'GET',
-    );
-    expect(req.request.params.keys()).toEqual([]);
-    req.flush([ALERT_API]);
+    const req = httpMock.expectOne(`${environment.apiUrl}/alerts`);
+    expect(req.request.method).toBe('GET');
 
-    expect(result.length).toBe(1);
-    expect(result[0].alert_id).toBe(1);
-    expect(result[0].prediction_id).toBeNull();
-  });
+    req.flush([
+      {
+        alert_id: 'ALR-TEST-1',
+        timestamp: '2026-09-15T12:00:00',
+        site_id: 'SITE001',
+        severity: 'high',
+        type: 'threshold',
+        message: 'Test',
+        value: 100,
+        threshold: 90,
+      },
+    ]);
 
-  it('transmet les filtres site_id et severity en paramètres de requête', () => {
-    service.getAlerts({ site_id: 'SITE001', severity: 'high' }).subscribe();
-
-    const req = httpMock.expectOne((r) => r.url === `${environment.apiUrl}/alerts`);
-    expect(req.request.params.get('site_id')).toBe('SITE001');
-    expect(req.request.params.get('severity')).toBe('high');
-    req.flush([]);
-  });
-
-  it('ne pose pas de paramètre pour un filtre omis', () => {
-    service.getAlerts({ site_id: 'SITE001' }).subscribe();
-
-    const req = httpMock.expectOne((r) => r.url === `${environment.apiUrl}/alerts`);
-    expect(req.request.params.has('severity')).toBe(false);
-    req.flush([]);
+    expect((result as unknown[]).length).toBe(1);
   });
 });

apps/frontend/src/app/core/services/alerts.service.ts

@@ -1,25 +1,13 @@
 import { Service, inject } from '@angular/core';
-import { HttpClient, HttpParams } from '@angular/common/http';
+import { HttpClient } from '@angular/common/http';
 import { environment } from '../../../environments/environment';
-import { Alert, AlertSeverity } from '../../shared/models/alert.model';
-
-export interface AlertFilters {
-  site_id?: string;
-  severity?: AlertSeverity;
-}
+import { Alert } from '../../shared/models/alert.model';
 
 @Service()
 export class AlertsService {
   private http = inject(HttpClient);
 
-  getAlerts(filters: AlertFilters = {}) {
-    let params = new HttpParams();
-    if (filters.site_id) {
-      params = params.set('site_id', filters.site_id);
-    }
-    if (filters.severity) {
-      params = params.set('severity', filters.severity);
-    }
-    return this.http.get<Alert[]>(`${environment.apiUrl}/alerts`, { params });
+  getAlerts() {
+    return this.http.get<Alert[]>(`${environment.apiUrl}/alerts`);
   }
 }

apps/frontend/src/app/core/services/predictions.service.spec.ts

@@ -1,35 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { provideHttpClient } from '@angular/common/http';
-import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
-import { PredictionsService } from './predictions.service';
-import { environment } from '../../../environments/environment';
-
-describe('PredictionsService', () => {
-  let service: PredictionsService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideHttpClient(), provideHttpClientTesting()],
-    });
-    service = TestBed.inject(PredictionsService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => httpMock.verify());
-
-  it('appelle le bon endpoint et retourne un résumé de prévisions', () => {
-    let result: unknown;
-    service.getPredictions().subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/predictions`);
-    expect(req.request.method).toBe('GET');
-
-    req.flush({
-      timestamp: '2026-09-18T09:00:00Z',
-      sites: [{ site_id: 'SITE001', site_name: 'Test', prediction: null }],
-    });
-
-    expect((result as { sites: unknown[] }).sites.length).toBe(1);
-  });
-});

apps/frontend/src/app/core/services/predictions.service.ts

@@ -1,13 +0,0 @@
-import { Service, inject } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { environment } from '../../../environments/environment';
-import { PredictionSummary } from '../../shared/models/prediction.model';
-
-@Service()
-export class PredictionsService {
-  private http = inject(HttpClient);
-
-  getPredictions() {
-    return this.http.get<PredictionSummary>(`${environment.apiUrl}/predictions`);
-  }
-}

apps/frontend/src/app/core/services/readings.service.spec.ts

@@ -1,50 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { provideHttpClient } from '@angular/common/http';
-import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
-import { ReadingsService } from './readings.service';
-import { environment } from '../../../environments/environment';
-
-describe('ReadingsService', () => {
-  let service: ReadingsService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideHttpClient(), provideHttpClientTesting()],
-    });
-    service = TestBed.inject(ReadingsService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => httpMock.verify());
-
-  it("demande l'historique du site avec la fenêtre temporelle donnée", () => {
-    let result: unknown;
-    service
-      .getHistory('SITE001', '2026-09-16T00:00:00Z', '2026-09-17T00:00:00Z')
-      .subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(
-      (r) => r.url === `${environment.apiUrl}/readings` && r.method === 'GET',
-    );
-    expect(req.request.params.get('site_id')).toBe('SITE001');
-    expect(req.request.params.get('start')).toBe('2026-09-16T00:00:00Z');
-    expect(req.request.params.get('end')).toBe('2026-09-17T00:00:00Z');
-
-    req.flush([{ reading_id: 1, site_id: 'SITE001', consumption_kw: 12.5 }]);
-
-    expect((result as unknown[]).length).toBe(1);
-  });
-
-  it('ne pose pas de paramètres start/end quand ils sont omis', () => {
-    service.getHistory('SITE001').subscribe();
-
-    const req = httpMock.expectOne(
-      (r) => r.url === `${environment.apiUrl}/readings` && r.method === 'GET',
-    );
-    expect(req.request.params.has('start')).toBe(false);
-    expect(req.request.params.has('end')).toBe(false);
-
-    req.flush([]);
-  });
-});

apps/frontend/src/app/core/services/readings.service.ts

@@ -1,20 +0,0 @@
-import { Service, inject } from '@angular/core';
-import { HttpClient, HttpParams } from '@angular/common/http';
-import { environment } from '../../../environments/environment';
-import { Reading } from '../../shared/models/reading.model';
-
-@Service()
-export class ReadingsService {
-  private http = inject(HttpClient);
-
-  getHistory(siteId: string, start?: string, end?: string) {
-    let params = new HttpParams().set('site_id', siteId);
-    if (start) {
-      params = params.set('start', start);
-    }
-    if (end) {
-      params = params.set('end', end);
-    }
-    return this.http.get<Reading[]>(`${environment.apiUrl}/readings`, { params });
-  }
-}

apps/frontend/src/app/core/services/recommendations.service.spec.ts

@@ -1,74 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { provideHttpClient } from '@angular/common/http';
-import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
-import { RecommendationsService } from './recommendations.service';
-import { environment } from '../../../environments/environment';
-import { Recommendation } from '../../shared/models/recommendation.model';
-
-const RECOMMANDATION_API: Recommendation = {
-  recommendation_id: 1,
-  alert_id: 1,
-  action: 'Vérifier la consommation',
-  explanation: 'Pic détecté',
-  rule_reference: 'spike-v1',
-  created_at: '2024-01-01T00:00:00Z',
-};
-
-describe('RecommendationsService', () => {
-  let service: RecommendationsService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideHttpClient(), provideHttpClientTesting()],
-    });
-    service = TestBed.inject(RecommendationsService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => httpMock.verify());
-
-  it('liste les recommandations depuis le bon endpoint', () => {
-    let result: Recommendation[] = [];
-    service.getRecommendations().subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/recommendations`);
-    expect(req.request.method).toBe('GET');
-    req.flush([RECOMMANDATION_API]);
-
-    expect(result.length).toBe(1);
-    expect(result[0].alert_id).toBe(1);
-  });
-
-  it('décrit une recommandation par son identifiant', () => {
-    service.getRecommendation(42).subscribe();
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/recommendations/42`);
-    expect(req.request.method).toBe('GET');
-    req.flush({ ...RECOMMANDATION_API, recommendation_id: 42 });
-  });
-
-  it('déclenche la génération en POST avec le site en paramètre de requête', () => {
-    let result: unknown;
-    service.generate('SITE001').subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(
-      (r) => r.url === `${environment.apiUrl}/recommendations/generate` && r.method === 'POST',
-    );
-    expect(req.request.params.get('site_id')).toBe('SITE001');
-    expect(req.request.body).toBeNull();
-    req.flush({ alerts_examined: 2, recommendations_created: 3, already_present: 1 });
-
-    expect(result).toEqual({ alerts_examined: 2, recommendations_created: 3, already_present: 1 });
-  });
-
-  it('génère pour tout le parc quand aucun site n’est donné', () => {
-    service.generate().subscribe();
-
-    const req = httpMock.expectOne(
-      (r) => r.url === `${environment.apiUrl}/recommendations/generate` && r.method === 'POST',
-    );
-    expect(req.request.params.has('site_id')).toBe(false);
-    req.flush({ alerts_examined: 0, recommendations_created: 0, already_present: 0 });
-  });
-});

apps/frontend/src/app/core/services/recommendations.service.ts

@@ -1,34 +0,0 @@
-import { Service, inject } from '@angular/core';
-import { HttpClient, HttpParams } from '@angular/common/http';
-import { environment } from '../../../environments/environment';
-import {
-  Recommendation,
-  RecommendationGenerationReport,
-} from '../../shared/models/recommendation.model';
-
-@Service()
-export class RecommendationsService {
-  private http = inject(HttpClient);
-
-  getRecommendations() {
-    return this.http.get<Recommendation[]>(`${environment.apiUrl}/recommendations`);
-  }
-
-  getRecommendation(recommendationId: number) {
-    return this.http.get<Recommendation>(
-      `${environment.apiUrl}/recommendations/${recommendationId}`,
-    );
-  }
-
-  generate(siteId?: string) {
-    let params = new HttpParams();
-    if (siteId) {
-      params = params.set('site_id', siteId);
-    }
-    return this.http.post<RecommendationGenerationReport>(
-      `${environment.apiUrl}/recommendations/generate`,
-      null,
-      { params },
-    );
-  }
-}

apps/frontend/src/app/core/services/sensors.service.spec.ts

@@ -1,48 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { provideHttpClient } from '@angular/common/http';
-import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
-import { SensorsService } from './sensors.service';
-import { environment } from '../../../environments/environment';
-
-describe('SensorsService', () => {
-  let service: SensorsService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideHttpClient(), provideHttpClientTesting()],
-    });
-    service = TestBed.inject(SensorsService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => httpMock.verify());
-
-  it("appelle l'endpoint /sensors/status et retourne la réponse", () => {
-    let result: unknown;
-    service.getStatus().subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/sensors/status`);
-    expect(req.request.method).toBe('GET');
-
-    req.flush({
-      timestamp: '2026-09-18T08:00:00',
-      sites: [
-        {
-          site_id: 'SITE001',
-          site_name: 'Test',
-          overall: 'ok',
-          sensors: {
-            consumption: { status: 'ok', since: null },
-            electrical: { status: 'ok', since: null },
-            temperature: { status: 'ok', since: null },
-            humidity: { status: 'ok', since: null },
-            network: { status: 'ok', since: null },
-          },
-        },
-      ],
-    });
-
-    expect((result as { sites: unknown[] }).sites.length).toBe(1);
-  });
-});

apps/frontend/src/app/core/services/sensors.service.ts

@@ -1,13 +0,0 @@
-import { Service, inject } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { environment } from '../../../environments/environment';
-import {SensorStatusResponse} from '../../shared/models/sensor-status.model';
-
-@Service()
-export class SensorsService {
-  private http = inject(HttpClient);
-
-  getStatus() {
-    return this.http.get<SensorStatusResponse>(`${environment.apiUrl}/sensors/status`);
-  }
-}

apps/frontend/src/app/core/services/sites.service.spec.ts

@@ -38,50 +38,4 @@ describe('SitesService', () => {
 
     expect((result as { site_id: string }[])[0].site_id).toBe('SITE001');
   });
-
-  it('appelle le bon endpoint et retourne un site', () => {
-    let result: unknown;
-    service.getSite('SITE001').subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/sites/SITE001`);
-    expect(req.request.method).toBe('GET');
-
-    req.flush({
-      site_id: 'SITE001',
-      site_name: 'Site 1',
-      site_type: 'industriel',
-      location: 'Nantes',
-      capacity_kw: 500,
-      status: 'actif',
-    });
-
-    expect((result as { site_id: string }).site_id).toBe('SITE001');
-  });
-
-  it('appelle le bon endpoint et retourne la mesure courante du site', () => {
-    let result: unknown;
-    service.getCurrent('SITE001').subscribe((r) => (result = r));
-
-    const req = httpMock.expectOne(`${environment.apiUrl}/sites/SITE001/current`);
-    expect(req.request.method).toBe('GET');
-
-    req.flush({
-      timestamp: '2026-09-17T10:00:00Z',
-      site_id: 'SITE001',
-      site_type: 'industriel',
-      consumption_kw: 120,
-      consumption_kwh: null,
-      voltage_v: null,
-      current_a: null,
-      power_factor: null,
-      temperature_celsius: 22,
-      humidity_percent: 55,
-      null_reasons: ['electrical_sensor_failure'],
-      data_quality: 'partial',
-    });
-
-    expect((result as { null_reasons: string[] }).null_reasons).toEqual([
-      'electrical_sensor_failure',
-    ]);
-  });
 });

apps/frontend/src/app/core/services/sites.service.ts

@@ -2,7 +2,6 @@ import { Service, inject } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 import { environment } from '../../../environments/environment';
 import { Site } from '../../shared/models/site.model';
-import { SiteCurrent } from '../../shared/models/site-current.model';
 
 @Service()
 export class SitesService {
@@ -11,12 +10,4 @@ export class SitesService {
   getSites() {
     return this.http.get<Site[]>(`${environment.apiUrl}/sites`);
   }
-
-  getSite(siteId: string) {
-    return this.http.get<Site>(`${environment.apiUrl}/sites/${siteId}`);
-  }
-
-  getCurrent(siteId: string) {
-    return this.http.get<SiteCurrent>(`${environment.apiUrl}/sites/${siteId}/current`);
-  }
 }

apps/frontend/src/app/features/dashboard/dashboard.html

@@ -10,11 +10,7 @@
       </div>
     </div>
     <div class="dashboard__actions">
-      @if (auth.principal()?.role === 'admin') {
-        <a routerLink="/monitoring/sensors" class="ev-link">Supervision des capteurs</a>
-      }
       <a routerLink="/sites" class="ev-link">Voir les sites</a>
-      <a routerLink="/recommendations" class="ev-link">Recommandations</a>
       <ev-button
         class="logout-button"
         variant="secondary"
@@ -25,123 +21,55 @@
     </div>
   </header>
 
-  @if (statsError(); as message) {
-    <ev-alert severity="danger" class="banner-error">{{ message }}</ev-alert>
-  }
-  @if (predictionsError(); as message) {
+  @if (error(); as message) {
     <ev-alert severity="danger" class="banner-error">{{ message }}</ev-alert>
   }
 
   @if (stats(); as s) {
-    <p class="dashboard__status">
-      <span class="dashboard__pulse" aria-hidden="true"></span>
-      Actualisé à {{ s.timestamp | date: 'HH:mm:ss' }} · {{ s.total_sites }} sites suivis
-    </p>
-
-    <section class="overview" aria-label="Indicateurs du parc">
-      <ev-card class="kpi kpi--gauge">
-        <span class="kpi__label">Consommation vs capacité</span>
+    <section class="overview">
+      <ev-card class="card card--gauge">
+        <span class="card__label">Consommation vs capacité</span>
         <app-consumption-gauge
           [consumption]="s.total_consumption_kw"
           [capacity]="s.total_capacity_kw"
         />
-        <span class="kpi__value">
-          {{ s.total_consumption_kw | number: '1.0-1' }}
-          <small>/ {{ s.total_capacity_kw | number }} kW</small>
-        </span>
+        <span class="card__value"
+          >{{ s.total_consumption_kw | number: '1.0-1' }} /
+          {{ s.total_capacity_kw | number }} kW</span
+        >
       </ev-card>
 
-      <ev-card class="kpi">
-        <span class="kpi__label">Charge moyenne du parc</span>
-        <span class="kpi__value"
-          >{{ s.average_load_percent | number: '1.0-0' }} <small>%</small></span
-        >
-        <div
-          class="progress-bar"
-          role="progressbar"
-          aria-valuemin="0"
-          aria-valuemax="100"
-          [attr.aria-valuenow]="s.average_load_percent"
-        >
-          <div
-            class="progress-bar__fill"
-            [class]="'progress-bar__fill--' + loadTone(s.average_load_percent)"
-            [style.width.%]="s.average_load_percent"
-          ></div>
+      <ev-card class="card">
+        <span class="card__label">Charge moyenne du parc</span>
+        <span class="card__value">{{ s.average_load_percent }} %</span>
+        <div class="progress-bar">
+          <div class="progress-bar__fill" [style.width.%]="s.average_load_percent"></div>
         </div>
-        <span class="kpi__hint">{{ loadHint(s.average_load_percent) }}</span>
       </ev-card>
 
-      <ev-card class="kpi">
-        <span class="kpi__label">Sites suivis</span>
-        <span class="kpi__value">{{ s.total_sites }}</span>
-        <a routerLink="/sites" class="ev-link kpi__link">Voir la liste des sites</a>
+      <ev-card class="card">
+        <span class="card__label">Sites suivis</span>
+        <span class="card__value">{{ s.total_sites }}</span>
       </ev-card>
     </section>
+
+    <section class="chart-section">
+      <h2>Charge et alerte visuelle par site</h2>
+      <app-site-load-chart [sites]="s.sites" />
+    </section>
   }
 
-  <div class="dashboard__grid">
-    <div class="dashboard__main">
-      @if (stats(); as s) {
-        <section class="chart-section">
-          <h2>Charge par site</h2>
-          <ev-card class="chart-card">
-            <app-site-load-chart [sites]="s.sites" />
-          </ev-card>
-        </section>
-      }
-
-      <section class="predictions-section">
-        <h2>Prévisions de consommation</h2>
-        @if (predictions().length > 0) {
-          <ev-card class="ev-table-card">
-            <table class="ev-table">
-              <thead>
-                <tr>
-                  <th>Site</th>
-                  <th>Prévision</th>
-                  <th>Échéance</th>
-                  <th></th>
-                </tr>
-              </thead>
-              <tbody>
-                @for (site of predictions(); track site.site_id) {
-                  <tr>
-                    <td>{{ site.site_name }}</td>
-                    @if (site.prediction; as prediction) {
-                      @if (prediction.status === 'available') {
-                        <td class="ev-table__number">
-                          {{ prediction.predicted_value | number: '1.0-1' }} kWh
-                        </td>
-                        <td>{{ prediction.target_at | date: "dd/MM 'à' HH:mm" }}</td>
-                      } @else {
-                        <td>
-                          <ev-badge [tone]="badgeToneForPredictionStatus(prediction.status)">{{
-                            prediction.status === 'insufficient_data'
-                              ? 'Historique insuffisant'
-                              : 'Erreur'
-                          }}</ev-badge>
-                        </td>
-                        <td class="ev-table__muted">-</td>
-                      }
-                    } @else {
-                      <td><ev-badge tone="neutral">Pas encore de prévision</ev-badge></td>
-                      <td class="ev-table__muted">-</td>
-                    }
-                    <td><a [routerLink]="['/sites', site.site_id]" class="ev-link">Détail</a></td>
-                  </tr>
-                }
-              </tbody>
-            </table>
-          </ev-card>
-        } @else if (!predictionsError()) {
-          <p class="dashboard__empty">Aucune prévision disponible pour le moment.</p>
+  @if (alerts().length > 0) {
+    <section class="alerts-section">
+      <h2>Alertes actives</h2>
+      <ul class="alerts-list">
+        @for (alert of alerts(); track alert.alert_id) {
+          <li class="alert-item">
+            <ev-badge [tone]="badgeToneForSeverity(alert.severity)">{{ alert.severity }}</ev-badge>
+            <span class="alert-item__message">{{ alert.message }}</span>
+          </li>
         }
-      </section>
-    </div>
-
-    <aside class="dashboard__side" aria-label="Alertes actives">
-      <app-alert-feed />
-    </aside>
-  </div>
+      </ul>
+    </section>
+  }
 </div>

apps/frontend/src/app/features/dashboard/dashboard.scss

@@ -8,11 +8,9 @@
 
 .dashboard__header {
   display: flex;
-  flex-wrap: wrap;
   align-items: flex-start;
   justify-content: space-between;
-  gap: var(--space-3);
-  margin-bottom: var(--space-3);
+  margin-bottom: 2rem;
 }
 
 .dashboard__brand {
@@ -22,9 +20,8 @@
 
   h1 {
     margin: 0;
-    font-size: var(--font-size-xl);
+    font-size: 1.75rem;
     font-weight: 700;
-    letter-spacing: -0.01em;
   }
 }
 
@@ -34,69 +31,19 @@
 
 .dashboard__subtitle {
   margin: 0.25rem 0 0;
-  font-size: var(--font-size-sm);
   color: var(--color-text-muted);
 }
 
 .dashboard__actions {
   display: flex;
-  flex-wrap: wrap;
   align-items: center;
-  gap: var(--space-2);
-
-  .ev-link {
-    padding: 0.45rem 0.9rem;
-    border-radius: var(--radius-pill);
-    background: var(--color-primary-light);
-    color: var(--color-primary-hover);
-    font-size: var(--font-size-sm);
-    transition: background 0.15s ease;
-
-    &:hover {
-      background: var(--color-primary);
-      color: var(--color-text-inverse);
-      text-decoration: none;
-    }
-  }
-}
-
-.dashboard__status {
-  display: flex;
-  align-items: center;
-  gap: var(--space-2);
-  margin: 0 0 var(--space-4);
-  font-size: var(--font-size-sm);
-  color: var(--color-text-muted);
-}
-
-.dashboard__pulse {
-  width: 0.6rem;
-  height: 0.6rem;
-  border-radius: 50%;
-  background: var(--color-success);
-  animation: pulse 2s ease-out infinite;
-}
-
-@keyframes pulse {
-  0% {
-    box-shadow: 0 0 0 0 rgba(22, 163, 74, 0.45);
-  }
-
-  100% {
-    box-shadow: 0 0 0 8px rgba(22, 163, 74, 0);
-  }
-}
-
-@media (prefers-reduced-motion: reduce) {
-  .dashboard__pulse {
-    animation: none;
-  }
+  gap: 1rem;
 }
 
 h2 {
-  margin: 0 0 var(--space-3);
-  font-size: var(--font-size-lg);
+  font-size: 1.1rem;
   font-weight: 600;
+  margin: 0 0 1rem;
 }
 
 .banner-error {
@@ -107,124 +54,70 @@ h2 {
 .overview {
   display: grid;
   grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
-  gap: var(--space-3);
-  margin-bottom: var(--space-5);
+  gap: 1rem;
+  margin-bottom: 2.5rem;
 }
 
-.kpi {
-  position: relative;
-  overflow: hidden;
-  padding: var(--space-4);
-  gap: var(--space-1);
-  transition:
-    box-shadow 0.15s ease,
-    transform 0.15s ease;
-
-  &::before {
-    content: '';
-    position: absolute;
-    inset: 0 0 auto 0;
-    height: 3px;
-    background: var(--color-primary);
-  }
-
-  &:hover {
-    box-shadow: var(--shadow-card-hover);
-    transform: translateY(-1px);
-  }
+.card {
+  padding: 1.25rem;
+  gap: 0.35rem;
 }
 
-.kpi--gauge {
+.card--gauge {
   align-items: center;
   text-align: center;
 }
 
-.kpi__label {
-  font-size: var(--font-size-xs);
-  font-weight: 600;
+.card__label {
+  font-size: 0.8rem;
   color: var(--color-text-muted);
   text-transform: uppercase;
-  letter-spacing: 0.06em;
+  letter-spacing: 0.02em;
 }
 
-.kpi__value {
-  font-size: var(--font-size-2xl);
+.card__value {
+  font-size: 1.6rem;
   font-weight: 700;
-  line-height: 1.1;
-  font-variant-numeric: tabular-nums;
-
-  small {
-    font-size: var(--font-size-sm);
-    font-weight: 500;
-    color: var(--color-text-muted);
-  }
-}
-
-.kpi__hint {
-  font-size: var(--font-size-xs);
-  color: var(--color-text-muted);
-}
-
-.kpi__link {
-  margin-top: auto;
-  font-size: var(--font-size-sm);
 }
 
 .progress-bar {
-  height: 8px;
-  margin: var(--space-1) 0;
+  height: 6px;
   background: var(--color-border-light);
   border-radius: var(--radius-pill);
   overflow: hidden;
+  margin-top: 0.25rem;
 }
 
 .progress-bar__fill {
   height: 100%;
+  background: var(--color-primary);
   border-radius: var(--radius-pill);
-  background: var(--color-success);
   transition: width 0.3s ease;
 }
 
-.progress-bar__fill--warning {
-  background: var(--color-warning);
-}
-
-.progress-bar__fill--danger {
-  background: var(--color-danger);
-}
-
-.dashboard__grid {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) minmax(320px, 380px);
-  gap: var(--space-4);
-  align-items: start;
-}
-
-.dashboard__side {
-  position: sticky;
-  top: var(--space-3);
-}
-
 .chart-section {
-  margin-bottom: var(--space-5);
+  margin-bottom: 2.5rem;
 }
 
-.chart-card {
-  padding: var(--space-3);
-}
-
-.dashboard__empty {
+.alerts-list {
+  list-style: none;
   margin: 0;
-  font-size: var(--font-size-sm);
-  color: var(--color-text-muted);
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
 }
 
-@media (max-width: 900px) {
-  .dashboard__grid {
-    grid-template-columns: 1fr;
-  }
-
-  .dashboard__side {
-    position: static;
-  }
+.alert-item {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 0.7rem 1rem;
+  border-radius: var(--radius-md);
+  background: var(--color-danger-bg);
+  border: 1px solid var(--color-danger-border);
+}
+
+.alert-item__message {
+  font-size: 0.9rem;
 }

apps/frontend/src/app/features/dashboard/dashboard.spec.ts

@@ -1,13 +1,11 @@
 import { TestBed } from '@angular/core/testing';
 import { vi } from 'vitest';
-import { Observable, of, throwError } from 'rxjs';
-import { Router, provideRouter } from '@angular/router';
+import { of, throwError } from 'rxjs';
 import { Dashboard } from './dashboard';
 import { StatsService } from '../../core/services/stats.service';
 import { AlertsService } from '../../core/services/alerts.service';
-import { SitesService } from '../../core/services/sites.service';
-import { PredictionsService } from '../../core/services/predictions.service';
-import { AuthService } from '../../core/services/auth.service';
+import {AuthService} from '../../core/services/auth.service';
+import {Router, provideRouter} from '@angular/router';
 
 vi.mock('chart.js', () => {
   class ChartMock {
@@ -19,219 +17,166 @@ vi.mock('chart.js', () => {
   return { Chart: ChartMock, registerables: [] };
 });
 
-const STATS = { total_sites: 7, sites: [] };
-
-function predictionsMock(sites: unknown[] = []) {
-  return {
-    getPredictions: vi.fn().mockReturnValue(of({ timestamp: '2026-09-18T09:00:00Z', sites })),
-  };
-}
-
-function setup(
-  options: {
-    stats?: Observable<unknown>;
-    predictions?: { getPredictions: ReturnType<typeof vi.fn> };
-    auth?: Record<string, unknown>;
-  } = {},
-) {
-  const statsMock = { getSummary: vi.fn().mockReturnValue(options.stats ?? of(STATS)) };
-  const predictions = options.predictions ?? predictionsMock();
-  TestBed.configureTestingModule({
-    imports: [Dashboard],
-    providers: [
-      { provide: StatsService, useValue: statsMock },
-      { provide: AlertsService, useValue: { getAlerts: vi.fn().mockReturnValue(of([])) } },
-      { provide: SitesService, useValue: { getSites: vi.fn().mockReturnValue(of([])) } },
-      { provide: PredictionsService, useValue: predictions },
-      ...(options.auth ? [{ provide: AuthService, useValue: options.auth }] : []),
-      provideRouter([]),
-    ],
-  });
-  return { fixture: TestBed.createComponent(Dashboard), statsMock, predictions };
-}
-
 describe('Dashboard', () => {
   afterEach(() => vi.useRealTimers());
 
-  it('charge les stats et les prévisions au démarrage', async () => {
-    const { fixture, statsMock, predictions } = setup({
-      predictions: predictionsMock([{ site_id: 'SITE001', site_name: 'Test', prediction: null }]),
+  it('charge les stats et les alertes au démarrage', async () => {
+    const statsMock = { getSummary: vi.fn().mockReturnValue(of({ total_sites: 7, sites: [] })) };
+    const alertsMock = { getAlerts: vi.fn().mockReturnValue(of([{ alert_id: 'A1' }])) };
+
+    TestBed.configureTestingModule({
+      imports: [Dashboard],
+      providers: [
+        { provide: StatsService, useValue: statsMock },
+        { provide: AlertsService, useValue: alertsMock },
+        provideRouter([]),
+      ],
     });
 
+    const fixture = TestBed.createComponent(Dashboard);
     fixture.detectChanges();
+
+    // laisse le timer(0, ...) se déclencher avant de vérifier
     await new Promise((resolve) => setTimeout(resolve, 0));
     fixture.detectChanges();
 
     expect(statsMock.getSummary).toHaveBeenCalled();
-    expect(predictions.getPredictions).toHaveBeenCalled();
-    expect(fixture.componentInstance.predictions().length).toBe(1);
-    expect(fixture.componentInstance.statsError()).toBeNull();
-    expect(fixture.componentInstance.predictionsError()).toBeNull();
-  });
-
-  it('délègue les alertes au widget app-alert-feed', () => {
-    const { fixture } = setup();
-
-    fixture.detectChanges();
-
-    expect(fixture.nativeElement.querySelector('app-alert-feed')).not.toBeNull();
+    expect(alertsMock.getAlerts).toHaveBeenCalled();
+    expect(fixture.componentInstance.alerts().length).toBe(1);
+    expect(fixture.componentInstance.error()).toBeNull();
   });
 
   it("signale l'indisponibilité puis repart au rafraîchissement suivant", () => {
     vi.useFakeTimers();
-    const { fixture, statsMock } = setup({
-      stats: throwError(() => new Error('API injoignable')),
-    });
-    statsMock.getSummary
-      .mockReturnValueOnce(throwError(() => new Error('API injoignable')))
-      .mockReturnValue(of(STATS));
+    const statsMock = {
+      getSummary: vi
+        .fn()
+        .mockReturnValueOnce(throwError(() => new Error('API injoignable')))
+        .mockReturnValue(of({ total_sites: 7, sites: [] })),
+    };
+    const alertsMock = { getAlerts: vi.fn().mockReturnValue(of([])) };
 
+    TestBed.configureTestingModule({
+      imports: [Dashboard],
+      providers: [
+        { provide: StatsService, useValue: statsMock },
+        { provide: AlertsService, useValue: alertsMock },
+        provideRouter([]),
+      ],
+    });
+
+    const fixture = TestBed.createComponent(Dashboard);
     fixture.detectChanges();
 
     vi.advanceTimersByTime(1);
     expect(statsMock.getSummary).toHaveBeenCalledTimes(1);
-    expect(fixture.componentInstance.statsError()).not.toBeNull();
+    expect(fixture.componentInstance.error()).not.toBeNull();
     expect(fixture.componentInstance.stats()).toBeNull();
 
     vi.advanceTimersByTime(10000);
     expect(statsMock.getSummary).toHaveBeenCalledTimes(2);
     expect(fixture.componentInstance.stats()).not.toBeNull();
-    expect(fixture.componentInstance.statsError()).toBeNull();
+    expect(fixture.componentInstance.error()).toBeNull();
   });
 
-  it("n'interrompt pas la page quand le chargement des prévisions échoue", () => {
-    const { fixture } = setup({
-      predictions: { getPredictions: vi.fn().mockReturnValue(throwError(() => new Error('nope'))) },
+  it("n'interrompt pas la page quand le chargement des alertes échoue", () => {
+    const statsMock = { getSummary: vi.fn().mockReturnValue(of({ total_sites: 7, sites: [] })) };
+    const alertsMock = { getAlerts: vi.fn().mockReturnValue(throwError(() => new Error('nope'))) };
+
+    TestBed.configureTestingModule({
+      imports: [Dashboard],
+      providers: [
+        { provide: StatsService, useValue: statsMock },
+        { provide: AlertsService, useValue: alertsMock },
+        provideRouter([]),
+      ],
     });
 
+    const fixture = TestBed.createComponent(Dashboard);
     fixture.detectChanges();
 
-    expect(fixture.componentInstance.predictions().length).toBe(0);
-    expect(fixture.componentInstance.predictionsError()).not.toBeNull();
-  });
-
-  it("un rafraîchissement de stats n'efface pas une erreur de prévisions en attente", () => {
-    vi.useFakeTimers();
-    const { fixture } = setup({
-      predictions: { getPredictions: vi.fn().mockReturnValue(throwError(() => new Error('nope'))) },
-    });
-
-    fixture.detectChanges();
-    expect(fixture.componentInstance.predictionsError()).not.toBeNull();
-
-    // Plusieurs cycles de `timer(0, 10_000)` (stats) plus tard, l'erreur des prévisions doit
-    // toujours être visible : rien ne vient la rafraîchir tant que la section n'est pas rechargée.
-    vi.advanceTimersByTime(30000);
-
-    expect(fixture.componentInstance.predictionsError()).not.toBeNull();
-    expect(fixture.componentInstance.statsError()).toBeNull();
+    expect(fixture.componentInstance.alerts().length).toBe(0);
   });
 
   it('appelle logout et redirige vers /login au clic sur le bouton de déconnexion', () => {
-    const authMock = {
-      logout: vi.fn().mockReturnValue(of(undefined)),
-      clearSession: vi.fn(),
-      principal: vi.fn().mockReturnValue({ role: 'admin' }),
-    };
-    const { fixture } = setup({ auth: authMock });
-    fixture.detectChanges();
-    const router = TestBed.inject(Router);
-    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+  const statsMock = { getSummary: vi.fn().mockReturnValue(of({ total_sites: 7, sites: [] })) };
+  const alertsMock = { getAlerts: vi.fn().mockReturnValue(of([])) };
+  const authMock = { logout: vi.fn().mockReturnValue(of(undefined)), clearSession: vi.fn() };
 
-    fixture.nativeElement.querySelector('.logout-button').click();
-
-    expect(authMock.logout).toHaveBeenCalled();
-    expect(navigateSpy).toHaveBeenCalledWith(['/login']);
+  TestBed.configureTestingModule({
+    imports: [Dashboard],
+    providers: [
+      { provide: StatsService, useValue: statsMock },
+      { provide: AlertsService, useValue: alertsMock },
+      { provide: AuthService, useValue: authMock },
+      provideRouter([]),
+    ],
   });
 
+  const fixture = TestBed.createComponent(Dashboard);
+  fixture.detectChanges();
+
+  const router = TestBed.inject(Router);
+  const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+  const button = fixture.nativeElement.querySelector('.logout-button');
+  button.click();
+
+  expect(authMock.logout).toHaveBeenCalled();
+  expect(navigateSpy).toHaveBeenCalledWith(['/login']);
+  });
   it('déconnecte localement et redirige vers /login même si logout échoue côté réseau', () => {
-    const authMock = {
-      logout: vi.fn().mockReturnValue(throwError(() => new Error('réseau indisponible'))),
-      clearSession: vi.fn(),
-      principal: vi.fn().mockReturnValue({ role: 'admin' }),
-    };
-    const { fixture } = setup({ auth: authMock });
-    fixture.detectChanges();
-    const router = TestBed.inject(Router);
-    const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
-
-    fixture.nativeElement.querySelector('.logout-button').click();
-
-    expect(authMock.clearSession).toHaveBeenCalled();
-    expect(navigateSpy).toHaveBeenCalledWith(['/login']);
+  const statsMock = { getSummary: vi.fn().mockReturnValue(of({ total_sites: 7, sites: [] })) };
+  const alertsMock = { getAlerts: vi.fn().mockReturnValue(of([])) };
+  const authMock = {
+    logout: vi.fn().mockReturnValue(throwError(() => new Error('réseau indisponible'))),
+    clearSession: vi.fn(),
+  };
+  TestBed.configureTestingModule({
+    imports: [Dashboard],
+    providers: [
+      { provide: StatsService, useValue: statsMock },
+      { provide: AlertsService, useValue: alertsMock },
+      { provide: AuthService, useValue: authMock },
+      provideRouter([]),
+    ],
   });
 
-  it('affiche l’heure du dernier relevé et les indicateurs du parc', () => {
-    vi.useFakeTimers();
-    const { fixture } = setup({
-      stats: of({
-        timestamp: '2026-09-18T09:00:00Z',
-        total_sites: 7,
-        total_consumption_kw: 1234.5,
-        total_capacity_kw: 5000,
-        average_load_percent: 24.7,
-        sites: [],
-      }),
+  const fixture = TestBed.createComponent(Dashboard);
+  fixture.detectChanges();
+
+  const router = TestBed.inject(Router);
+  const navigateSpy = vi.spyOn(router, 'navigate').mockResolvedValue(true);
+
+  const button = fixture.nativeElement.querySelector('.logout-button');
+  button.click();
+
+  expect(authMock.clearSession).toHaveBeenCalled();
+  expect(navigateSpy).toHaveBeenCalledWith(['/login']);
+});
+
+  it('distingue le ton des sévérités high et critical', () => {
+    const statsMock = { getSummary: vi.fn().mockReturnValue(of({ total_sites: 7, sites: [] })) };
+    const alertsMock = { getAlerts: vi.fn().mockReturnValue(of([])) };
+
+    TestBed.configureTestingModule({
+      imports: [Dashboard],
+      providers: [
+        { provide: StatsService, useValue: statsMock },
+        { provide: AlertsService, useValue: alertsMock },
+        provideRouter([]),
+      ],
     });
 
-    fixture.detectChanges();
-    vi.advanceTimersByTime(1);
-    fixture.detectChanges();
-
-    const texte = fixture.nativeElement.textContent as string;
-    expect(texte).toContain('Actualisé à');
-    expect(texte).toContain('7 sites suivis');
-    expect(texte).toContain('Marge confortable');
-    expect(fixture.nativeElement.querySelector('.progress-bar__fill--success')).not.toBeNull();
-  });
-
-  it('présente les prévisions en tableau avec un lien vers chaque site', () => {
-    const { fixture } = setup({
-      predictions: predictionsMock([
-        {
-          site_id: 'SITE001',
-          site_name: 'Usine Nantes',
-          prediction: {
-            target_at: '2026-09-18T10:00:00Z',
-            target_metric: 'consumption_kwh',
-            period_minutes: 60,
-            predicted_value: 118.4,
-            status: 'available',
-            failure_reason: null,
-            model_reference: 'lightgbm-v1',
-            created_at: '2026-09-18T09:00:00Z',
-          },
-        },
-        { site_id: 'SITE002', site_name: 'Bureau Lille', prediction: null },
-      ]),
-    });
-
-    fixture.detectChanges();
-
-    const table = fixture.nativeElement.querySelector('table.ev-table');
-    expect(table).not.toBeNull();
-    expect(table.textContent).toContain('118.4 kWh');
-    expect(table.textContent).toContain('Pas encore de prévision');
-    expect(fixture.nativeElement.querySelector('a[href="/sites/SITE001"]')).not.toBeNull();
-  });
-
-  it('colore la charge moyenne selon les seuils 70 % et 90 %', () => {
-    const { fixture } = setup();
+    const fixture = TestBed.createComponent(Dashboard);
     const dashboard = fixture.componentInstance;
 
-    expect(dashboard.loadTone(69.9)).toBe('success');
-    expect(dashboard.loadTone(70)).toBe('warning');
-    expect(dashboard.loadTone(89.9)).toBe('warning');
-    expect(dashboard.loadTone(90)).toBe('danger');
-    expect(dashboard.loadHint(95)).toBe('Proche de la capacité du parc');
-  });
-
-  it('distingue le ton des statuts de prévision', () => {
-    const { fixture } = setup();
-    const dashboard = fixture.componentInstance;
-
-    expect(dashboard.badgeToneForPredictionStatus('available')).toBe('success');
-    expect(dashboard.badgeToneForPredictionStatus('insufficient_data')).toBe('warning');
-    expect(dashboard.badgeToneForPredictionStatus('error')).toBe('danger');
+    expect(dashboard.badgeToneForSeverity('low')).toBe('success');
+    expect(dashboard.badgeToneForSeverity('medium')).toBe('warning');
+    expect(dashboard.badgeToneForSeverity('high')).toBe('danger');
+    expect(dashboard.badgeToneForSeverity('critical')).toBe('critical');
+    expect(dashboard.badgeToneForSeverity('high')).not.toBe(
+      dashboard.badgeToneForSeverity('critical'),
+    );
   });
 });

apps/frontend/src/app/features/dashboard/dashboard.ts

@@ -1,16 +1,15 @@
-import { Component, OnInit, inject, signal, DestroyRef, WritableSignal } from '@angular/core';
+import { Component, OnInit, inject, signal, DestroyRef } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { timer, switchMap, catchError, EMPTY, Observable } from 'rxjs';
-import { DecimalPipe, DatePipe } from '@angular/common';
+import { DecimalPipe } from '@angular/common';
 import { Router, RouterLink } from '@angular/router';
 import { StatsService } from '../../core/services/stats.service';
 import { ConsumptionGauge } from '../../shared/components/consumption-gauge/consumption-gauge';
 import { SiteLoadChart } from '../../shared/components/site-load-chart/site-load-chart';
-import { AlertFeed } from '../../shared/components/alert-feed/alert-feed';
-import { PredictionsService } from '../../core/services/predictions.service';
+import { AlertsService } from '../../core/services/alerts.service';
 import { AuthService } from '../../core/services/auth.service';
 import { StatsSummary } from '../../shared/models/stats.model';
-import { PredictionStatus, SitePredictionSummary } from '../../shared/models/prediction.model';
+import { Alert, AlertSeverity } from '../../shared/models/alert.model';
 import { Card } from '../../shared/components/ui/card/card';
 import { Alert as EvAlert } from '../../shared/components/ui/alert/alert';
 import { Badge, BadgeTone } from '../../shared/components/ui/badge/badge';
@@ -21,29 +20,21 @@ const REFRESH_INTERVAL_MS = 10000;
 const UNAVAILABLE_MESSAGE =
   'Données indisponibles, les valeurs affichées datent du dernier relevé.';
 
-// `error` n'a pas encore de précédent côté API mais figure dans `ck_prediction_status` :
-// mieux vaut un ton défini que `undefined` le jour où ce statut apparaît.
-const TON_PAR_STATUT_PREDICTION: Record<PredictionStatus, BadgeTone> = {
-  available: 'success',
-  insufficient_data: 'warning',
-  error: 'danger',
+const TON_PAR_SEVERITE: Record<AlertSeverity, BadgeTone> = {
+  low: 'success',
+  medium: 'warning',
+  high: 'danger',
+  critical: 'critical',
 };
 
-const SEUIL_CHARGE_SOUTENUE = 70;
-const SEUIL_CHARGE_CRITIQUE = 90;
-
-export type LoadTone = 'success' | 'warning' | 'danger';
-
 @Component({
   selector: 'app-dashboard',
   standalone: true,
   imports: [
     DecimalPipe,
-    DatePipe,
     RouterLink,
     ConsumptionGauge,
     SiteLoadChart,
-    AlertFeed,
     Card,
     EvAlert,
     Badge,
@@ -55,67 +46,38 @@ export type LoadTone = 'success' | 'warning' | 'danger';
 })
 export class Dashboard implements OnInit {
   private statsService = inject(StatsService);
-  public auth = inject(AuthService);
-  private predictionsService = inject(PredictionsService);
+  private alertsService = inject(AlertsService);
+  private auth = inject(AuthService);
   private router = inject(Router);
   private destroyRef = inject(DestroyRef);
 
   stats = signal<StatsSummary | null>(null);
-  predictions = signal<SitePredictionSummary[]>([]);
-
-  // Piège : un signal d'erreur par flux, sinon le tick suivant de `timer` (stats) efface en
-  // silence l'échec des prévisions après 10 s au plus, sans retry ni indication à l'utilisateur.
-  statsError = signal<string | null>(null);
-  predictionsError = signal<string | null>(null);
+  alerts = signal<Alert[]>([]);
+  error = signal<string | null>(null);
 
   ngOnInit(): void {
-    // Les prévisions viennent d'un scoring hors ligne, pas d'un calcul à la demande : un seul
-    // chargement au démarrage suffit, pas besoin du rafraîchissement périodique de `stats`.
-    this.predictionsService
-      .getPredictions()
-      .pipe(catchError(() => this.reportUnavailable(this.predictionsError)))
-      .subscribe((summary) => {
-        this.predictionsError.set(null);
-        this.predictions.set(summary.sites);
-      });
+    this.alertsService
+      .getAlerts()
+      .pipe(catchError(() => this.reportUnavailable()))
+      .subscribe((alerts) => this.alerts.set(alerts));
 
     // Piège : le catchError porte sur l'observable interne. Sur le flux externe il
     // terminerait le timer, et le rafraîchissement ne repartirait jamais.
     timer(0, REFRESH_INTERVAL_MS)
       .pipe(
         switchMap(() =>
-          this.statsService
-            .getSummary()
-            .pipe(catchError(() => this.reportUnavailable(this.statsError))),
+          this.statsService.getSummary().pipe(catchError(() => this.reportUnavailable())),
         ),
         takeUntilDestroyed(this.destroyRef),
       )
       .subscribe((stats) => {
-        this.statsError.set(null);
+        this.error.set(null);
         this.stats.set(stats);
       });
   }
 
-  badgeToneForPredictionStatus(status: PredictionStatus): BadgeTone {
-    return TON_PAR_STATUT_PREDICTION[status];
-  }
-
-  loadTone(percent: number): LoadTone {
-    if (percent >= SEUIL_CHARGE_CRITIQUE) {
-      return 'danger';
-    }
-    return percent >= SEUIL_CHARGE_SOUTENUE ? 'warning' : 'success';
-  }
-
-  loadHint(percent: number): string {
-    switch (this.loadTone(percent)) {
-      case 'danger':
-        return 'Proche de la capacité du parc';
-      case 'warning':
-        return 'Charge soutenue';
-      default:
-        return 'Marge confortable';
-    }
+  badgeToneForSeverity(severity: AlertSeverity): BadgeTone {
+    return TON_PAR_SEVERITE[severity];
   }
 
   onLogout(): void {
@@ -129,8 +91,8 @@ export class Dashboard implements OnInit {
     });
   }
 
-  private reportUnavailable(target: WritableSignal<string | null>): Observable<never> {
-    target.set(UNAVAILABLE_MESSAGE);
+  private reportUnavailable(): Observable<never> {
+    this.error.set(UNAVAILABLE_MESSAGE);
     return EMPTY;
   }
 }

apps/frontend/src/app/features/monitoring/sensor-status/sensor-status.html

@@ -1,51 +0,0 @@
-<div class="sensor-status">
-  <nav class="ev-breadcrumb">
-    <a routerLink="/dashboard">Tableau de bord</a>
-  </nav>
-
-  <header class="sensor-status__header">
-    <a routerLink="/dashboard" class="ev-brand-link">
-      <ev-brand class="sensor-status__logo" />
-    </a>
-    <div>
-      <h1>Supervision des capteurs</h1>
-      <p class="sensor-status__subtitle">État de santé par capteur et par site</p>
-    </div>
-  </header>
-
-  @if (error(); as message) {
-    <ev-alert severity="danger" class="banner-error">{{ message }}</ev-alert>
-  }
-
-  @if (data(); as d) {
-    <div class="sites-grid">
-      @for (site of d.sites; track site.site_id) {
-        <ev-card class="site-card">
-          <div class="site-card__header">
-            <span class="site-card__name">{{ site.site_name }}</span>
-            <ev-badge [tone]="badgeToneForOverall(site.overall)">{{ site.overall }}</ev-badge>
-          </div>
-
-          <ul class="sensor-list">
-            @for (entry of sensorEntries; track entry[0]) {
-              @let diagnostic = sensorOf(site.sensors, entry[0]);
-              <li class="sensor-item">
-                <span class="sensor-dot" [class]="'sensor-dot--' + diagnostic.status"></span>
-                <span class="sensor-item__label">{{ entry[1] }}</span>
-                @if (diagnostic.status === 'failing') {
-                  <span class="sensor-item__since">
-                    @if (diagnostic.since; as since) {
-                      dernière lecture le {{ since | date: 'dd/MM/yyyy HH:mm' }}
-                    } @else {
-                      aucune lecture reçue
-                    }
-                  </span>
-                }
-              </li>
-            }
-          </ul>
-        </ev-card>
-      }
-    </div>
-  }
-</div>

apps/frontend/src/app/features/monitoring/sensor-status/sensor-status.scss

@@ -1,90 +0,0 @@
-:host {
-  display: block;
-  color: var(--color-text);
-  padding: 2.5rem 2rem;
-  max-width: 1100px;
-  margin: 0 auto;
-}
-
-.sensor-status__header {
-  display: flex;
-  align-items: center;
-  gap: 0.85rem;
-  margin-bottom: 2rem;
-
-  h1 {
-    margin: 0;
-    font-size: 1.75rem;
-    font-weight: 700;
-  }
-}
-
-.sensor-status__logo {
-  font-size: 1.3rem;
-}
-
-.sensor-status__subtitle {
-  margin: 0.25rem 0 0;
-  color: var(--color-text-muted);
-}
-
-.banner-error {
-  display: block;
-  margin: 0 0 1.5rem;
-}
-
-.sites-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
-  gap: 1rem;
-}
-
-.site-card__header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  margin-bottom: 0.75rem;
-}
-
-.site-card__name {
-  font-weight: 600;
-}
-
-.sensor-list {
-  list-style: none;
-  margin: 0;
-  padding: 0;
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-}
-
-.sensor-item {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  font-size: 0.85rem;
-}
-
-.sensor-dot {
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  flex-shrink: 0;
-
-  &--ok {
-    background: var(--color-success);
-  }
-  &--failing {
-    background: var(--color-danger);
-  }
-}
-
-.sensor-item__label {
-  flex: 1;
-}
-
-.sensor-item__since {
-  color: var(--color-text-muted);
-  font-size: 0.75rem;
-}

apps/frontend/src/app/features/monitoring/sensor-status/sensor-status.spec.ts

@@ -1,122 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { of, throwError } from 'rxjs';
-import { vi } from 'vitest';
-import { SensorStatusView } from './sensor-status';
-import { SensorsService } from '../../../core/services/sensors.service';
-import { SiteSensors } from '../../../shared/models/sensor-status.model';
-import {provideRouter} from '@angular/router';
-
-const OK_SENSORS: SiteSensors = {
-  consumption: { status: 'ok', since: null },
-  electrical: { status: 'ok', since: null },
-  temperature: { status: 'ok', since: null },
-  humidity: { status: 'ok', since: null },
-  network: { status: 'ok', since: null },
-};
-
-describe('SensorStatusView', () => {
-  let sensorsMock: { getStatus: ReturnType<typeof vi.fn> };
-
-  beforeEach(() => {
-    sensorsMock = { getStatus: vi.fn() };
-
-    TestBed.configureTestingModule({
-      imports: [SensorStatusView],
-      providers: [
-        { provide: SensorsService, useValue: sensorsMock },
-        provideRouter([]),
-      ],
-    });
-  });
-
-  it('charge et affiche les données au démarrage', () => {
-    sensorsMock.getStatus.mockReturnValue(
-      of({
-        timestamp: '2026-09-18T08:00:00',
-        sites: [
-          { site_id: 'SITE001', site_name: 'Bureau Test', overall: 'ok', sensors: OK_SENSORS },
-        ],
-      })
-    );
-
-    const fixture = TestBed.createComponent(SensorStatusView);
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.data()?.sites.length).toBe(1);
-    expect(fixture.componentInstance.error()).toBeNull();
-    expect(fixture.nativeElement.textContent).toContain('Bureau Test');
-  });
-
-  it("affiche un message d'erreur si l'appel échoue", () => {
-    sensorsMock.getStatus.mockReturnValue(throwError(() => new Error('boom')));
-
-    const fixture = TestBed.createComponent(SensorStatusView);
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.error()).toBe(
-      'État des capteurs indisponible, réessayez plus tard.'
-    );
-    expect(fixture.componentInstance.data()).toBeNull();
-    expect(fixture.nativeElement.textContent).toContain('État des capteurs indisponible');
-  });
-
-  it('associe le bon ton de badge à chaque statut global', () => {
-    sensorsMock.getStatus.mockReturnValue(of({ timestamp: '2026-09-18T08:00:00', sites: [] }));
-    const fixture = TestBed.createComponent(SensorStatusView);
-    const component = fixture.componentInstance;
-
-    expect(component.badgeToneForOverall('ok')).toBe('success');
-    expect(component.badgeToneForOverall('degraded')).toBe('warning');
-    expect(component.badgeToneForOverall('critical')).toBe('critical');
-    expect(component.badgeToneForOverall('inconnu')).toBe('neutral');
-  });
-
-  it('retourne le bon diagnostic via sensorOf', () => {
-    sensorsMock.getStatus.mockReturnValue(of({ timestamp: '2026-09-18T08:00:00', sites: [] }));
-    const fixture = TestBed.createComponent(SensorStatusView);
-    const component = fixture.componentInstance;
-
-    expect(component.sensorOf(OK_SENSORS, 'temperature')).toEqual({ status: 'ok', since: null });
-  });
-
-  it('affiche la date de la dernière lecture reçue pour un capteur en panne', () => {
-    const sensors: SiteSensors = {
-      ...OK_SENSORS,
-      temperature: { status: 'failing', since: '2026-09-18T08:00:00' },
-    };
-    sensorsMock.getStatus.mockReturnValue(
-      of({
-        timestamp: '2026-09-18T08:00:00',
-        sites: [{ site_id: 'SITE001', site_name: 'Bureau Test', overall: 'degraded', sensors }],
-      })
-    );
-
-    const fixture = TestBed.createComponent(SensorStatusView);
-    fixture.detectChanges();
-
-    expect(fixture.nativeElement.textContent).toContain('dernière lecture le');
-    expect(fixture.nativeElement.textContent).toContain('18/09/2026 08:00');
-  });
-
-  it("annonce l'absence de lecture quand un site n'en a jamais reçu", () => {
-    const sensors: SiteSensors = {
-      consumption: { status: 'failing', since: null },
-      electrical: { status: 'failing', since: null },
-      temperature: { status: 'failing', since: null },
-      humidity: { status: 'failing', since: null },
-      network: { status: 'failing', since: null },
-    };
-    sensorsMock.getStatus.mockReturnValue(
-      of({
-        timestamp: '2026-09-18T08:00:00',
-        sites: [{ site_id: 'SITE001', site_name: 'Bureau Test', overall: 'critical', sensors }],
-      })
-    );
-
-    const fixture = TestBed.createComponent(SensorStatusView);
-    fixture.detectChanges();
-
-    expect(fixture.nativeElement.textContent).toContain('aucune lecture reçue');
-    expect(fixture.nativeElement.textContent).not.toContain('dernière lecture le');
-  });
-});

apps/frontend/src/app/features/monitoring/sensor-status/sensor-status.ts

@@ -1,65 +0,0 @@
-import { Component, OnInit, inject, signal } from '@angular/core';
-import { RouterLink } from '@angular/router';
-import { catchError, EMPTY, Observable } from 'rxjs';
-import {Badge, BadgeTone} from '../../../shared/components/ui/badge/badge';
-import {Card} from '../../../shared/components/ui/card/card';
-import {Alert} from '../../../shared/components/ui/alert/alert';
-import {Brand} from '../../../shared/components/ui/brand/brand';
-import {SensorsService} from '../../../core/services/sensors.service';
-import {SensorDiagnostic, SensorStatusResponse} from '../../../shared/models/sensor-status.model';
-import { DatePipe } from '@angular/common';
-
-const UNAVAILABLE_MESSAGE = 'État des capteurs indisponible, réessayez plus tard.';
-
-const SENSOR_LABELS: Record<string, string> = {
-  consumption: 'Consommation',
-  electrical: 'Électrique',
-  temperature: 'Température',
-  humidity: 'Humidité',
-  network: 'Réseau',
-};
-
-const TON_PAR_OVERALL: Record<string, BadgeTone> = {
-  ok: 'success',
-  degraded: 'warning',
-  critical: 'critical',
-};
-
-@Component({
-  selector: 'app-sensor-status',
-  standalone: true,
-  imports: [RouterLink, Card, Alert, Badge, Brand, DatePipe],
-  templateUrl: './sensor-status.html',
-  styleUrl: './sensor-status.scss',
-})
-export class SensorStatusView implements OnInit {
-  private sensorsService = inject(SensorsService);
-
-  data = signal<SensorStatusResponse | null>(null);
-  error = signal<string | null>(null);
-
-  readonly sensorEntries = Object.entries(SENSOR_LABELS);
-
-  ngOnInit(): void {
-    this.sensorsService
-      .getStatus()
-      .pipe(catchError(() => this.reportUnavailable()))
-      .subscribe((response) => {
-        this.error.set(null);
-        this.data.set(response);
-      });
-  }
-
-  sensorOf(sensors: Record<string, SensorDiagnostic>, key: string): SensorDiagnostic {
-    return sensors[key];
-  }
-
-  badgeToneForOverall(overall: string): BadgeTone {
-    return TON_PAR_OVERALL[overall] ?? 'neutral';
-  }
-
-  private reportUnavailable(): Observable<never> {
-    this.error.set(UNAVAILABLE_MESSAGE);
-    return EMPTY;
-  }
-}

apps/frontend/src/app/features/recommendations/recommendations.html

@@ -1,58 +0,0 @@
-<div class="recommendations">
-  <nav class="ev-breadcrumb">
-    <a routerLink="/dashboard">Tableau de bord</a>
-  </nav>
-
-  <header class="recommendations__header">
-    <a routerLink="/dashboard" class="ev-brand-link">
-      <ev-brand class="recommendations__logo" />
-    </a>
-    <div>
-      <h1>Recommandations</h1>
-      <p class="recommendations__subtitle">
-        Actions proposées par le moteur de règles à partir des alertes
-      </p>
-    </div>
-  </header>
-
-  <div class="recommendations__toolbar">
-    <label class="recommendations__filter">
-      <span class="form-label">Site</span>
-      <select class="form-select" data-testid="site-filter" (change)="onSiteChange($event)">
-        <option value="" [selected]="!siteFilter()">Tous les sites</option>
-        @for (site of sites(); track site.site_id) {
-          <option [value]="site.site_id" [selected]="site.site_id === siteFilter()">
-            {{ site.site_name }}
-          </option>
-        }
-      </select>
-    </label>
-    @if (isAdmin()) {
-      <ev-button
-        variant="secondary"
-        [fullWidth]="false"
-        [disabled]="generating()"
-        data-testid="generate"
-        (click)="onGenerate()"
-      >
-        {{ generating() ? 'Génération en cours…' : 'Générer les recommandations' }}
-      </ev-button>
-    }
-  </div>
-
-  @if (generationReport(); as report) {
-    <ev-alert severity="success" class="recommendations__banner">{{ bilan(report) }}.</ev-alert>
-  }
-  @if (generationError(); as message) {
-    <ev-alert severity="danger" class="recommendations__banner">{{ message }}</ev-alert>
-  }
-
-  @if (alertId(); as id) {
-    <p class="recommendations__focus">
-      Alerte n° {{ id }} ·
-      <a routerLink="/recommendations" class="ev-link">Toutes les recommandations</a>
-    </p>
-  }
-
-  <app-recommendation-list [siteId]="siteFilter()" [alertId]="alertId()" [sites]="sites()" />
-</div>

apps/frontend/src/app/features/recommendations/recommendations.scss

@@ -1,59 +0,0 @@
-:host {
-  display: block;
-  color: var(--color-text);
-  padding: 2.5rem 2rem;
-  max-width: 1100px;
-  margin: 0 auto;
-}
-
-.recommendations__header {
-  display: flex;
-  align-items: center;
-  gap: 0.85rem;
-  margin-bottom: 2rem;
-
-  h1 {
-    margin: 0;
-    font-size: 1.75rem;
-    font-weight: 700;
-  }
-}
-
-.recommendations__logo {
-  font-size: 1.3rem;
-}
-
-.recommendations__subtitle {
-  margin: 0.25rem 0 0;
-  color: var(--color-text-muted);
-}
-
-.recommendations__toolbar {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: flex-end;
-  justify-content: space-between;
-  gap: var(--space-3);
-  margin-bottom: var(--space-4);
-}
-
-.recommendations__filter {
-  display: flex;
-  flex-direction: column;
-  min-width: 14rem;
-
-  .form-label {
-    margin-top: 0;
-  }
-}
-
-.recommendations__banner {
-  display: block;
-  margin-bottom: var(--space-3);
-}
-
-.recommendations__focus {
-  margin: 0 0 var(--space-3);
-  font-size: 0.9rem;
-  color: var(--color-text-muted);
-}

apps/frontend/src/app/features/recommendations/recommendations.spec.ts

@@ -1,169 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { By } from '@angular/platform-browser';
-import { ActivatedRoute, convertToParamMap, provideRouter } from '@angular/router';
-import { vi } from 'vitest';
-import { BehaviorSubject, of, throwError } from 'rxjs';
-import { RecommendationsView, parseAlertId } from './recommendations';
-import { RecommendationList } from '../../shared/components/recommendation-list/recommendation-list';
-import { SitesService } from '../../core/services/sites.service';
-import { AlertsService } from '../../core/services/alerts.service';
-import { RecommendationsService } from '../../core/services/recommendations.service';
-import { AuthService } from '../../core/services/auth.service';
-
-const SITES = [
-  {
-    site_id: 'SITE001',
-    site_name: 'Usine Nantes',
-    site_type: 'industriel',
-    location: 'Nantes',
-    capacity_kw: 500,
-    status: 'actif',
-  },
-];
-
-const BILAN = { alerts_examined: 2, recommendations_created: 3, already_present: 1 };
-
-function setup(options: { query?: Record<string, string>; role?: string } = {}) {
-  const query = options.query ?? {};
-  const queryParamMap = new BehaviorSubject(convertToParamMap(query));
-  const generate = vi.fn().mockReturnValue(of(BILAN));
-  const getRecommendations = vi.fn().mockReturnValue(of([]));
-  const getAlerts = vi.fn().mockReturnValue(of([]));
-  TestBed.configureTestingModule({
-    imports: [RecommendationsView],
-    providers: [
-      provideRouter([]),
-      {
-        provide: ActivatedRoute,
-        useValue: { queryParamMap, snapshot: { queryParamMap: convertToParamMap(query) } },
-      },
-      { provide: SitesService, useValue: { getSites: vi.fn().mockReturnValue(of(SITES)) } },
-      { provide: AlertsService, useValue: { getAlerts } },
-      { provide: RecommendationsService, useValue: { getRecommendations, generate } },
-      {
-        provide: AuthService,
-        useValue: { principal: vi.fn().mockReturnValue({ role: options.role ?? 'lecteur' }) },
-      },
-    ],
-  });
-  const fixture = TestBed.createComponent(RecommendationsView);
-  fixture.detectChanges();
-  fixture.detectChanges();
-  return { fixture, queryParamMap, generate, getRecommendations, getAlerts };
-}
-
-function listeEnfant(fixture: ReturnType<typeof setup>['fixture']): RecommendationList {
-  return fixture.debugElement.query(By.directive(RecommendationList)).componentInstance;
-}
-
-describe('parseAlertId', () => {
-  it("n'accepte qu'un entier strictement positif", () => {
-    expect(parseAlertId('12')).toBe(12);
-    expect(parseAlertId('0')).toBeNull();
-    expect(parseAlertId('-3')).toBeNull();
-    expect(parseAlertId('abc')).toBeNull();
-    expect(parseAlertId('12abc')).toBeNull();
-    expect(parseAlertId(null)).toBeNull();
-  });
-});
-
-describe('RecommendationsView', () => {
-  it("cible l'alerte donnée par ?alert= et la transmet à la liste", () => {
-    const { fixture } = setup({ query: { alert: '12' } });
-
-    expect(fixture.componentInstance.alertId()).toBe(12);
-    expect(listeEnfant(fixture).alertId()).toBe(12);
-    expect(fixture.nativeElement.textContent).toContain('Alerte n° 12');
-    expect(fixture.nativeElement.querySelector('a[href="/recommendations"]')).not.toBeNull();
-  });
-
-  it('ignore un paramètre alert invalide', () => {
-    const { fixture } = setup({ query: { alert: 'abc' } });
-
-    expect(fixture.componentInstance.alertId()).toBeNull();
-    expect(fixture.nativeElement.textContent).not.toContain('Alerte n°');
-  });
-
-  it('applique le site donné par ?site= au filtre et à la liste', () => {
-    const { fixture, getAlerts } = setup({ query: { site: 'SITE001' } });
-
-    expect(getAlerts).toHaveBeenCalledWith({ site_id: 'SITE001' });
-    const option = fixture.nativeElement.querySelector(
-      'option[value="SITE001"]',
-    ) as HTMLOptionElement;
-    expect(option.selected).toBe(true);
-  });
-
-  it('relance la liste sur le site choisi dans le filtre', () => {
-    const { fixture, getAlerts } = setup();
-    const select = fixture.nativeElement.querySelector(
-      '[data-testid="site-filter"]',
-    ) as HTMLSelectElement;
-
-    select.value = 'SITE001';
-    select.dispatchEvent(new Event('change'));
-    fixture.detectChanges();
-    fixture.detectChanges();
-
-    expect(getAlerts).toHaveBeenLastCalledWith({ site_id: 'SITE001' });
-    expect(listeEnfant(fixture).siteId()).toBe('SITE001');
-  });
-
-  it('cache le bouton de génération aux lecteurs', () => {
-    const { fixture } = setup({ role: 'lecteur' });
-
-    expect(fixture.nativeElement.querySelector('[data-testid="generate"]')).toBeNull();
-  });
-
-  it('permet à un admin de générer pour le site filtré, affiche le bilan et recharge la liste', () => {
-    const { fixture, generate, getRecommendations } = setup({
-      role: 'admin',
-      query: { site: 'SITE001' },
-    });
-
-    fixture.nativeElement.querySelector('[data-testid="generate"]').click();
-    fixture.detectChanges();
-    fixture.detectChanges();
-
-    expect(generate).toHaveBeenCalledWith('SITE001');
-    expect(fixture.nativeElement.textContent).toContain(
-      '3 recommandations créées, 1 déjà présente, 2 alertes examinées.',
-    );
-    expect(getRecommendations).toHaveBeenCalledTimes(2);
-    expect(fixture.componentInstance.generating()).toBe(false);
-  });
-
-  it('génère pour tout le parc quand aucun site n’est filtré', () => {
-    const { fixture, generate } = setup({ role: 'admin' });
-
-    fixture.componentInstance.onGenerate();
-
-    expect(generate).toHaveBeenCalledWith(undefined);
-  });
-
-  it("signale l'échec de la génération sans casser la page", () => {
-    const { fixture, generate } = setup({ role: 'admin' });
-    generate.mockReturnValue(throwError(() => new Error('403')));
-
-    fixture.componentInstance.onGenerate();
-    fixture.detectChanges();
-
-    expect(fixture.componentInstance.generationError()).not.toBeNull();
-    expect(fixture.nativeElement.textContent).toContain(
-      'La génération des recommandations a échoué',
-    );
-    expect(fixture.componentInstance.generating()).toBe(false);
-  });
-
-  it('accorde le bilan au singulier', () => {
-    const { fixture } = setup();
-
-    expect(
-      fixture.componentInstance.bilan({
-        alerts_examined: 1,
-        recommendations_created: 1,
-        already_present: 0,
-      }),
-    ).toBe('1 recommandation créée, 0 déjà présente, 1 alerte examinée');
-  });
-});

apps/frontend/src/app/features/recommendations/recommendations.ts

@@ -1,85 +0,0 @@
-import { Component, computed, inject, signal, viewChild } from '@angular/core';
-import { toSignal } from '@angular/core/rxjs-interop';
-import { ActivatedRoute, RouterLink } from '@angular/router';
-import { catchError, map, of } from 'rxjs';
-import { SitesService } from '../../core/services/sites.service';
-import { RecommendationsService } from '../../core/services/recommendations.service';
-import { AuthService } from '../../core/services/auth.service';
-import { Site } from '../../shared/models/site.model';
-import { RecommendationGenerationReport } from '../../shared/models/recommendation.model';
-import { RecommendationList } from '../../shared/components/recommendation-list/recommendation-list';
-import { Alert as EvAlert } from '../../shared/components/ui/alert/alert';
-import { Brand } from '../../shared/components/ui/brand/brand';
-import { Button } from '../../shared/components/ui/button/button';
-
-const GENERATION_FAILED_MESSAGE =
-  'La génération des recommandations a échoué, réessayez plus tard.';
-
-export function parseAlertId(raw: string | null): number | null {
-  return raw !== null && /^[1-9]\d*$/.test(raw) ? Number(raw) : null;
-}
-
-function pluriel(nombre: number, singulier: string, plurielForme: string): string {
-  return `${nombre} ${nombre > 1 ? plurielForme : singulier}`;
-}
-
-@Component({
-  selector: 'app-recommendations',
-  standalone: true,
-  imports: [RouterLink, RecommendationList, EvAlert, Brand, Button],
-  templateUrl: './recommendations.html',
-  styleUrl: './recommendations.scss',
-})
-export class RecommendationsView {
-  private route = inject(ActivatedRoute);
-  private sitesService = inject(SitesService);
-  private recommendationsService = inject(RecommendationsService);
-  private auth = inject(AuthService);
-
-  alertId = toSignal(
-    this.route.queryParamMap.pipe(map((params) => parseAlertId(params.get('alert')))),
-    { initialValue: null },
-  );
-  siteFilter = signal<string | null>(this.route.snapshot.queryParamMap.get('site'));
-  sites = toSignal(this.sitesService.getSites().pipe(catchError(() => of([] as Site[]))), {
-    initialValue: [] as Site[],
-  });
-
-  list = viewChild.required(RecommendationList);
-
-  isAdmin = computed(() => this.auth.principal()?.role === 'admin');
-  generating = signal(false);
-  generationReport = signal<RecommendationGenerationReport | null>(null);
-  generationError = signal<string | null>(null);
-
-  onSiteChange(event: Event): void {
-    this.siteFilter.set((event.target as HTMLSelectElement).value || null);
-  }
-
-  onGenerate(): void {
-    if (this.generating()) {
-      return;
-    }
-    this.generating.set(true);
-    this.generationError.set(null);
-    this.recommendationsService.generate(this.siteFilter() ?? undefined).subscribe({
-      next: (report) => {
-        this.generating.set(false);
-        this.generationReport.set(report);
-        this.list().reload();
-      },
-      error: () => {
-        this.generating.set(false);
-        this.generationError.set(GENERATION_FAILED_MESSAGE);
-      },
-    });
-  }
-
-  bilan(report: RecommendationGenerationReport): string {
-    return [
-      pluriel(report.recommendations_created, 'recommandation créée', 'recommandations créées'),
-      pluriel(report.already_present, 'déjà présente', 'déjà présentes'),
-      pluriel(report.alerts_examined, 'alerte examinée', 'alertes examinées'),
-    ].join(', ');
-  }
-}

apps/frontend/src/app/features/sites/site-detail-placeholder/site-detail-placeholder.html

@@ -0,0 +1,19 @@
+<div class="site-detail-placeholder">
+  <nav class="ev-breadcrumb">
+    <a routerLink="/dashboard">Tableau de bord</a>
+    <span>/</span>
+    <a routerLink="/sites">Sites</a>
+  </nav>
+
+  <header class="site-detail-placeholder__header">
+    <a routerLink="/dashboard" class="ev-brand-link">
+      <ev-brand class="site-detail-placeholder__logo" />
+    </a>
+    <h1>Site {{ siteId() }}</h1>
+  </header>
+
+  <ev-card>
+    <p>Le détail de ce site est à venir (voir issue #51).</p>
+    <a routerLink="/sites" class="ev-link">Retour aux sites</a>
+  </ev-card>
+</div>

apps/frontend/src/app/features/sites/site-detail-placeholder/site-detail-placeholder.scss

@@ -0,0 +1,28 @@
+:host {
+  display: block;
+  color: var(--color-text);
+  padding: 2.5rem 2rem;
+  max-width: 640px;
+  margin: 0 auto;
+}
+
+.site-detail-placeholder__header {
+  display: flex;
+  align-items: center;
+  gap: 0.85rem;
+  margin-bottom: 1.5rem;
+
+  h1 {
+    margin: 0;
+    font-size: 1.5rem;
+    font-weight: 700;
+  }
+}
+
+.site-detail-placeholder__logo {
+  font-size: 1.3rem;
+}
+
+ev-card p {
+  margin: 0 0 0.75rem;
+}

apps/frontend/src/app/features/sites/site-detail-placeholder/site-detail-placeholder.spec.ts

@@ -0,0 +1,42 @@
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute, convertToParamMap, provideRouter } from '@angular/router';
+import { BehaviorSubject } from 'rxjs';
+import { SiteDetailPlaceholder } from './site-detail-placeholder';
+
+describe('SiteDetailPlaceholder', () => {
+  it("affiche l'identifiant du site depuis la route", () => {
+    const paramMap = new BehaviorSubject(convertToParamMap({ siteId: 'SITE001' }));
+    TestBed.configureTestingModule({
+      imports: [SiteDetailPlaceholder],
+      providers: [
+        provideRouter([]),
+        { provide: ActivatedRoute, useValue: { paramMap } },
+      ],
+    });
+
+    const fixture = TestBed.createComponent(SiteDetailPlaceholder);
+    fixture.detectChanges();
+
+    expect(fixture.nativeElement.textContent).toContain('SITE001');
+  });
+
+  it('met à jour l\'affichage quand le paramètre change sans recréer le composant', () => {
+    const paramMap = new BehaviorSubject(convertToParamMap({ siteId: 'SITE001' }));
+    TestBed.configureTestingModule({
+      imports: [SiteDetailPlaceholder],
+      providers: [
+        provideRouter([]),
+        { provide: ActivatedRoute, useValue: { paramMap } },
+      ],
+    });
+
+    const fixture = TestBed.createComponent(SiteDetailPlaceholder);
+    fixture.detectChanges();
+
+    paramMap.next(convertToParamMap({ siteId: 'SITE002' }));
+    fixture.detectChanges();
+
+    expect(fixture.nativeElement.textContent).toContain('SITE002');
+    expect(fixture.nativeElement.textContent).not.toContain('SITE001');
+  });
+});

apps/frontend/src/app/features/sites/site-detail-placeholder/site-detail-placeholder.ts

@@ -0,0 +1,19 @@
+import { Component, inject } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { ActivatedRoute, RouterLink } from '@angular/router';
+import { map } from 'rxjs';
+import { Card } from '../../../shared/components/ui/card/card';
+import { Brand } from '../../../shared/components/ui/brand/brand';
+
+@Component({
+  selector: 'app-site-detail-placeholder',
+  standalone: true,
+  imports: [RouterLink, Card, Brand],
+  templateUrl: './site-detail-placeholder.html',
+  styleUrl: './site-detail-placeholder.scss',
+})
+export class SiteDetailPlaceholder {
+  private route = inject(ActivatedRoute);
+
+  siteId = toSignal(this.route.paramMap.pipe(map((params) => params.get('siteId'))));
+}