connexion avec signalR

main.js

@@ -6,8 +6,10 @@ const signalR = require('@microsoft/signalr');
 let mainWindow;
 let config;
 let currentAgent = null;
+let currentTerminal = null; // Terminal téléphonique de l'agent connecté
 let signalRConnection = null;
 let signalRStatus = 'disconnected'; // disconnected, connecting, connected, error
+let agentConnectionInfo = null; // Informations complètes retournées par SignalR
 
 // Charger la configuration
 function loadConfig() {
@@ -97,10 +99,70 @@ function initializeSignalR() {
 function setupSignalRMethods() {
   // Écouter les événements IPBX
   signalRConnection.on('IpbxEvent', (name, args) => {
-    if (!args) return;
+    if (!args || !agentConnectionInfo) return;
+    
     const event = args[0];
-    console.log('Événement IPBX reçu:', event);
-    // TODO: Gérer les événements d'appel
+    console.log('Événement IPBX reçu:', {
+      eventCode: event.eventCode,
+      terminal: event.terminal,
+      queueName: event.queueName
+    });
+    
+    // Vérifier que l'événement est pour notre terminal
+    if (event.terminal !== currentTerminal) {
+      console.log('Événement ignoré - Terminal différent:', event.terminal, '!==', currentTerminal);
+      return;
+    }
+    
+    // Gérer les différents types d'événements
+    switch(event.eventCode) {
+      case 1: // Appel décroché
+        handleCallPickedUp(event);
+        break;
+      case 2: // Appel raccroché  
+        handleCallHungUp(event);
+        break;
+      default:
+        console.log('Code événement non géré:', event.eventCode);
+    }
+  });
+}
+
+// Gérer un appel entrant
+function handleCallPickedUp(event) {
+  if (!mainWindow || !agentConnectionInfo) return;
+  
+  // Identifier le centre correspondant à la file
+  const centres = processApplicationUrls(agentConnectionInfo.connList);
+  const centre = centres.find(c => c.queueName === event.queueName);
+  
+  if (centre) {
+    console.log('Basculement vers le centre:', centre.nom);
+    
+    // Envoyer l'instruction de basculement à la fenêtre
+    mainWindow.webContents.send('switch-to-center', {
+      centreId: centre.id,
+      centreName: centre.nom,
+      queueName: event.queueName,
+      terminal: event.terminal,
+      eventType: 'call_pickup'
+    });
+  } else {
+    console.warn('Aucun centre trouvé pour la file:', event.queueName);
+  }
+}
+
+// Gérer la fin d'un appel
+function handleCallHungUp(event) {
+  if (!mainWindow) return;
+  
+  console.log('Fin d\'appel sur la file:', event.queueName);
+  
+  // Envoyer l'instruction de libération à la fenêtre
+  mainWindow.webContents.send('release-center', {
+    queueName: event.queueName,
+    terminal: event.terminal,
+    eventType: 'call_hangup'
   });
 }
 
@@ -159,7 +221,22 @@ app.whenReady().then(() => {
 });
 
 // Quitter quand toutes les fenêtres sont fermées
-app.on('window-all-closed', () => {
+app.on('window-all-closed', async () => {
+  // Déconnexion propre avant de quitter
+  if (currentAgent && signalRConnection && signalRStatus === 'connected') {
+    try {
+      await signalRConnection.invoke('AgentLogoff', currentAgent.accessCode);
+      console.log('Déconnexion agent avant fermeture');
+    } catch (error) {
+      console.error('Erreur déconnexion:', error);
+    }
+  }
+  
+  // Arrêter SignalR
+  if (signalRConnection) {
+    await signalRConnection.stop();
+  }
+  
   if (process.platform !== 'darwin') {
     app.quit();
   }
@@ -208,46 +285,158 @@ ipcMain.handle('get-terminal-list', async () => {
   }
 });
 
-// Connexion agent
-ipcMain.handle('login-agent', (event, credentials) => {
-  const agent = config.agents.find(a => 
-    a.email === credentials.email && 
-    a.password === credentials.password
-  );
-  
-  if (agent) {
-    currentAgent = agent;
-    // Retourner l'agent avec ses centres assignés
-    const centresAssignes = config.centres.filter(c => 
-      agent.centresAssignes.includes(c.id)
-    );
-    return {
-      success: true,
-      agent: agent,
-      centres: centresAssignes
+// Connexion agent via SignalR
+ipcMain.handle('login-agent', async (event, credentials) => {
+  // Vérifier que SignalR est connecté
+  if (!signalRConnection || signalRStatus !== 'connected') {
+    return { 
+      success: false, 
+      message: 'Connexion au serveur SignalR non établie. Veuillez réessayer.' 
+    };
+  }
+
+  try {
+    console.log('Tentative de connexion agent:', credentials.email, 'Terminal:', credentials.terminal);
+    
+    // Appel SignalR pour l'authentification
+    const result = await signalRConnection.invoke('AgentLogin',
+      credentials.email,
+      credentials.password,
+      credentials.terminal
+    );
+    
+    if (result) {
+      console.log('Connexion réussie:', result);
+      
+      // Stocker les informations de connexion
+      agentConnectionInfo = result;
+      currentTerminal = credentials.terminal;
+      
+      // Créer l'objet agent pour compatibilité
+      currentAgent = {
+        id: result.accessCode,
+        accessCode: result.accessCode,
+        name: `${result.firstName} ${result.lastName}`,
+        email: credentials.email,
+        firstName: result.firstName,
+        lastName: result.lastName,
+        terminal: credentials.terminal
+      };
+      
+      // Traiter les URLs des applications et créer les centres
+      const centres = processApplicationUrls(result.connList);
+      
+      // Mettre à jour le titre de la fenêtre
+      if (mainWindow) {
+        mainWindow.setTitle(
+          `SimpleConnect - Agent: ${currentAgent.accessCode} (${result.firstName} ${result.lastName}) - Tel: ${credentials.terminal}`
+        );
+      }
+      
+      return {
+        success: true,
+        agent: currentAgent,
+        centres: centres
+      };
+    }
+    
+    return { success: false, message: 'Échec de l\'authentification' };
+    
+  } catch (error) {
+    console.error('Erreur lors de la connexion agent:', error);
+    return { 
+      success: false, 
+      message: error.message || 'Erreur de connexion au serveur' 
     };
   }
-  
-  return { success: false, message: 'Email ou mot de passe incorrect' };
 });
 
-// Déconnexion
-ipcMain.handle('logout', () => {
+// Traiter les URLs des applications avec les placeholders
+function processApplicationUrls(connList) {
+  if (!connList || connList.length === 0) return [];
+  
+  return connList.map((conn, index) => {
+    let url = conn.applicationName;
+    
+    // Remplacer les placeholders
+    if (url.includes('#CA#')) {
+      url = url.replace('#CA#', conn.accessCode || '');
+    }
+    if (url.includes('#MP#')) {
+      url = url.replace('#MP#', conn.password || '');
+    }
+    
+    // Gérer les cas spécifiques des plateformes connues
+    if (url === 'pro.mondocteur.fr' || url.includes('mondocteur.fr')) {
+      if (!url.startsWith('http')) {
+        url = 'https://pro.mondocteur.fr/backoffice.do';
+      }
+    } else if (url === 'pro.doctolib.fr' || url.includes('doctolib.fr')) {
+      if (!url.startsWith('http')) {
+        url = 'https://pro.doctolib.fr/signin';
+      }
+    } else if (!url.startsWith('http')) {
+      // Ajouter https:// par défaut si pas de protocole
+      url = `https://${url}`;
+    }
+    
+    // Créer l'objet centre compatible avec l'interface
+    return {
+      id: conn.code || `centre${index + 1}`,
+      nom: conn.queueName || conn.code || `Centre ${index + 1}`,
+      url: url,
+      couleur: getColorForIndex(index),
+      credentials: {
+        username: conn.accessCode,
+        password: conn.password
+      },
+      queueName: conn.queueName // Garder pour le mapping avec les événements IPBX
+    };
+  });
+}
+
+// Fonction helper pour attribuer des couleurs aux centres
+function getColorForIndex(index) {
+  const colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#DDA0DD', '#FFD93D', '#6BCB77'];
+  return colors[index % colors.length];
+}
+
+// Déconnexion agent via SignalR
+ipcMain.handle('logout', async () => {
+  if (currentAgent && signalRConnection && signalRStatus === 'connected') {
+    try {
+      // Appeler SignalR pour la déconnexion
+      await signalRConnection.invoke('AgentLogoff', currentAgent.accessCode);
+      console.log('Agent déconnecté du serveur SignalR');
+    } catch (error) {
+      console.error('Erreur lors de la déconnexion SignalR:', error);
+    }
+  }
+  
+  // Réinitialiser les variables locales
   currentAgent = null;
+  currentTerminal = null;
+  agentConnectionInfo = null;
+  
+  // Réinitialiser le titre de la fenêtre
+  if (mainWindow) {
+    mainWindow.setTitle('SimpleConnect - Gestion Centralisée des Plannings');
+  }
+  
   return { success: true };
 });
 
 // Obtenir l'agent actuel
 ipcMain.handle('get-current-agent', () => {
-  if (!currentAgent) return null;
+  if (!currentAgent || !agentConnectionInfo) return null;
   
-  const centresAssignes = config.centres.filter(c => 
-    currentAgent.centresAssignes.includes(c.id)
-  );
+  // Retourner les centres traités depuis SignalR
+  const centres = processApplicationUrls(agentConnectionInfo.connList);
   
   return {
     agent: currentAgent,
-    centres: centresAssignes
+    centres: centres,
+    terminal: currentTerminal
   };
 });