first_commit

GTA_P_V2/project/public/Backend/DockerfileGTA.backend

@@ -0,0 +1,24 @@
+FROM node:18-alpine
+
+# Install required tools
+RUN apk add --no-cache curl mysql-client python3 make g++
+
+WORKDIR /app
+
+# Copy package files first for better caching
+COPY package*.json ./
+
+# Install dependencies
+RUN npm install --production
+
+# Copy application code
+COPY . .
+
+# Create uploads directory
+RUN mkdir -p /app/uploads/medical
+
+# Expose the port
+EXPOSE 3004
+
+# Start the server
+CMD ["node", "server.js"]

GTA_P_V2/project/public/Backend/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "gta-backend",
+  "version": "1.0.0",
+  "description": "GTA Backend API",
+  "main": "server.js",
+  "type": "module",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "mssql": "^10.0.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "multer": "^1.4.5-lts.1",
+    "@microsoft/microsoft-graph-client": "^3.0.7",
+    "@azure/identity": "^4.0.0",
+    "body-parser": "^1.20.2",
+    "axios": "^1.6.0",
+    "node-cron": "^3.0.3"
+
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

GTA_P_V2/project/public/Backend/server-test.js

@@ -0,0 +1,570 @@
+import express from 'express';
+import cors from 'cors';
+import sql from 'mssql';
+import axios from 'axios';
+
+const app = express();
+const PORT = 3000;
+
+app.use(cors({ origin: '*' }));
+app.use(express.json());
+
+// Configuration Azure AD
+const AZURE_CONFIG = {
+    tenantId: '9840a2a0-6ae1-4688-b03d-d2ec291be0f9',
+    clientId: '4bb4cc24-bac3-427c-b02c-5d14fc67b561',
+    clientSecret: 'gvf8Q~545Bafn8yYsgjW~QG_P1lpzaRe6gJNgb2t',
+    groupId: 'c1ea877c-6bca-4f47-bfad-f223640813a0'
+};
+
+// Configuration SQL Server
+const dbConfig = {
+    server: '192.168.0.3',
+    user: 'gta_app',
+    password: 'GTA2025!Secure',
+    database: 'GTA',
+    port: 1433,
+    options: {
+        encrypt: true,
+        trustServerCertificate: true,
+        enableArithAbort: true,
+        connectTimeout: 60000,
+        requestTimeout: 60000
+    },
+    pool: {
+        max: 10,
+        min: 0,
+        idleTimeoutMillis: 30000
+    }
+};
+
+// Créer le pool de connexions
+const pool = new sql.ConnectionPool(dbConfig);
+
+// Connexion au démarrage
+pool.connect()
+    .then(() => {
+        console.log('✅ Connecté à SQL Server');
+        console.log(`   Base: ${dbConfig.database}@${dbConfig.server}`);
+    })
+    .catch(err => {
+        console.error('❌ Erreur connexion SQL Server:', err.message);
+    });
+
+// ========================================
+// WRAPPER POUR COMPATIBILITÉ (style MySQL)
+// ========================================
+pool.query = async function (queryText, params = []) {
+    if (!pool.connected) {
+        await pool.connect();
+    }
+
+    const request = pool.request();
+
+    // Ajouter les paramètres
+    params.forEach((value, index) => {
+        request.input(`param${index}`, value);
+    });
+
+    // Remplacer ? par @param0, @param1, etc.
+    let parameterizedQuery = queryText;
+    let paramIndex = 0;
+    parameterizedQuery = parameterizedQuery.replace(/\?/g, () => `@param${paramIndex++}`);
+
+    // Conversion LIMIT → TOP
+    parameterizedQuery = parameterizedQuery.replace(
+        /LIMIT\s+(\d+)/gi,
+        (match, limit) => {
+            return parameterizedQuery.includes('SELECT')
+                ? parameterizedQuery.replace(/SELECT/i, `SELECT TOP ${limit}`)
+                : '';
+        }
+    );
+
+    const result = await request.query(parameterizedQuery);
+    return result.recordset || [];
+};
+
+// ========================================
+// 🔑 FONCTION TOKEN MICROSOFT GRAPH
+// ========================================
+async function getGraphToken() {
+    try {
+        const params = new URLSearchParams({
+            grant_type: 'client_credentials',
+            client_id: AZURE_CONFIG.clientId,
+            client_secret: AZURE_CONFIG.clientSecret,
+            scope: 'https://graph.microsoft.com/.default'
+        });
+
+        const response = await axios.post(
+            `https://login.microsoftonline.com/${AZURE_CONFIG.tenantId}/oauth2/v2.0/token`,
+            params.toString(),
+            { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
+        );
+
+        return response.data.access_token;
+    } catch (error) {
+        console.error('❌ Erreur obtention token:', error.message);
+        return null;
+    }
+}
+
+// ========================================
+// 🔄 FONCTION SYNCHRONISATION ENTRA ID
+// ========================================
+async function syncEntraIdUsers() {
+    const syncResults = {
+        processed: 0,
+        inserted: 0,
+        updated: 0,
+        deactivated: 0,
+        errors: []
+    };
+
+    try {
+        console.log('\n🔄 === DÉBUT SYNCHRONISATION ENTRA ID ===');
+
+        // 1️⃣ Obtenir le token
+        const accessToken = await getGraphToken();
+        if (!accessToken) {
+            console.error('❌ Impossible d\'obtenir le token');
+            return syncResults;
+        }
+        console.log('✅ Token obtenu');
+
+        // 2️⃣ Récupérer le groupe
+        const groupResponse = await axios.get(
+            `https://graph.microsoft.com/v1.0/groups/${AZURE_CONFIG.groupId}?$select=id,displayName`,
+            { headers: { Authorization: `Bearer ${accessToken}` } }
+        );
+        const groupName = groupResponse.data.displayName;
+        console.log(`📋 Groupe : ${groupName}`);
+
+        // 3️⃣ Récupérer tous les membres avec pagination
+        let allAzureMembers = [];
+        let nextLink = `https://graph.microsoft.com/v1.0/groups/${AZURE_CONFIG.groupId}/members?$select=id,givenName,surname,mail,department,jobTitle,officeLocation,accountEnabled&$top=999`;
+
+        console.log('📥 Récupération des membres...');
+        while (nextLink) {
+            const membersResponse = await axios.get(nextLink, {
+                headers: { Authorization: `Bearer ${accessToken}` }
+            });
+            allAzureMembers = allAzureMembers.concat(membersResponse.data.value);
+            nextLink = membersResponse.data['@odata.nextLink'];
+
+            if (nextLink) {
+                console.log(`   📄 ${allAzureMembers.length} membres récupérés...`);
+            }
+        }
+
+        console.log(`✅ ${allAzureMembers.length} membres trouvés`);
+
+        // 4️⃣ Filtrer les membres valides
+        const validMembers = allAzureMembers.filter(m => {
+            if (!m.mail || m.mail.trim() === '') return false;
+            if (m.accountEnabled === false) return false;
+
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            return emailRegex.test(m.mail);
+        });
+
+        console.log(`✅ ${validMembers.length} membres valides`);
+
+        // 5️⃣ Traitement avec transaction
+        const transaction = new sql.Transaction(pool);
+        await transaction.begin();
+
+        try {
+            const azureEmails = new Set();
+            validMembers.forEach(m => {
+                azureEmails.add(m.mail.toLowerCase().trim());
+            });
+
+            console.log('\n📝 Traitement des utilisateurs...');
+
+            // 6️⃣ Pour chaque membre
+            for (const m of validMembers) {
+                try {
+                    const emailClean = m.mail.toLowerCase().trim();
+                    syncResults.processed++;
+
+                    // Vérifier existence
+                    const request = new sql.Request(transaction);
+                    request.input('email', sql.NVarChar, emailClean);
+
+                    const result = await request.query(`
+                        SELECT id, email, entraUserId, actif 
+                        FROM CollaborateurAD 
+                        WHERE LOWER(email) = LOWER(@email)
+                    `);
+
+                    if (result.recordset.length > 0) {
+                        // MISE À JOUR
+                        const updateRequest = new sql.Request(transaction);
+                        updateRequest.input('entraUserId', sql.NVarChar, m.id);
+                        updateRequest.input('prenom', sql.NVarChar, m.givenName || '');
+                        updateRequest.input('nom', sql.NVarChar, m.surname || '');
+                        updateRequest.input('departement', sql.NVarChar, m.department || '');
+                        updateRequest.input('fonction', sql.NVarChar, m.jobTitle || '');
+                        updateRequest.input('campus', sql.NVarChar, m.officeLocation || '');
+                        updateRequest.input('email', sql.NVarChar, emailClean);
+
+                        await updateRequest.query(`
+                            UPDATE CollaborateurAD 
+                            SET 
+                                entraUserId = @entraUserId,
+                                prenom = @prenom,
+                                nom = @nom,
+                                departement = @departement,
+                                fonction = @fonction,
+                                campus = @campus,
+                                actif = 1
+                            WHERE LOWER(email) = LOWER(@email)
+                        `);
+
+                        syncResults.updated++;
+                        console.log(`   ✓ Mis à jour : ${emailClean}`);
+
+                    } else {
+                        // INSERTION
+                        const insertRequest = new sql.Request(transaction);
+                        insertRequest.input('entraUserId', sql.NVarChar, m.id);
+                        insertRequest.input('prenom', sql.NVarChar, m.givenName || '');
+                        insertRequest.input('nom', sql.NVarChar, m.surname || '');
+                        insertRequest.input('email', sql.NVarChar, emailClean);
+                        insertRequest.input('departement', sql.NVarChar, m.department || '');
+                        insertRequest.input('fonction', sql.NVarChar, m.jobTitle || '');
+                        insertRequest.input('campus', sql.NVarChar, m.officeLocation || '');
+
+                        await insertRequest.query(`
+                            INSERT INTO CollaborateurAD 
+                            (entraUserId, prenom, nom, email, departement, fonction, campus, role, SocieteId, actif, dateCreation, TypeContrat) 
+                            VALUES (@entraUserId, @prenom, @nom, @email, @departement, @fonction, @campus, 'Collaborateur', 1, 1, GETDATE(), '37h')
+                        `);
+
+                        syncResults.inserted++;
+                        console.log(`   ✓ Créé : ${emailClean}`);
+                    }
+
+                } catch (userError) {
+                    syncResults.errors.push({
+                        email: m.mail,
+                        error: userError.message
+                    });
+                    console.error(`   ❌ Erreur ${m.mail}:`, userError.message);
+                }
+            }
+
+            // 7️⃣ DÉSACTIVATION des comptes absents
+            console.log('\n🔍 Désactivation des comptes obsolètes...');
+
+            if (azureEmails.size > 0) {
+                const activeEmailsList = Array.from(azureEmails).map(e => `'${e}'`).join(',');
+
+                const deactivateRequest = new sql.Request(transaction);
+                const deactivateResult = await deactivateRequest.query(`
+                    UPDATE CollaborateurAD 
+                    SET actif = 0
+                    WHERE 
+                        email IS NOT NULL 
+                        AND email != ''
+                        AND LOWER(email) NOT IN (${activeEmailsList})
+                        AND actif = 1
+                `);
+
+                syncResults.deactivated = deactivateResult.rowsAffected[0];
+                console.log(`   ✓ ${syncResults.deactivated} compte(s) désactivé(s)`);
+            }
+
+            await transaction.commit();
+
+            console.log('\n📊 === RÉSUMÉ ===');
+            console.log(`   Groupe: ${groupName}`);
+            console.log(`   Total Entra: ${allAzureMembers.length}`);
+            console.log(`   Valides: ${validMembers.length}`);
+            console.log(`   Traités: ${syncResults.processed}`);
+            console.log(`   Créés: ${syncResults.inserted}`);
+            console.log(`   Mis à jour: ${syncResults.updated}`);
+            console.log(`   Désactivés: ${syncResults.deactivated}`);
+            console.log(`   Erreurs: ${syncResults.errors.length}`);
+
+        } catch (error) {
+            await transaction.rollback();
+            throw error;
+        }
+
+    } catch (error) {
+        console.error('\n❌ ERREUR SYNCHRONISATION:', error.message);
+    }
+
+    return syncResults;
+}
+
+// ========================================
+// 📡 ROUTES API
+// ========================================
+
+// Route test connexion
+app.get('/api/db-status', async (req, res) => {
+    try {
+        const result = await pool.query('SELECT COUNT(*) AS count FROM CollaborateurAD', []);
+        const collaboratorCount = result[0]?.count || 0;
+
+        res.json({
+            success: true,
+            message: 'Connexion SQL Server OK',
+            collaboratorCount,
+        });
+    } catch (error) {
+        console.error('Erreur connexion:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Erreur connexion base',
+            error: error.message,
+        });
+    }
+});
+
+// Route sync unitaire
+app.post('/api/initial-sync', async (req, res) => {
+    try {
+        const email = (req.body.mail || req.body.userPrincipalName)?.toLowerCase().trim();
+        const entraUserId = req.body.id;
+
+        if (!email) {
+            return res.json({ success: false, message: 'Email manquant' });
+        }
+
+        console.log(`\n🔄 Sync utilisateur : ${email}`);
+
+        const transaction = new sql.Transaction(pool);
+        await transaction.begin();
+
+        try {
+            // Vérifier existence
+            const checkRequest = new sql.Request(transaction);
+            checkRequest.input('email', sql.NVarChar, email);
+
+            const existing = await checkRequest.query(`
+                SELECT id, email, actif 
+                FROM CollaborateurAD 
+                WHERE LOWER(email) = LOWER(@email)
+            `);
+
+            if (existing.recordset.length > 0) {
+                // UPDATE
+                const updateRequest = new sql.Request(transaction);
+                updateRequest.input('collaborateurADId', sql.NVarChar, entraUserId);
+                updateRequest.input('prenom', sql.NVarChar, req.body.givenName || '');
+                updateRequest.input('nom', sql.NVarChar, req.body.surname || '');
+                updateRequest.input('departement', sql.NVarChar, req.body.department || '');
+                updateRequest.input('fonction', sql.NVarChar, req.body.jobTitle || '');
+                updateRequest.input('campus', sql.NVarChar, req.body.officeLocation || '');
+                updateRequest.input('email', sql.NVarChar, email);
+                updateRequest.input('dateMaj', sql.DateTime, new Date());
+
+                await updateRequest.query(`
+                    UPDATE CollaborateurAD 
+                    SET 
+                        CollaborateurADId = @collaborateurADId,
+                        prenom = @prenom,
+                        nom = @nom,
+                        departement = @departement,
+                        fonction = @fonction,
+                        campus = @campus,
+                        actif = 1,
+                        dateMiseAJour = @dateMaj
+                    WHERE LOWER(email) = LOWER(@email)
+                `);
+
+                console.log(`   ✅ Mis à jour : ${email}`);
+            } else {
+                // INSERT
+                const insertRequest = new sql.Request(transaction);
+                insertRequest.input('collaborateurADId', sql.NVarChar, entraUserId);
+                insertRequest.input('prenom', sql.NVarChar, req.body.givenName || '');
+                insertRequest.input('nom', sql.NVarChar, req.body.surname || '');
+                insertRequest.input('email', sql.NVarChar, email);
+                insertRequest.input('departement', sql.NVarChar, req.body.department || '');
+                insertRequest.input('fonction', sql.NVarChar, req.body.jobTitle || '');
+                insertRequest.input('campus', sql.NVarChar, req.body.officeLocation || '');
+                insertRequest.input('dateCreation', sql.DateTime, new Date());
+                insertRequest.input('dateMaj', sql.DateTime, new Date());
+
+                await insertRequest.query(`
+                    INSERT INTO CollaborateurAD 
+                    (CollaborateurADId, prenom, nom, email, departement, fonction, campus, service, societe, actif, dateCreation, dateMiseAJour) 
+                    VALUES (@collaborateurADId, @prenom, @nom, @email, @departement, @fonction, @campus, NULL, NULL, 1, @dateCreation, @dateMaj)
+                `);
+
+                console.log(`   ✅ Créé : ${email}`);
+            }
+
+            // Récupérer données
+            const getUserRequest = new sql.Request(transaction);
+            getUserRequest.input('email', sql.NVarChar, email);
+
+            const userData = await getUserRequest.query(`
+                SELECT id as localUserId, email, prenom, nom, fonction, departement
+                FROM CollaborateurAD
+                WHERE LOWER(email) = LOWER(@email)
+            `);
+
+            await transaction.commit();
+
+            if (userData.recordset.length === 0) {
+                throw new Error('Utilisateur introuvable après sync');
+            }
+
+            res.json({
+                success: true,
+                message: 'Sync réussie',
+                localUserId: userData.recordset[0].localUserId,
+                user: userData.recordset[0]
+            });
+
+        } catch (error) {
+            await transaction.rollback();
+            throw error;
+        }
+
+    } catch (error) {
+        console.error('❌ Erreur sync:', error);
+        res.json({
+            success: false,
+            message: error.message
+        });
+    }
+});
+
+// Route check groups
+app.post('/api/check-user-groups', async (req, res) => {
+    try {
+        const { userPrincipalName } = req.body;
+
+        if (!userPrincipalName) {
+            return res.json({ authorized: false, message: 'Email manquant' });
+        }
+
+        const users = await pool.query(
+            'SELECT id, email, prenom, nom, actif FROM CollaborateurAD WHERE email = ?',
+            [userPrincipalName]
+        );
+
+        if (users.length > 0) {
+            const user = users[0];
+
+            if (user.actif === 0) {
+                return res.json({ authorized: false, message: 'Compte désactivé' });
+            }
+
+            return res.json({
+                authorized: true,
+                localUserId: user.id,
+                user: user
+            });
+        }
+
+        res.json({
+            authorized: true,
+            message: 'Sera créé au login'
+        });
+
+    } catch (error) {
+        console.error('❌ Erreur check:', error);
+        res.json({ authorized: false, error: error.message });
+    }
+});
+
+// Route sync complète manuelle
+app.post('/api/sync-all', async (req, res) => {
+    try {
+        console.log('🚀 Sync complète manuelle...');
+        const results = await 
+        IdUsers();
+
+        res.json({
+            success: true,
+            message: 'Sync terminée',
+            stats: results
+        });
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            message: error.message
+        });
+    }
+});
+
+// Route diagnostic
+app.get('/api/diagnostic-sync', async (req, res) => {
+    try {
+        const totalDB = await pool.query(
+            'SELECT COUNT(*) as total, SUM(CASE WHEN actif = 1 THEN 1 ELSE 0 END) as actifs FROM CollaborateurAD',
+            []
+        );
+
+        const sansEmail = await pool.query(
+            'SELECT COUNT(*) as total FROM CollaborateurAD WHERE email IS NULL OR email = \'\'',
+            []
+        );
+
+        const derniers = await pool.query(
+            'SELECT TOP 10 id, prenom, nom, email, CollaborateurADId, actif FROM CollaborateurAD ORDER BY id DESC',
+            []
+        );
+
+        // Test Entra
+        let entraStatus = { connected: false };
+        try {
+            const token = await getGraphToken();
+            if (token) {
+                const groupResponse = await axios.get(
+                    `https://graph.microsoft.com/v1.0/groups/${AZURE_CONFIG.groupId}?$select=id,displayName`,
+                    { headers: { Authorization: `Bearer ${token}` } }
+                );
+                entraStatus = {
+                    connected: true,
+                    groupName: groupResponse.data.displayName
+                };
+            }
+        } catch (err) {
+            entraStatus.error = err.message;
+        }
+
+        res.json({
+            success: true,
+            database: {
+                total: totalDB[0]?.total || 0,
+                actifs: totalDB[0]?.actifs || 0,
+                sansEmail: sansEmail[0]?.total || 0
+            },
+            entraId: entraStatus,
+            derniers_utilisateurs: derniers
+        });
+
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+// ========================================
+// 🚀 DÉMARRAGE
+// ========================================
+app.listen(PORT, "0.0.0.0", async () => {
+    console.log("✅ ==========================================");
+    console.log("   SERVEUR TEST DÉMARRÉ");
+    console.log("   Port:", PORT);
+    console.log(`   Base SQL Server: ${dbConfig.database}@${dbConfig.server}`);
+    console.log("==========================================");
+
+    // Sync auto après 5 secondes
+    setTimeout(async () => {
+        console.log("\n🚀 Sync Entra ID automatique...");
+        await syncEntraIdUsers();
+    }, 5000);
+});

GTA_P_V2/project/public/Backend/useSSENotifications.js

@@ -0,0 +1,38 @@
+// hooks/useSSENotifications.js
+import { useEffect, useCallback } from 'react';
+
+export const useSSENotifications = (token, collaborateurId, onEventReceived) => {
+    useEffect(() => {
+        if (!token || !collaborateurId) return;
+
+        const eventSource = new EventSource(
+            `/api/events?token=${encodeURIComponent(token)}`
+        );
+
+        eventSource.onmessage = (event) => {
+            try {
+                const data = JSON.parse(event.data);
+
+                console.log('📨 SSE reçu:', data);
+
+                // Log spécifique pour les récupérations
+                if (data.type === 'demande-validated' && data.typeConge === 'Récupération') {
+                    console.log('🎨 Couleur reçue:', data.couleurHex);
+                }
+
+                onEventReceived(data);
+            } catch (error) {
+                console.error('❌ Erreur parsing SSE:', error);
+            }
+        };
+
+        eventSource.onerror = (error) => {
+            console.error('❌ Erreur SSE:', error);
+            eventSource.close();
+        };
+
+        return () => {
+            eventSource.close();
+        };
+    }, [token, collaborateurId, onEventReceived]);
+};

GTA_P_V2/project/public/Backend/webhook-config.js

@@ -0,0 +1,19 @@
+// webhook-config.js
+
+
+
+export const WEBHOOKS= {
+        COLLABORATEURS_URL: process.env.COLLABORATEURS_URL || 'http://localhost:3000',
+        RH_URL: process.env.RH_URL || 'http://localhost:3001',
+        SECRET_KEY: process.env.WEBHOOK_SECRET || 'secret-key-securise'
+    };
+
+    // Types d'événements
+export const   EVENTS= {
+        DEMANDE_VALIDATED: 'demande.validated',
+        DEMANDE_CREATED: 'demande.created',
+        DEMANDE_UPDATED: 'demande.updated',
+        DEMANDE_DELETED: 'demande.deleted',
+        COMPTEUR_UPDATED: 'compteur.updated'
+    
+};

GTA_P_V2/project/public/Backend/webhook-utils.js

@@ -0,0 +1,116 @@
+// webhook-utils.js (VERSION ES MODULES - CORRIGÉE)
+// Pour projets avec "type": "module" dans package.json
+
+import axios from 'axios';
+import crypto from 'crypto';
+
+class WebhookManager {
+    constructor(secretKey) {
+        this.secretKey = secretKey;
+    }
+
+    /**
+     * Génère une signature HMAC SHA-256 pour sécuriser le webhook
+     * @param {Object} payload - Les données à signer
+     * @returns {string} La signature hexadécimale
+     */
+    generateSignature(payload) {
+        return crypto
+            .createHmac('sha256', this.secretKey)
+            .update(JSON.stringify(payload))
+            .digest('hex');
+    }
+
+    /**
+     * Vérifie la signature d'un webhook reçu
+     * @param {Object} payload - Les données reçues
+     * @param {string} receivedSignature - La signature reçue dans le header
+     * @returns {boolean} True si la signature est valide
+     */
+    verifySignature(payload, receivedSignature) {
+        if (!receivedSignature) {
+            console.error('❌ Aucune signature fournie');
+            return false;
+        }
+
+        try {
+            const expectedSignature = this.generateSignature(payload);
+            return crypto.timingSafeEqual(
+                Buffer.from(expectedSignature),
+                Buffer.from(receivedSignature)
+            );
+        } catch (error) {
+            console.error('❌ Erreur vérification signature:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Envoie un webhook à une URL cible avec retry automatique
+     * @param {string} targetUrl - URL du serveur cible
+     * @param {string} eventType - Type d'événement (ex: 'demande.validated')
+     * @param {Object} data - Données de l'événement
+     * @param {number} retries - Nombre de tentatives (défaut: 3)
+     * @returns {Promise<Object>} La réponse du serveur
+     */
+    async sendWebhook(targetUrl, eventType, data, retries = 3) {
+        const payload = {
+            event: eventType,
+            data: data,
+            timestamp: new Date().toISOString()
+        };
+
+        const signature = this.generateSignature(payload);
+
+        for (let attempt = 1; attempt <= retries; attempt++) {
+            try {
+                console.log(`📤 Envoi webhook: ${eventType} vers ${targetUrl} (tentative ${attempt}/${retries})`);
+                console.log(`   Données:`, JSON.stringify(data, null, 2));
+
+                const response = await axios.post(
+                    `${targetUrl}/api/webhook/receive`,
+                    payload,
+                    {
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'X-Webhook-Signature': signature
+                        },
+                        timeout: 5000 // 5 secondes de timeout
+                    }
+                );
+
+                console.log(`✅ Webhook envoyé avec succès: ${eventType}`);
+                return response.data;
+
+            } catch (error) {
+                console.error(`❌ Erreur envoi webhook (tentative ${attempt}/${retries}):`, error.message);
+
+                if (attempt === retries) {
+                    console.error(`❌ Échec définitif du webhook après ${retries} tentatives`);
+                    throw error;
+                }
+
+                // Attendre avant de réessayer (backoff exponentiel)
+                const waitTime = 1000 * attempt;
+                console.log(`⏳ Nouvelle tentative dans ${waitTime}ms...`);
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+        }
+    }
+
+    /**
+     * Envoie un webhook sans attendre la réponse (fire and forget)
+     * Utile pour ne pas bloquer l'exécution
+     * @param {string} targetUrl - URL du serveur cible
+     * @param {string} eventType - Type d'événement
+     * @param {Object} data - Données de l'événement
+     */
+    sendWebhookAsync(targetUrl, eventType, data) {
+        this.sendWebhook(targetUrl, eventType, data)
+            .catch(error => {
+                console.error('❌ Webhook async échoué (non bloquant):', error.message);
+            });
+    }
+}
+
+export default WebhookManager;