Automatiser la création de tarifs clients personnalisés depuis un fichier FAB-DIS

Stratégie tarifaire : pourquoi et comment différencier les coefficients

Avant de plonger dans le script, posons les fondations d’une stratégie tarifaire cohérente et rentable.

Les 3 dimensions de la différenciation tarifaire

1. Différenciation par PROFIL CLIENT

2. Différenciation par FAMILLE DE PRODUITS

Tous les produits ne justifient pas la même marge. Exemples de logiques courantes :

• Produits techniques complexes (automatismes, centrales) → Marge élevée (forte valeur ajoutée conseil)
• Accessoires standards (télécommandes, photocellules) → Marge moyenne (concurrence forte)
• Consommables (piles, lubrifiants) → Marge faible (produits d’appel)
• Pièces détachées → Marge élevée (exclusivité, urgence)

3. Matrice de coefficients croisée

La formule de calcul du prix client

Le script d’automatisation : créer des tarifs clients en masse

Passons maintenant à la création du script qui applique automatiquement vos grilles tarifaires.

Vue d’ensemble : ce que fait le script

Inputs :

• Feuille B01_COMMERCE : Données produits FAB-DIS
• Feuille Grille_Coefficients : Votre matrice Profil × Famille (créée manuellement)
• Paramètre : Nom du profil client (ex: « Revendeur »)

Process :

1. Lecture de tous les produits B01_COMMERCE
2. Pour chaque produit, récupération de sa FAM1L
3. Recherche du coefficient correspondant dans la grille (Profil × FAM1L)
4. Calcul : Prix Client = TARIF × (1 – Remise) × Coefficient
5. Génération d’une nouvelle feuille avec colonnes : REFCIALE, LIBELLE80, FAM1L, Prix Client

Output :

• Nouvel onglet Tarif_[NomClient] prêt à être exporté en PDF ou Excel
• Colonnes : REFCIALE, LIBELLE80, FAM1L, Prix Unitaire HT, Prix TTC

Étape préalable : créer votre grille de coefficients

Tutoriel : création du script en 3 étapes

function main(workbook: ExcelScript.Workbook) {
    // ========================================
    // CONFIGURATION : À ADAPTER SELON VOS BESOINS
    // ========================================

    // Profil client pour ce tarif (doit correspondre à une colonne dans Grille_Coefficients)
    const PROFIL_CLIENT = "Revendeur"; // Modifier ici : Gros_compte, Revendeur, Installateur...

    // Remise fournisseur que vous bénéficiez (en décimal)
    const REMISE_FOURNISSEUR = 0.30; // 30% de remise = 0.30

    // Taux de TVA à appliquer (pour calcul TTC)
    const TVA = 0.20; // 20%

    // Nom du client (pour le titre de la feuille)
    const NOM_CLIENT = "Tarif_Revendeur_Standard";

    // ========================================
    // ÉTAPE 1 : Récupération des feuilles
    // ========================================

let b01 = workbook.getWorksheet("B01_COMMERCE");

let grille = workbook.getWorksheet("Grille_Coefficients");

    if (!b01 || !grille) {
        console.log("❌ Erreur : Feuilles B01_COMMERCE ou Grille_Coefficients manquantes");
        return;
    }

    // ========================================
    // ÉTAPE 2 : Lecture de la grille de coefficients
    // ========================================

    let grilleData = grille.getUsedRange().getValues();
    let grilleHeaders = grilleData[0].map((h: string | number | boolean) => String(h).trim());

    // Trouver l'index de la colonne du profil client
    let colProfilIndex = grilleHeaders.indexOf(PROFIL_CLIENT);

    if (colProfilIndex === -1) {
        console.log("❌ Erreur : Profil '" + PROFIL_CLIENT + "' introuvable dans Grille_Coefficients");
        return;
    }

    // Créer un map FAM1L → Coefficient
    let coeffMap: { [key: string]: number } = {};

    for (let i = 1; i < grilleData.length; i++) {
        let famille = String(grilleData[i][0]).trim();
        let coeff = parseFloat(grilleData[i][colProfilIndex]);

        if (famille && !isNaN(coeff)) {
            coeffMap[famille] = coeff;
        }
    }

    console.log("Coefficients chargés : " + Object.keys(coeffMap).length + " familles");

    // ========================================
    // ÉTAPE 3 : Lecture des données B01_COMMERCE
    // ========================================

    let b01Data = b01.getUsedRange().getValues();
    let b01Headers = b01Data[0].map((h: string | number | boolean) => String(h).trim());
    
    // Trouver les colonnes nécessaires
    let colREFCIALE = b01Headers.indexOf("REFCIALE");
    let colLIBELLE80 = b01Headers.indexOf("LIBELLE80");
    let colFAM1L = b01Headers.indexOf("FAM1L");
    let colTARIF = b01Headers.indexOf("TARIF");

    if (colREFCIALE === -1 || colFAM1L === -1 || colTARIF === -1) {
        console.log("❌ Erreur : Colonnes REFCIALE, FAM1L ou TARIF manquantes");
        return;
    }

    // ========================================
    // ÉTAPE 4 : Calcul des prix clients
    // ========================================

    let lignesTarif: (string | number)[][] = [];

    for (let i = 1; i < b01Data.length; i++) {
        let refciale = b01Data[i][colREFCIALE];
        let libelle = b01Data[i][colLIBELLE80] || "";
        let famille = String(b01Data[i][colFAM1L]).trim();
        let tarifFabDis = parseFloat(b01Data[i][colTARIF]);

        // Vérifier que les données sont valides
        if (!refciale || isNaN(tarifFabDis) || tarifFabDis === 0) {
            continue; // Ignorer les lignes invalides
        }

        // Récupérer le coefficient pour cette famille
        let coefficient = coeffMap[famille];

        if (!coefficient) {
            // Si famille non trouvée, appliquer un coefficient par défaut
            coefficient = 1.30; // Défaut +30%
            console.log("⚠️ Famille non trouvée : " + famille + ", coefficient par défaut appliqué");
        }

        // CALCUL : Prix Client HT = TARIF × (1 - Remise) × Coefficient
        let prixAchat = tarifFabDis * (1 - REMISE_FOURNISSEUR);
        let prixClientHT = prixAchat * coefficient;
        let prixClientTTC = prixClientHT * (1 + TVA);

        // Arrondir à 2 décimales
        prixClientHT = Math.round(prixClientHT * 100) / 100;
        prixClientTTC = Math.round(prixClientTTC * 100) / 100;

        lignesTarif.push([
            refciale,
            libelle,
            famille,
            prixClientHT,
            prixClientTTC
        ]);
    }

    console.log("Produits traités : " + lignesTarif.length);

    // ========================================
    // ÉTAPE 5 : Création de la feuille de tarif
    // ========================================

    // Supprimer l'ancienne feuille si elle existe
    let oldSheet = workbook.getWorksheet(NOM_CLIENT);
    if (oldSheet) oldSheet.delete();

    // Créer la nouvelle feuille
    let tarifSheet = workbook.addWorksheet(NOM_CLIENT);

    // En-têtes
    let headers = ["Référence", "Désignation", "Famille", "Prix HT", "Prix TTC"];
    tarifSheet.getRange("A1").getAbsoluteResizedRange(1, headers.length)
        .setValues([headers]);

    // Mise en forme de l'en-tête
    let headerRange = tarifSheet.getRange("A1").getAbsoluteResizedRange(1, headers.length);
    headerRange.getFormat().getFill().setColor("#629552");
    headerRange.getFormat().getFont().setColor("white");
    headerRange.getFormat().getFont().setBold(true);

    // Écrire les données
    if (lignesTarif.length > 0) {
        tarifSheet.getRange("A2").getAbsoluteResizedRange(
            lignesTarif.length,
            headers.length
        ).setValues(lignesTarif);

        // Format monétaire pour les colonnes Prix
        tarifSheet.getRange("D2:E" + (lignesTarif.length + 1))
            .setNumberFormat("#,##0.00 €");
    }

    // Ajuster largeur colonnes
    tarifSheet.getUsedRange().getFormat().autofitColumns();

    // ========================================
    // RÉSULTAT FINAL
    // ========================================

    console.log("✅ Script terminé avec succès !");
    console.log("Feuille créée : " + NOM_CLIENT);
    console.log("Profil appliqué : " + PROFIL_CLIENT);
    console.log("Remise fournisseur : " + (REMISE_FOURNISSEUR * 100) + "%");
}

Vérifier l’intégrité d’un fichier FAB-DIS : doublons, GTIN manquants, incohérences de prix

Les 5 types d’anomalies critiques dans un fichier FAB-DIS

Avant de plonger dans l’automatisation, il est essentiel de comprendre quelles anomalies guettent vos fichiers FAB-DIS. Voici les 5 catégories d’erreurs les plus fréquentes et les plus dangereuses :

Exemple concret d’anomalies détectées

Voici ce que peut contenir un fichier FAB-DIS reçu d’un fournisseur réel :

La checklist complète de vérification d’intégrité FAB-DIS

Voici la checklist exhaustive des contrôles à effectuer systématiquement avant tout import de fichier FAB-DIS. Cette liste servira de base à notre script automatisé.

Effectuer manuellement ces 17 vérifications sur un fichier de 5 000 produits prendrait entre 3 et 6 heures. Avec un script automatisé, cela prend moins de 30 secondes.

Le script « gardien » : validation automatique d’intégrité FAB-DIS

Voici le script Office Scripts complet qui effectue automatiquement tous les contrôles de la checklist et produit un rapport détaillé des anomalies détectées.

Code complet du script de validation

function main(workbook: ExcelScript.Workbook) {
  const sheet = workbook.getActiveWorksheet();
  const usedRange = sheet.getUsedRange();
  
  if (!usedRange) {
    console.log("❌ Erreur : la feuille est vide");
    return;
  }
  
  // Récupère les en-têtes
  const headerRange = sheet.getRange("1:1");
  const headerValues = headerRange.getValues();
  
  if (!headerValues || headerValues.length === 0 || !headerValues[0]) {
    console.log("❌ Erreur : pas d'en-têtes trouvés");
    return;
  }
  
  const headers = headerValues[0];
  
  // Identifie les colonnes importantes
  const colIndex: {[key: string]: number} = {};
  const colNames = ["REFCIALE", "GTIN", "EAN", "LIBELLE40", "LIBELLE80", "LIBELLE240", 
                    "PUTTC", "TARIF", "TVA", "FAM1", "QMV", "STOCK"];
  
  headers.forEach((header, index) => {
    const headerStr = String(header).toUpperCase().trim();
    colNames.forEach(colName => {
      if (headerStr === colName || headerStr.includes(colName)) {
        colIndex[colName] = index;
      }
    });
  });
  
  // Récupère toutes les données
  const dataRange = sheet.getRangeByIndexes(
    1, 
    0, 
    usedRange.getRowCount() - 1, 
    usedRange.getColumnCount()
  );
  const values = dataRange.getValues();
  
  // Variables de comptage
  let totalRows = values.length;
  let errors: {[key: string]: string[]} = {
    "Doublons REFCIALE": [],
    "Doublons GTIN": [],
    "GTIN manquants": [],
    "GTIN invalides": [],
    "Prix incohérents": [],
    "Prix à zéro": [],
    "TVA invalide": [],
    "Libellé manquant": [],
    "Libellé trop long": [],
    "Quantité négative": [],
    "Catégorie manquante": [],
    "Unité manquante": [],
    "Ligne vide": []
  };
  
  // Structures pour détecter les doublons
  const seenREFCIALE: {[key: string]: number[]} = {};
  const seenGTIN: {[key: string]: number[]} = {};
  
  // Liste des taux de TVA valides en France
  const validTVA = [0, 2.1, 5.5, 10, 20];
  
  // Analyse ligne par ligne
  values.forEach((row: any[], rowIndex: number) => {
    const lineNumber = rowIndex + 2; // +2 car index 0 = ligne 2 (après en-tête)
    
    // Vérifie si la ligne est complètement vide
    const isEmpty = row.every(cell => !cell || String(cell).trim() === "");
    if (isEmpty) {
      errors["Ligne vide"].push(`Ligne ${lineNumber}`);
      return;
    }
    
    // 1. Vérification REFCIALE
    if (colIndex["REFCIALE"] !== undefined) {
      const REFCIALE = String(row[colIndex["REFCIALE"]] || "").trim();
      if (REFCIALE) {
        if (!seenREFCIALE[REFCIALE]) {
          seenREFCIALE[REFCIALE] = [];
        }
        seenREFCIALE[REFCIALE].push(lineNumber);
      }
    }
    
    // 2. Vérification GTIN/EAN
    const gtinCol = colIndex["GTIN"] !== undefined ? colIndex["GTIN"] : colIndex["EAN"];
    if (gtinCol !== undefined) {
      const gtin = String(row[gtinCol] || "").trim();
      
      if (!gtin) {
        errors["GTIN manquants"].push(`Ligne ${lineNumber}`);
      } else {
        // Vérifie le format (doit être numérique, 8/12/13/14 chiffres)
        if (!/^\d{8}$|^\d{12}$|^\d{13}$|^\d{14}$/.test(gtin)) {
          errors["GTIN invalides"].push(`Ligne ${lineNumber} : "${gtin}"`);
        }
        
        // Détection doublons GTIN
        if (!seenGTIN[gtin]) {
          seenGTIN[gtin] = [];
        }
        seenGTIN[gtin].push(lineNumber);
      }
    }
    
// 3. Vérification prix (PUHT = TARIF, calcul TTC via TVA)
if (colIndex["TARIF"] !== undefined && colIndex["TVA"] !== undefined) {
  const puht = Number(row[colIndex["TARIF"]] || 0);
  const tva = Number(row[colIndex["TVA"]] || 0);

  // Prix TTC calculé
  const puttc = puht * (1 + tva / 100);

  // Prix à zéro ou négatif
  if (puht <= 0) {
    errors["Prix à zéro"].push(`Ligne ${lineNumber} : PUHT = ${puht}`);
  }

  // Prix incohérent : TVA invalide ou calcul aberrant
  if (tva < 0 || tva > 20) {
    errors["TVA invalide"].push(`Ligne ${lineNumber} : TVA = ${tva}`);
  }

  // Vérification prix public si présent
  if (colIndex["PUTTC"] !== undefined) {
    const prixPublic = Number(row[colIndex["PUTTC"]] || 0);

    if (prixPublic < puttc) {
      errors["Prix incohérents"].push(
        `Ligne ${lineNumber} : Prix public ${prixPublic} < Prix TTC calculé ${puttc.toFixed(2)}`
      );
    }
  }
}

    
    // 4. Vérification TVA
    if (colIndex["TVA"] !== undefined) {
      const tva = Number(row[colIndex["TVA"]] || 0);
      if (!validTVA.includes(tva)) {
        errors["TVA invalide"].push(`Ligne ${lineNumber} : ${tva}%`);
      }
    }
    
    // 5. Vérification libellés
    const libelle40 = String(row[colIndex["LIBELLE40"]] || "").trim();
    const libelle80 = String(row[colIndex["LIBELLE80"]] || "").trim();
    
    if (!libelle40 && !libelle80) {
      errors["Libellé manquant"].push(`Ligne ${lineNumber}`);
    }
    
    if (libelle40.length > 40) {
      errors["Libellé trop long"].push(`Ligne ${lineNumber} : LIBELLE40 = ${libelle40.length} car.`);
    }
    
    if (libelle80 && libelle80.length > 80) {
      errors["Libellé trop long"].push(`Ligne ${lineNumber} : LIBELLE80 = ${libelle80.length} car.`);
    }
    
    // 6. Vérification stock/quantité
    if (colIndex["STOCK"] !== undefined) {
      const stock = Number(row[colIndex["STOCK"]] || 0);
      if (stock < 0) {
        errors["Quantité négative"].push(`Ligne ${lineNumber} : Stock = ${stock}`);
      }
    }
    
    // 7. Vérification catégorie
    if (colIndex["FAM1"] !== undefined) {
      const famille = String(row[colIndex["FAM1"]] || "").trim();
      if (!famille) {
        errors["Catégorie manquante"].push(`Ligne ${lineNumber}`);
      }
    }
    
    // 8. Vérification unité
    if (colIndex["QMV"] !== undefined) {
      const QMV = String(row[colIndex["QMV"]] || "").trim();
      if (!QMV) {
        errors["Unité manquante"].push(`Ligne ${lineNumber}`);
      }
    }
  });
  
  // Détection des doublons REFCIALE
  Object.keys(seenREFCIALE).forEach(code => {
    if (seenREFCIALE[code].length > 1) {
      errors["Doublons REFCIALE"].push(`"${code}" : lignes ${seenREFCIALE[code].join(", ")}`);
    }
  });
  
  // Détection des doublons GTIN
  Object.keys(seenGTIN).forEach(gtin => {
    if (seenGTIN[gtin].length > 1) {
      errors["Doublons GTIN"].push(`"${gtin}" : lignes ${seenGTIN[gtin].join(", ")}`);
    }
  });
  
  // Calcul du score de qualité
  let totalErrors = 0;
  Object.values(errors).forEach(errorList => {
    totalErrors += errorList.length;
  });
  
  const qualityScore = Math.max(0, Math.round((1 - totalErrors / totalRows) * 100));
  
  // Génération du rapport
  console.log("═══════════════════════════════════════════════════════");
  console.log("🛡️  RAPPORT DE VALIDATION D'INTÉGRITÉ FAB-DIS");
  console.log("═══════════════════════════════════════════════════════");
  console.log("");
  console.log(`📊 Produits analysés : ${totalRows}`);
  console.log(`📈 Score de qualité : ${qualityScore}%`);
  console.log(`⚠️  Anomalies détectées : ${totalErrors}`);
  console.log("");
  
  if (totalErrors === 0) {
    console.log("✅ EXCELLENT ! Aucune anomalie détectée.");
    console.log("✅ Le fichier est prêt à être importé.");
  } else {
    console.log("───────────────────────────────────────────────────────");
    console.log("📋 DÉTAIL DES ANOMALIES PAR CATÉGORIE");
    console.log("───────────────────────────────────────────────────────");
    
    Object.keys(errors).forEach(category => {
      if (errors[category].length > 0) {
        console.log("");
        console.log(`❌ ${category} (${errors[category].length})`);
        errors[category].slice(0, 10).forEach(error => {
          console.log(`   → ${error}`);
        });
        if (errors[category].length > 10) {
          console.log(`   ... et ${errors[category].length - 10} autres`);
        }
      }
    });
    
    console.log("");
    console.log("───────────────────────────────────────────────────────");
    console.log("⚠️  ATTENTION : Corrigez ces anomalies avant import !");
  }
  
  console.log("═══════════════════════════════════════════════════════");
}

Guide d’implémentation et utilisation du script

Exemple de rapport généré

// Exemple : vérifier que REFCIALE commence toujours par "ART-"
if (colIndex["REFCIALE"] !== undefined) {
  const REFCIALE = String(row[colIndex["REFCIALE"]] || "").trim();
  if (REFCIALE && !REFCIALE.startsWith("ART-")) {
    errors["Format REFCIALE invalide"].push(`Ligne ${lineNumber} : "${REFCIALE}"`);
  }
}

// Exemple : vérifier une marge minimale de 30%
if (colIndex["PUTTC"] !== undefined && colIndex["TARIF"] !== undefined) {
  const puttc = Number(row[colIndex["PUTTC"]] || 0);
  const TARIF = Number(row[colIndex["TARIF"]] || 0);
  const marge = ((puttc - TARIF) / TARIF) * 100;
  
  if (marge < 30 && TARIF > 0) {
    errors["Marge insuffisante"].push(`Ligne ${lineNumber} : marge = ${marge.toFixed(1)}%`);
  }
}
    

Modifier les seuils d’alerte

Vous pouvez ajuster le score de qualité acceptable ou définir des niveaux d’alerte :

// Calcul du score avec niveau d'alerte
const qualityScore = Math.max(0, Math.round((1 - totalErrors / totalRows) * 100));

let qualityLevel = "";
if (qualityScore >= 95) {
  qualityLevel = "✅ EXCELLENT";
} else if (qualityScore >= 85) {
  qualityLevel = "🟢 BON";
} else if (qualityScore >= 70) {
  qualityLevel = "🟡 MOYEN (à corriger)";
} else {
  qualityLevel = "🔴 CRITIQUE (import déconseillé)";
}

console.log(`📈 Score de qualité : ${qualityScore}% - ${qualityLevel}`);

Exporter le rapport vers une feuille Excel

Plutôt que d’afficher le rapport dans la console, vous pouvez le créer dans une nouvelle feuille Excel pour le partager facilement :

// Créer une feuille "Rapport de validation"
let reportSheet = workbook.getWorksheet("Rapport de validation");
if (!reportSheet) {
  reportSheet = workbook.addWorksheet("Rapport de validation");
}
reportSheet.activate();

// Effacer le contenu existant
reportSheet.getRange().clear();

// Écrire le rapport
let currentRow = 1;
reportSheet.getRange(`A${currentRow}`).setValue("RAPPORT DE VALIDATION FAB-DIS");
currentRow += 2;

reportSheet.getRange(`A${currentRow}`).setValue("Produits analysés :");
reportSheet.getRange(`B${currentRow}`).setValue(totalRows);
currentRow++;

reportSheet.getRange(`A${currentRow}`).setValue("Score de qualité :");
reportSheet.getRange(`B${currentRow}`).setValue(`${qualityScore}%`);
currentRow++;

reportSheet.getRange(`A${currentRow}`).setValue("Anomalies détectées :");
reportSheet.getRange(`B${currentRow}`).setValue(totalErrors);
currentRow += 2;

// Écrire les anomalies par catégorie
Object.keys(errors).forEach(category => {
  if (errors[category].length > 0) {
    reportSheet.getRange(`A${currentRow}`).setValue(category);
    reportSheet.getRange(`B${currentRow}`).setValue(errors[category].length);
    currentRow++;
    
    errors[category].forEach(error => {
      reportSheet.getRange(`B${currentRow}`).setValue(error);
      currentRow++;
    });
    currentRow++;
  }
});

Intégrer le script dans votre workflow qualité

Pour maximiser l’efficacité du script de validation, intégrez-le comme étape systématique dans votre processus de gestion des FAB-DIS :

Automatiser l’exécution avec Power Automate

Si vous disposez d’un abonnement Microsoft 365 Business, vous pouvez automatiser complètement le processus :

1. Créez un flux Power Automate déclenché quand un nouveau fichier FAB-DIS arrive dans un dossier OneDrive/SharePoint
2. Exécutez automatiquement le script de validation via l’action « Exécuter un script Office »
3. Envoyez le rapport par email aux personnes concernées
4. Déplacez le fichier dans un dossier « Validé » ou « À corriger » selon le score

Témoignage client (PME spécialisée en électronique) :

« Avant le script de validation, nous importions directement les FAB-DIS dans notre ERP. Résultat : 2 à 3 fois par mois, des erreurs critiques qui nous obligeaient à tout reprendre. Ruptures de stock fictives, prix erronés affichés aux clients, litiges commerciaux…

Depuis que nous validons systématiquement avec le script avant import, nous avons divisé par 10 le nombre d’incidents. Le temps de correction est passé de 4-5 heures par mois à 30 minutes maximum. Et surtout, nous avons évité des litiges commerciaux qui nous coûtaient entre 500 et 2 000 € à chaque fois. »

Conclusion : de la réactivité à la proactivité

Valider l’intégrité de vos fichiers FAB-DIS avant import n’est plus une option, c’est une nécessité. Les conséquences d’un fichier non vérifié peuvent coûter entre 500 et 5 000 € par incident : litiges commerciaux, erreurs de facturation, ruptures de stock fictives, temps perdu en corrections d’urgence.

Avec un script de validation automatisé, vous passez d’une posture réactive à une posture proactive :

• ✅ Détection précoce : les anomalies sont identifiées avant qu’elles n’impactent votre système
• ⏱️ Gain de temps massif : de 3-6 heures à 30 secondes pour l’analyse complète
• 🎯 Correction ciblée : vous savez exactement où intervenir (numéro de ligne)
• 📊 Suivi qualité : score de qualité mesurable, historique des fichiers, identification des fournisseurs problématiques
• 🛡️ Sécurité renforcée : vous ne faites plus confiance aveuglément aux fichiers fournisseurs

Le script fourni dans cet article constitue votre « gardien automatique » qui scanne 17 points de contrôle critiques en quelques secondes. C’est un investissement minimal (30 minutes de mise en place) pour un ROI immédiat et durable.

Pour aller plus loin :
• FAB-DIS et automatisation : le guide ultime pour les TPE/PME

Nettoyer et standardiser les libellés produits FAB-DIS (LIBELLE40/80/240) automatiquement

Pourquoi les libellés FAB-DIS sont-ils mal formatés ?

Pour comprendre le problème, il faut revenir à la source. Les fichiers FAB-DIS sont produits par les systèmes informatiques des fabricants et distributeurs, souvent des ERP legacy qui ont 10, 15 ou 20 ans. Ces systèmes ont été conçus à une époque où :

• Les majuscules étaient la norme pour des raisons de compatibilité informatique
• Les espaces multiples n’étaient pas gérés lors de la saisie manuelle dans les bases de données
• L’encodage des caractères (accents, caractères spéciaux) variait d’un système à l’autre
• La présentation visuelle n’était pas une priorité : seule la donnée brute comptait

Les trois colonnes LIBELLE : comprendre leurs rôles

Le problème ? Ces trois colonnes subissent les mêmes défauts de formatage, et vous devez les traiter toutes les trois pour obtenir un catalogue cohérent.

Les erreurs de formatage les plus courantes

Problèmes identifiés :

• ✗ Tout en MAJUSCULES (agressif visuellement, peu lisible)
• ✗ Espaces multiples entre les mots (2, 3 ou même 4 espaces)
• ✗ Absence d’accents sur les mots français
• ✗ Formatage incohérent des unités (2M vs 2 METRES)

La solution : automatiser le nettoyage avec Office Scripts

Office Scripts est un outil d’automatisation intégré à Excel Online (Microsoft 365) qui permet de créer des scripts en TypeScript pour manipuler vos données. Contrairement aux macros VBA traditionnelles, Office Scripts fonctionne directement dans le cloud et ne nécessite aucune installation.

Ce que fait le script de nettoyage

Notre script Office Scripts va effectuer les opérations suivantes sur vos colonnes LIBELLE40, LIBELLE80 et LIBELLE240 :

1. Convertir en casse titre : première lettre en majuscule, reste en minuscule
2. Supprimer les espaces multiples : remplace 2+ espaces par un seul espace
3. Nettoyer les espaces de début/fin : supprime les espaces inutiles avant et après le texte
4. Gérer les cas spéciaux : préserver les acronymes courants (HDMI, USB, LED, etc.)
5. Uniformiser les séparateurs : remplace les tirets/underscores par des espaces si nécessaire

Le code complet du script

function main(workbook: ExcelScript.Workbook) {
    // ========================================
    // CONFIGURATION
    // ========================================
    const SHEET_NAME: string = "B01_COMMERCE";  // ou "Nouveaux_Produits" selon votre besoin

    // Récupère la feuille
    const sheet: ExcelScript.Worksheet | undefined = workbook.getWorksheet(SHEET_NAME);

    if (!sheet) {
        console.log(`Erreur : La feuille "${SHEET_NAME}" n'existe pas.`);
        return;
    }

    // Plage utilisée
    const usedRange: ExcelScript.Range | undefined = sheet.getUsedRange();

    if (!usedRange) {
        console.log("Erreur : Aucune donnée dans la feuille.");
        return;
    }

    // En-têtes (première ligne)
    const headerRow: ExcelScript.Range = usedRange.getRow(0);
    const headerValues: (string | number | boolean)[][] = headerRow.getValues();
    const headers: string[] = headerValues[0].map(cell => String(cell).trim());

    // ========================================
    // Identification des colonnes
    // ========================================
    const libelleColumns: {
        libelle40: number;
        libelle80: number;
        libelle240: number
    } = {
        libelle40: headers.findIndex(h => h.toUpperCase() === "LIBELLE40"),
        libelle80: headers.findIndex(h => h.toUpperCase() === "LIBELLE80"),
        libelle240: headers.findIndex(h => h.toUpperCase() === "LIBELLE240")
    };

    if (libelleColumns.libelle40 === -1 &&
        libelleColumns.libelle80 === -1 &&
        libelleColumns.libelle240 === -1) {
        console.log("Aucune colonne LIBELLE40/80/240 trouvée.");
        return;
    }

    // Acronymes à préserver
    const acronyms: string[] = [
        "HDMI", "USB", "LED", "LCD", "4K", "8K", "HD", "UHD",
        "SSD", "HDD", "CPU", "GPU", "V", "NM", "RFID", "WIFI", "BF", "LHS"
    ];

    // Fonction de nettoyage
    function cleanText(text: string | number | boolean): string {
        if (typeof text !== 'string' || !text.trim()) {
            return String(text || '');
        }

        let cleaned: string = text.replace(/\s+/g, ' ').trim().toLowerCase();

        cleaned = cleaned.split(' ')
            .map((word: string) => {
                const upper: string = word.toUpperCase();
                if (acronyms.includes(upper)) {
                    return upper;
                }
                if (/^\d+[a-z]$/i.test(word) || /^\d+V$/i.test(upper)) {
                    return upper;  // 24v → 24V
                }
                return word.charAt(0).toUpperCase() + word.slice(1);
            })
            .join(' ');

        return cleaned;
    }

    // ========================================
    // Traitement des données (à partir ligne 2)
    // ========================================
    const rowCount: number = usedRange.getRowCount();
    const colCount: number = usedRange.getColumnCount();

    const dataRange: ExcelScript.Range = sheet.getRangeByIndexes(1, 0, rowCount - 1, colCount);
    const values: (string | number | boolean)[][] = dataRange.getValues();

    values.forEach((row: (string | number | boolean)[]) => {
        if (libelleColumns.libelle40 !== -1) {
            row[libelleColumns.libelle40] = cleanText(row[libelleColumns.libelle40]);
        }
        if (libelleColumns.libelle80 !== -1) {
            row[libelleColumns.libelle80] = cleanText(row[libelleColumns.libelle80]);
        }
        if (libelleColumns.libelle240 !== -1) {
            row[libelleColumns.libelle240] = cleanText(row[libelleColumns.libelle240]);
        }
    });

    dataRange.setValues(values);

    console.log("Nettoyage terminé ! Colonnes traitées :");
    if (libelleColumns.libelle40 !== -1) console.log("- LIBELLE40");
    if (libelleColumns.libelle80 !== -1) console.log("- LIBELLE80");
    if (libelleColumns.libelle240 !== -1) console.log("- LIBELLE240");
}
  });
  
  // Réapplique les valeurs nettoyées
dataRange.setValues(values);console.log("Nettoyage terminé ! Colonnes traitées :");
if (libelleColumns.libelle40 !== -1) console.log("- LIBELLE40");
if (libelleColumns.libelle80 !== -1) console.log("- LIBELLE80");
if (libelleColumns.libelle240 !== -1) console.log("- LIBELLE240");
}

Guide d’implémentation étape par étape

Personnaliser le script selon vos besoins

Le script fourni est une base solide, mais vous pouvez l’adapter à vos exigences spécifiques. Voici quelques personnalisations courantes :

Ajouter des acronymes spécifiques à votre secteur

Si vous travaillez dans un secteur particulier (informatique, électronique, bricolage, etc.), vous avez probablement des acronymes métier qui doivent rester en majuscules. Modifiez simplement la ligne 25 du script :

// Exemple pour le secteur informatique/électronique
const acronyms = ["HDMI", "USB", "LED", "LCD", "4K", "8K", "HD", "UHD", 
                  "SSD", "HDD", "CPU", "GPU", "RAM", "RGB", "VGA", "DVI",
                  "SATA", "NVMe", "PCIe", "WiFi", "LAN", "WAN"];

// Exemple pour le secteur bricolage/construction
const acronyms = ["PVC", "MDF", "OSB", "DIY", "LED", "IP44", "IP65"];

// Exemple pour le secteur automobile
const acronyms = ["ABS", "ESP", "GPS", "LED", "SUV", "4WD", "CVT"];

Gérer les cas particuliers de mise en forme

Certains libellés nécessitent une mise en forme spéciale. Par exemple, vous voulez que « anti-rayures » garde son tiret, ou que les dimensions restent en majuscules (L, M, XL). Ajoutez ces règles dans la fonction cleanText() :

// Préserve les tirets dans certains mots
const wordsWithHyphens = ["anti-rayures", "multi-usage", "micro-ondes"];
wordsWithHyphens.forEach(word => {
  const regex = new RegExp(word, 'gi');
  cleaned = cleaned.replace(regex, word);
});

// Préserve les tailles de vêtements
const sizes = ["XS", "S", "M", "L", "XL", "XXL"];
sizes.forEach(size => {
  const regex = new RegExp(`\\b${size.toLowerCase()}\\b`, 'gi');
  cleaned = cleaned.replace(regex, size);
});

Nettoyer uniquement certaines colonnes

Si vous voulez traiter uniquement LIBELLE240 (par exemple pour un catalogue en ligne) et laisser LIBELLE40/80 inchangés, commentez les lignes correspondantes :

// Nettoie chaque cellule des colonnes libellé
values.forEach((row, rowIndex) => {
  // if (libelleColumns.libelle40 !== -1) {
  //   row[libelleColumns.libelle40] = cleanText(String(row[libelleColumns.libelle40]));
  // }
  // if (libelleColumns.libelle80 !== -1) {
  //   row[libelleColumns.libelle80] = cleanText(String(row[libelleColumns.libelle80]));
  // }
  if (libelleColumns.libelle240 !== -1) {
    row[libelleColumns.libelle240] = cleanText(String(row[libelleColumns.libelle240]));
  }
});

Aller plus loin : combiner avec d’autres automatisations

L’impact commercial d’un catalogue bien formaté

Au-delà du gain de temps, standardiser vos libellés produits a un impact direct sur vos performances commerciales. Voici pourquoi :

Exemple concret : impact sur un catalogue e-commerce

Cas client (TPE spécialisée en électronique) :

« Avant l’automatisation, nos fiches produits sur notre site e-commerce étaient copiées-collées directement du FAB-DIS de notre fournisseur. Tout était en MAJUSCULES avec des espaces bizarres. Après avoir implémenté le script de nettoyage automatique, nous avons constaté :

• ✅ +18% de taux de conversion sur les fiches produits révisées
• ✅ -35% de demandes SAV liées à des incompréhensions sur les produits
• ✅ 2h économisées par jour sur la mise à jour du catalogue

Le retour sur investissement a été immédiat. Le script s’est payé dès la première semaine. »

Conclusion : passer de la corvée à l’automatisation

Nettoyer manuellement les libellés produits de vos fichiers FAB-DIS est une tâche chronophage, répétitive et à faible valeur ajoutée. Pourtant, elle est indispensable pour maintenir un catalogue professionnel et performant.

En automatisant ce processus avec Office Scripts, vous gagnez :

• ⏱️ Du temps précieux : de 2 heures à 2 minutes par fichier
• 💼 Une image professionnelle : des descriptions cohérentes et lisibles
• 📈 De meilleures performances commerciales : meilleur taux de conversion et satisfaction client
• 😌 Moins de stress : vos équipes se concentrent sur des tâches à plus forte valeur ajoutée

Le script présenté dans cet article est une base solide que vous pouvez personnaliser selon vos besoins spécifiques. N’hésitez pas à l’adapter à votre secteur d’activité et à vos exigences de formatage.

Pour aller plus loin :
• FAB-DIS et automatisation : le guide ultime pour les TPE/PME

15 scripts Office essentiels pour vos FAB-DIS : le catalogue complet

Pourquoi constituer une bibliothèque de scripts ?

Contrairement aux macros VBA classiques, Office Scripts s’exécute dans le cloud et peut être réutilisé, partagé et orchestré. Une fois qu’un script est créé, il devient un actif permanent de votre organisation.

Les 4 avantages d’une bibliothèque de scripts

Les 5 catégories de scripts pour FAB-DIS

Les scripts Office pour FAB-DIS se répartissent en 5 grandes familles fonctionnelles. Voici comment nous organisons ce catalogue :

Catalogue des 15 scripts essentiels

🔧 Catégorie 1 : Scripts de Pré-traitement

Ces scripts préparent vos données FAB-DIS sans jamais modifier le fichier source, selon le principe de la zone de sécurité.

✅ Catégorie 2 : Scripts de Validation & Contrôle Qualité

Ces scripts détectent les anomalies critiques avant tout import dans votre système de gestion.

💎 Catégorie 3 : Scripts d’Enrichissement & Transformation

Ces scripts ajoutent de la valeur à vos données brutes en calculant, convertissant et catégorisant.

📊 Catégorie 4 : Scripts d’Export & Formatage

Ces scripts préparent vos données dans le format exact attendu par vos systèmes cibles.

📈 Catégorie 5 : Scripts de Reporting & Analyse

Ces scripts extraient de l’intelligence business de vos données FAB-DIS.

Comment choisir les bons scripts pour votre situation ?

Vous n’avez probablement pas besoin des 15 scripts immédiatement. Voici comment identifier vos priorités.

Roadmap d’implémentation recommandée

Combiner les scripts : créer des workflows complets

La vraie puissance vient de l’enchaînement de plusieurs scripts pour créer un workflow automatisé de bout en bout.

Retour d’expérience (PME négoce matériel BTP, 40 personnes) :

« Nous avons commencé avec 3 scripts (extraction, validation, calcul tarifs). ROI immédiat : 4 heures économisées par semaine. Encouragés par ce succès, nous avons ajouté progressivement 5 autres scripts sur 6 mois.

Aujourd’hui, notre bibliothèque contient 8 scripts actifs que nous enchaînons selon les besoins. Le workflow ‘Import ERP’ combine 4 scripts et tourne en 2 minutes vs 3 heures avant. Le workflow ‘Catalogue client’ en combine 5 et génère un PDF prêt à envoyer en 5 minutes.

Bilan après 1 an : 380 heures économisées, zéro erreur d’import ERP depuis 8 mois, satisfaction client augmentée (catalogues plus beaux et à jour). Investissement initial : 60 heures de développement (AutoExcel). ROI atteint en 2 mois. »

Conclusion : de la liste de souhaits à la bibliothèque opérationnelle

Ce catalogue de 15 scripts essentiels n’est pas une liste théorique, mais un condensé de cas d’usage réels observés sur des centaines de projets d’automatisation FAB-DIS.

Les 3 principes pour réussir votre bibliothèque de scripts :

• 🎯 Commencer petit : 3-4 scripts bien choisis valent mieux que 15 scripts mal maîtrisés
• 📊 Mesurer le ROI : chronométrez le temps « avant » vs « après » pour justifier les scripts suivants
• 🔄 Itérer progressivement : ajoutez un script par mois, perfectionnez, puis passez au suivant

Chaque script de cette liste résout un problème concret et génère un gain de temps mesurable. L’investissement dans une bibliothèque de 5-8 scripts actifs se rentabilise typiquement en 2-4 mois, puis continue de générer de la valeur pendant des années.

Pour aller plus loin :
• FAB-DIS et automatisation : le guide ultime pour les TPE/PME
• Automatiser le pré-traitement des données FAB-DIS
• Vérifier l’intégrité d’un fichier FAB-DIS : doublons, GTIN, prix

Office Script pour automatiser un fichier FAB-DIS : guide pratique et exemples

1. Office Script : qu’est-ce que c’est et pourquoi l’utiliser pour le FAB-DIS ?

Office Script est le langage de scripting moderne de Microsoft pour Excel. Contrairement a VBA qui existe depuis les annees 90, Office Script a ete lance en 2020 et repose sur TypeScript (une version typee de JavaScript). Il fonctionne exclusivement dans Excel pour le web et Excel pour Microsoft 365.

Comparaison VBA vs Office Script

Pourquoi Office Script est ideal pour le FAB-DIS

Les fichiers FAB-DIS sont particulierement adaptes a Office Script pour plusieurs raisons :

• Structure tabulaire fixe : Les colonnes (MARQUE, REFCIALE, GTIN, TARIF…) sont standardisees, ce qui facilite l’ecriture de scripts generiques.
• Flux recurrents : La mise a jour des tarifs, l’ajout de nouvelles references, la validation des donnees sont des taches repetitives.
• Collaboration multi-acteurs : Fournisseurs, ADV, chefs de produits peuvent travailler sur le meme fichier cloud.
• Integration ERP : Power Automate peut envoyer les donnees validees directement vers Sage, EBP, Cegid, etc.

2. Trois scripts Office Script prets a l’emploi pour le FAB-DIS

Voici trois scripts concrets que vous pouvez copier-coller directement dans l’editeur Office Script (onglet Automatiser puis Nouveau script dans Excel Online).

3. Aller plus loin : Office Script + Power Automate

La vraie puissance d’Office Script reside dans son integration avec Power Automate. Vous pouvez creer des flux automatiques qui declenchent vos scripts sans aucune action manuelle.

Exemple de flux automatise pour le FAB-DIS

Ce type de flux transforme un processus de 30 minutes (ouvrir le fichier, verifier, nettoyer, sauvegarder, notifier) en un processus de 0 minute pour l’utilisateur.

Limites a connaitre

Office Script n’est pas parfait. Voici les principales limitations a prendre en compte :

• Pas d’acces aux fichiers locaux : Le fichier doit etre sur OneDrive ou SharePoint.
• Pas de UserForms : Contrairement a VBA, vous ne pouvez pas creer de fenetres interactives.
• Performance sur gros volumes : Au-dela de 50 000 lignes, les temps d’execution augmentent significativement.
• Licence requise : Il faut une licence Microsoft 365 Business (pas la version gratuite).

Conclusion : Office Script, un allie puissant pour le FAB-DIS cloud

Office Script represente l’avenir de l’automatisation Excel dans un monde de plus en plus oriente cloud. Pour les TPE/PME du batiment qui travaillent deja avec Microsoft 365 et OneDrive, c’est une opportunite de moderniser leurs processus FAB-DIS sans investir dans des outils couteux.

Ce qu’il faut retenir :

• Office Script est ideal pour les traitements recurrents et les flux automatises (Power Automate).
• Les scripts sont ecrits en TypeScript, plus moderne que VBA, mais avec une courbe d’apprentissage.
• Pour les fichiers FAB-DIS, les cas d’usage prioritaires sont : validation GTIN, nettoyage de donnees, calculs tarifaires.
• VBA reste pertinent pour les gros volumes et les traitements locaux.

Pour aller plus loin, consultez notre guide ultime FAB-DIS et automatisation, ou decouvrez quand automatiser et quand laisser manuel pour prendre les bonnes decisions.