Paramètres : clé d'API FF Nancy (en-tête X-API-Key)

L'API api.ffnancy.fr exige désormais une clé (401 « Clé d'API requise »).
- Nouveau champ « Clé d'API » dans Paramètres → API FF Nancy, stocké dans
  data/.db-config.json (ffApiKey), jamais renvoyé au navigateur ; vide =
  conserver la clé enregistrée. Repli sur la variable FF_API_KEY.
- Tous les appels à l'API FF envoient l'en-tête X-API-Key (ff_get, proxy
  commandes-auto, publicités, /api/diag, test de connexion).
- Le test de connexion signale explicitement une clé manquante ou refusée.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KdY28Lq8Q8xX4RZsAvWRQ7

server/src/admin/qlik_bridge.rs

@@ -22,8 +22,8 @@ pub fn reset_ff_api_base() {
 }
 
 /// Diagnostic de l'API FF Nancy.
-pub async fn diagnostiquer_api_ff(base: Option<String>) -> Value {
-    serde_json::to_value(crate::ff::diagnostic::diagnostiquer_api_ff(base).await).unwrap_or(Value::Null)
+pub async fn diagnostiquer_api_ff(base: Option<String>, cle: Option<String>) -> Value {
+    serde_json::to_value(crate::ff::diagnostic::diagnostiquer_api_ff(base, cle).await).unwrap_or(Value::Null)
 }
 
 /// Extraction Qlik d'un fournisseur sur la fenêtre de la synchro (`QLIK_SYNC_MONTHS_BACK`),

server/src/admin/settings.rs

@@ -116,6 +116,9 @@ pub async fn get_parametres_affichables(ctx: Ctx) -> AppResult<Value> {
             "motDePasseEnregistre": config.qlik_password.as_deref().map(|p| !p.is_empty()).unwrap_or(false) || qlik_pwd_env,
         },
         "ffApiBaseUrl": config.ff_api_base_url.clone().unwrap_or_default(),
+        // La clé ne quitte pas le serveur : seulement l'indication qu'il y en a une
+        // (réglage enregistré, puis variable d'environnement `FF_API_KEY`).
+        "ffApiKeyEnregistree": crate::ff::api::resoudre_ff_api_key(config.ff_api_key.clone()).is_some(),
     }))
 }
 
@@ -219,12 +222,14 @@ pub async fn test_qlik_connection(ctx: Ctx) -> AppResult<Value> {
     }
 }
 
-/// Enregistre l'URL de l'API FF Nancy. Chaîne vide = revenir au défaut.
+/// Enregistre l'URL de l'API FF Nancy (chaîne vide = revenir au défaut) et sa
+/// clé d'API (vide ou absente = conserver celle qui est enregistrée).
 pub async fn save_ff_api_settings(ctx: Ctx) -> AppResult<Value> {
     if let Err(e) = ctx.admin().await {
         return Ok(refus(e));
     }
     let brut: String = ctx.arg::<Option<String>>(0)?.unwrap_or_default();
+    let cle: Option<String> = ctx.arg::<Option<String>>(1)?.map(|s| s.trim().to_string()).filter(|s| !s.is_empty());
     let cleaned = brut.trim().trim_end_matches('/').to_string();
     let lower = cleaned.to_ascii_lowercase();
     if !cleaned.is_empty() && !(lower.starts_with("http://") || lower.starts_with("https://")) {
@@ -232,6 +237,9 @@ pub async fn save_ff_api_settings(ctx: Ctx) -> AppResult<Value> {
     }
     let mut patch = Map::new();
     patch.insert("ffApiBaseUrl".into(), if cleaned.is_empty() { Value::Null } else { Value::String(cleaned.clone()) });
+    if let Some(cle) = cle {
+        patch.insert("ffApiKey".into(), Value::String(cle));
+    }
     match write_config(patch) {
         Ok(()) => {
             // Sans cela, l'ancienne URL resterait servie jusqu'à 30 s après la sauvegarde.
@@ -252,7 +260,8 @@ pub async fn test_ff_api_connection(ctx: Ctx) -> AppResult<Value> {
         return Ok(j!({ "success": false, "url": "", "error": e.message }));
     }
     let base: Option<String> = ctx.arg(0)?;
-    Ok(super::qlik_bridge::diagnostiquer_api_ff(base).await)
+    let cle: Option<String> = ctx.arg::<Option<String>>(1)?;
+    Ok(super::qlik_bridge::diagnostiquer_api_ff(base, cle).await)
 }
 
 #[cfg(test)]

server/src/config.rs

@@ -43,6 +43,9 @@ pub struct DbConfig {
     /// API REST FF Nancy (ex. https://api.ffnancy.fr).
     #[serde(default)]
     pub ff_api_base_url: Option<String>,
+    /// Clé d'API FF Nancy, envoyée dans l'en-tête `X-API-Key`.
+    #[serde(default)]
+    pub ff_api_key: Option<String>,
 }
 
 fn read_raw_sync() -> Map<String, Value> {

server/src/ff/api.rs

@@ -42,9 +42,21 @@ pub fn ff_client() -> &'static reqwest::Client {
     })
 }
 
-/// `fetch(url, ffFetchInit())`.
+/// `fetch(url, ffFetchInit())`, clé d'API comprise.
 pub async fn ff_get(url: &str) -> reqwest::Result<reqwest::Response> {
-    ff_client().get(url).header(reqwest::header::CACHE_CONTROL, "no-store").send().await
+    avec_cle_ff(ff_client().get(url).header(reqwest::header::CACHE_CONTROL, "no-store")).await.send().await
+}
+
+/// En-tête d'authentification attendu par l'API FF Nancy.
+pub const FF_API_KEY_HEADER: &str = "X-API-Key";
+
+/// Ajoute la clé d'API enregistrée (en-tête `X-API-Key`) à une requête vers l'API FF.
+/// Sans clé configurée, la requête part telle quelle.
+pub async fn avec_cle_ff(req: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+    match get_ff_api_key().await {
+        Some(cle) => req.header(FF_API_KEY_HEADER, cle),
+        None => req,
+    }
 }
 
 /// Libellé HTTP d'un statut (équivalent de `res.statusText`).
@@ -52,7 +64,43 @@ pub fn status_text(status: reqwest::StatusCode) -> &'static str {
     status.canonical_reason().unwrap_or("")
 }
 
-static FF_API_BASE_CACHE: LazyLock<Mutex<Option<(String, Instant)>>> = LazyLock::new(|| Mutex::new(None));
+/// Réglages de connexion à l'API FF résolus : adresse et clé.
+#[derive(Clone)]
+struct FfApiReglages {
+    base: String,
+    cle: Option<String>,
+}
+
+static FF_API_CACHE: LazyLock<Mutex<Option<(FfApiReglages, Instant)>>> = LazyLock::new(|| Mutex::new(None));
+
+/// Chaîne non vide après `trim`, sinon `None`.
+fn non_vide(s: Option<String>) -> Option<String> {
+    s.map(|s| s.trim().to_string()).filter(|s| !s.is_empty())
+}
+
+/// Clé d'API FF : réglage enregistré dans Paramètres → variable d'environnement
+/// `FF_API_KEY` → aucune.
+pub fn resoudre_ff_api_key(configured: Option<String>) -> Option<String> {
+    non_vide(configured).or_else(|| non_vide(std::env::var("FF_API_KEY").ok()))
+}
+
+async fn get_ff_api_reglages() -> FfApiReglages {
+    if let Some((value, at)) = FF_API_CACHE.lock().as_ref() {
+        if at.elapsed() < FF_API_BASE_TTL {
+            return value.clone();
+        }
+    }
+    // Fichier absent ou illisible : on retombe sur l'environnement.
+    let config = tokio::task::spawn_blocking(crate::config::read_config).await.unwrap_or_default();
+    let base = non_vide(config.ff_api_base_url)
+        .or_else(|| non_vide(std::env::var("FF_API_BASE_URL").ok()))
+        .unwrap_or_else(|| FF_API_BASE_DEFAULT.to_string())
+        .trim_end_matches('/')
+        .to_string();
+    let value = FfApiReglages { base, cle: resoudre_ff_api_key(config.ff_api_key) };
+    *FF_API_CACHE.lock() = Some((value.clone(), Instant::now()));
+    value
+}
 
 /// URL de l'API FF Nancy, résolue **au moment de l'appel**.
 ///
@@ -63,31 +111,17 @@ static FF_API_BASE_CACHE: LazyLock<Mutex<Option<(String, Instant)>>> = LazyLock:
 ///
 /// Le résultat est mémorisé 30 s pour ne pas relire le fichier à chaque requête.
 pub async fn get_ff_api_base() -> String {
-    if let Some((value, at)) = FF_API_BASE_CACHE.lock().as_ref() {
-        if at.elapsed() < FF_API_BASE_TTL {
-            return value.clone();
-        }
-    }
-    // Fichier absent ou illisible : on retombe sur l'environnement.
-    let configured = tokio::task::spawn_blocking(|| crate::config::read_config().ff_api_base_url)
-        .await
-        .ok()
-        .flatten()
-        .map(|s| s.trim().to_string())
-        .filter(|s| !s.is_empty());
-    let env = std::env::var("FF_API_BASE_URL").ok().filter(|s| !s.is_empty());
-    let value = configured
-        .or(env)
-        .unwrap_or_else(|| FF_API_BASE_DEFAULT.to_string())
-        .trim_end_matches('/')
-        .to_string();
-    *FF_API_BASE_CACHE.lock() = Some((value.clone(), Instant::now()));
-    value
+    get_ff_api_reglages().await.base
+}
+
+/// Clé d'API FF Nancy (même cache que l'adresse).
+pub async fn get_ff_api_key() -> Option<String> {
+    get_ff_api_reglages().await.cle
 }
 
 /// Vide le cache — appelé après un enregistrement dans Paramètres.
 pub fn reset_ff_api_base_cache() {
-    *FF_API_BASE_CACHE.lock() = None;
+    *FF_API_CACHE.lock() = None;
 }
 
 // ---------------------------------------------------------------------------

server/src/ff/diagnostic.rs

@@ -5,7 +5,7 @@
 //! route `/api/ff-status` (tout utilisateur connecté). Chaque appelant fait son
 //! propre contrôle d'accès.
 
-use super::api::{normalize_sync_status, status_text, FfSyncStatus, FF_API_BASE_DEFAULT};
+use super::api::{get_ff_api_key, normalize_sync_status, status_text, FfSyncStatus, FF_API_BASE_DEFAULT, FF_API_KEY_HEADER};
 use super::js::truthy;
 use serde::Serialize;
 use serde_json::Value;
@@ -77,7 +77,13 @@ fn message_complet(e: &dyn std::error::Error) -> String {
 /// L'ancien panneau se contentait d'un « HTTP 503 » opaque : impossible de savoir
 /// si l'hôte était injoignable, l'URL erronée ou le service en panne. On distingue
 /// donc ici l'échec réseau (DNS, refus de connexion, délai dépassé) du code HTTP.
-pub async fn diagnostiquer_api_ff(ff_api_base_url: Option<String>) -> DiagnosticApiFf {
+///
+/// `ff_api_key` : clé saisie à tester ; vide ou absente, on reprend la clé enregistrée.
+pub async fn diagnostiquer_api_ff(ff_api_base_url: Option<String>, ff_api_key: Option<String>) -> DiagnosticApiFf {
+    let cle = match ff_api_key.map(|s| s.trim().to_string()).filter(|s| !s.is_empty()) {
+        Some(c) => Some(c),
+        None => get_ff_api_key().await,
+    };
     let saisie = ff_api_base_url.map(|s| s.trim().to_string()).filter(|s| !s.is_empty());
     let base = match saisie {
         Some(b) => b,
@@ -97,9 +103,24 @@ pub async fn diagnostiquer_api_ff(ff_api_base_url: Option<String>) -> Diagnostic
     let started = Instant::now();
 
     let client = reqwest::Client::builder().timeout(Duration::from_millis(8000)).build().unwrap_or_default();
-    match client.get(&url).header(reqwest::header::CACHE_CONTROL, "no-store").send().await {
+    let mut req = client.get(&url).header(reqwest::header::CACHE_CONTROL, "no-store");
+    if let Some(cle) = &cle {
+        req = req.header(FF_API_KEY_HEADER, cle);
+    }
+    match req.send().await {
         Ok(res) => {
             let ms = started.elapsed().as_millis() as u64;
+            // 401/403 : le serveur répond, c'est la clé qui manque ou qui est refusée.
+            if matches!(res.status().as_u16(), 401 | 403) {
+                return DiagnosticApiFf::echec(
+                    &url,
+                    if cle.is_some() {
+                        format!("Clé d'API refusée (HTTP {}) — vérifiez la clé saisie.", res.status().as_u16())
+                    } else {
+                        format!("Clé d'API requise (HTTP {}) — renseignez la clé d'API.", res.status().as_u16())
+                    },
+                );
+            }
             if !res.status().is_success() {
                 let txt = status_text(res.status());
                 return DiagnosticApiFf::echec(

server/src/ff/fixture_tests.rs

@@ -247,8 +247,8 @@ async fn module_ff_sur_base_de_test() {
     montrer("get_mensuel_by_articles", api::get_mensuel_by_articles(&ffarts, d, f, 50).await);
     montrer("get_referentiel_by_articles", api::get_referentiel_by_articles(&ffarts, 50).await);
     montrer("get_commandes_by_fournisseur", api::get_commandes_by_fournisseur("F001").await);
-    montrer("diagnostiquer_api_ff", diagnostic::diagnostiquer_api_ff(None).await);
-    montrer("diagnostiquer_api_ff(injoignable)", diagnostic::diagnostiquer_api_ff(Some("http://127.0.0.1:9".into())).await);
+    montrer("diagnostiquer_api_ff", diagnostic::diagnostiquer_api_ff(None, None).await);
+    montrer("diagnostiquer_api_ff(injoignable)", diagnostic::diagnostiquer_api_ff(Some("http://127.0.0.1:9".into()), None).await);
 
     // ── cache.rs
     montrer("get_derniere_reception_cached", cache::get_derniere_reception_cached(&codes(&["F002", "F001"])).await.unwrap());

server/src/ff/pages.rs

@@ -3,7 +3,7 @@
 //! commandes fournisseurs et publicités.
 
 use super::actions::lister_cadences;
-use super::api::get_ff_api_base;
+use super::api::{avec_cle_ff, get_ff_api_base};
 use super::cache::get_fournisseurs_cached;
 use super::js::{get, js_number, js_number_to_string, message_erreur};
 use super::pg::{
@@ -223,12 +223,11 @@ async fn fetch_publicites_api(statut: String, page: String) -> PublicitesResult
     }
     let base = get_ff_api_base().await;
     let res = async {
-        let res = client_publicites()
+        let req = client_publicites()
             .get(format!("{base}/api/publicites"))
             .query(&params)
-            .header(reqwest::header::CACHE_CONTROL, "no-store")
-            .send()
-            .await?;
+            .header(reqwest::header::CACHE_CONTROL, "no-store");
+        let res = avec_cle_ff(req).await.send().await?;
         if !res.status().is_success() {
             return anyhow::Ok(PublicitesResult {
                 data: json_value!([]),
@@ -262,11 +261,10 @@ async fn fetch_publicites_api(statut: String, page: String) -> PublicitesResult
 async fn fetch_historique_api() -> HistoriqueResult {
     let base = get_ff_api_base().await;
     let res = async {
-        let res = client_publicites()
+        let req = client_publicites()
             .get(format!("{base}/api/publicites/historique"))
-            .header(reqwest::header::CACHE_CONTROL, "no-store")
-            .send()
-            .await?;
+            .header(reqwest::header::CACHE_CONTROL, "no-store");
+        let res = avec_cle_ff(req).await.send().await?;
         if !res.status().is_success() {
             return anyhow::Ok(HistoriqueResult {
                 data: json_value!([]),

server/src/ff/routes.rs

@@ -1,7 +1,7 @@
 //! Routes HTTP du module FF : `/api/ff-status`, `/api/diag`,
 //! `/api/diag/stock-fournisseur`, `/api/test-db`, `/api/commandes-auto`.
 
-use super::api::{ff_client, get_ff_api_base};
+use super::api::{avec_cle_ff, ff_client, get_ff_api_base};
 use super::diagnostic::diagnostiquer_api_ff;
 use super::js::{encode, js_string, message_erreur};
 use super::pg::{pg_diag_fournisseur_derniere_entree, pg_get_stock_for_codeins};
@@ -31,7 +31,7 @@ fn string_erreur(e: &dyn std::fmt::Display) -> String {
 /// et *quelle adresse* a été appelée. L'ancienne version renvoyait un 503 sans
 /// détail, impossible à distinguer d'une simple erreur d'URL.
 pub async fn ff_status(_user: SessionUser) -> Response {
-    let res = diagnostiquer_api_ff(None).await;
+    let res = diagnostiquer_api_ff(None, None).await;
     if !res.success {
         return (
             StatusCode::SERVICE_UNAVAILABLE,
@@ -115,7 +115,7 @@ pub async fn commandes_auto(_user: SessionUser, Query(q): Query<HashMap<String,
         }
         let base = get_ff_api_base().await;
         let url = format!("{base}/api/commandes-auto");
-        let res = ff_client().get(&url).query(&params).send().await?;
+        let res = avec_cle_ff(ff_client().get(&url).query(&params)).await.send().await?;
         if !res.status().is_success() {
             let status = res.status();
             return anyhow::Ok(
@@ -142,7 +142,7 @@ pub async fn commandes_auto(_user: SessionUser, Query(q): Query<HashMap<String,
 /// Résumé d'une sonde : statut HTTP et aperçu du contenu.
 async fn probe(url: String) -> Value {
     let res = async {
-        let res = reqwest::Client::new().get(&url).header(reqwest::header::CACHE_CONTROL, "no-store").send().await?;
+        let res = avec_cle_ff(reqwest::Client::new().get(&url).header(reqwest::header::CACHE_CONTROL, "no-store")).await.send().await?;
         let status = res.status().as_u16();
         let text = res.text().await?;
         anyhow::Ok((status, text))
@@ -189,7 +189,7 @@ fn premiere_liste(data: &Value) -> Vec<Value> {
 }
 
 async fn get_json(url: &str) -> anyhow::Result<Value> {
-    let res = reqwest::Client::new().get(url).header(reqwest::header::CACHE_CONTROL, "no-store").send().await?;
+    let res = avec_cle_ff(reqwest::Client::new().get(url).header(reqwest::header::CACHE_CONTROL, "no-store")).await.send().await?;
     Ok(res.json::<Value>().await?)
 }