pierre/SimpleClient-releases
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 7 Wiki Activity

feat: migration Socket.IO natif — login, terminaux REST, health check (closes #3)

Browse Source 
Remplace toute la couche SignalR par une connexion Socket.IO directe
au serveur Python (port 8004). Auth au handshake, reconnexion native
illimitée, terminaux via REST GET /terminals.

- socketio-adapter.js : connect/logoff/disconnect, events login_ok/login_error
- main.js : initializeSocketIO, health check net.request, terminaux REST
- renderer.js : IPC signalr-status → server-status
- config.json : clé socketio (plus signalR)
- Version 2.0.0
This commit is contained in:
Pierre Marx
2026-03-18 17:31:30 -04:00
parent 630f1fa8c3
commit 77a310976b
5 changed files with 414 additions and 447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
config.json
View File

@@ -1,8 +1,6 @@
{
"signalR": {
"enabled": true,
"serverUrl": "http://10.90.20.201:8002/signalR",
"serviceProvider": "RDVPREM",
"terminalsSimulation": ["3001", "3002", "3003", "3004", "3005"]
"socketio": {
"serverUrl": "http://10.90.20.201:8004",
"serviceProvider": "RDVPREM"
}
}
}

650
main.js
View File

@@ -1,51 +1,46 @@
const { app, BrowserWindow, ipcMain, session } = require('electron');
const { app, BrowserWindow, ipcMain, session, net } = require('electron');
const path = require('path');
const fs = require('fs');
const os = require('os');
const signalR = require('@microsoft/signalr');
const ConnectionManager = require('./connection-manager');
const SocketIOAdapter = require('./socketio-adapter');
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
let currentTerminal = null;
let adapter = null;
let serverStatus = 'disconnected'; // disconnected, connecting, connected, error
let agentConnectionInfo = null;
let healthCheckInterval = null;
// Configuration du système de logs SignalR
const SIGNALR_LOG_DIR = path.join(os.homedir(), '.simpleconnect-ng');
const SIGNALR_LOG_FILE = path.join(SIGNALR_LOG_DIR, 'signalr.log');
// Configuration du systeme de logs
const LOG_DIR = path.join(os.homedir(), '.simpleconnect-ng');
const LOG_FILE = path.join(LOG_DIR, 'socketio.log');
// Créer le répertoire de logs s'il n'existe pas
function ensureLogDirectory() {
if (!fs.existsSync(SIGNALR_LOG_DIR)) {
fs.mkdirSync(SIGNALR_LOG_DIR, { recursive: true });
console.log(`📁 Répertoire de logs créé: ${SIGNALR_LOG_DIR}`);
if (!fs.existsSync(LOG_DIR)) {
fs.mkdirSync(LOG_DIR, { recursive: true });
}
}
// Fonction pour écrire dans le fichier de log SignalR
function logToSignalRFile(message, data = null) {
function logToFile(message, data = null) {
ensureLogDirectory();
const timestamp = new Date().toISOString();
let logEntry = `[${timestamp}] ${message}`;
if (data) {
logEntry += '\n' + JSON.stringify(data, null, 2);
}
logEntry += '\n' + '─'.repeat(80) + '\n';
// Ajouter au fichier (append)
fs.appendFileSync(SIGNALR_LOG_FILE, logEntry, 'utf8');
logEntry += '\n' + '-'.repeat(80) + '\n';
fs.appendFileSync(LOG_FILE, logEntry, 'utf8');
}
// Logger dans la console ET dans le fichier
function logSignalR(message, data = null) {
function log(message, data = null) {
console.log(message, data || '');
logToSignalRFile(message, data);
logToFile(message, data);
}
// Charger la configuration
@@ -55,7 +50,7 @@ function loadConfig() {
config = JSON.parse(configData);
}
// Créer la fenêtre principale
// Creer la fenetre principale
function createWindow() {
mainWindow = new BrowserWindow({
width: 1400,
@@ -68,211 +63,92 @@ function createWindow() {
},
icon: path.join(__dirname, 'icon.png'),
title: `SimpleConnect v${app.getVersion()}`,
autoHideMenuBar: true // Cache la barre de menu par défaut
autoHideMenuBar: true
});
// Supprimer complètement le menu (pour Linux/Windows)
mainWindow.setMenuBarVisibility(false);
// Charger l'interface HTML
mainWindow.loadFile('index.html');
// Forcer le titre après le chargement de la page (le <title> HTML l'écrase sinon)
mainWindow.webContents.on('did-finish-load', () => {
mainWindow.setTitle(`SimpleConnect v${app.getVersion()}`);
});
// Ouvrir les DevTools uniquement en mode développement
if (process.env.NODE_ENV === 'development') {
mainWindow.webContents.openDevTools();
}
// Gérer la fermeture de la fenêtre
mainWindow.on('closed', () => {
mainWindow = null;
});
}
// === GESTION SIGNALR/WEBSOCKET ===
function initializeSignalR() {
if (!config.signalR || !config.signalR.enabled) {
console.log('SignalR/WebSocket désactivé dans la configuration');
signalRStatus = 'disabled';
sendSignalRStatus();
// === GESTION SOCKET.IO ===
function initializeSocketIO() {
if (!config.socketio || !config.socketio.serverUrl) {
console.log('Socket.IO non configure');
serverStatus = 'disabled';
sendServerStatus();
return;
}
try {
// Utiliser le ConnectionManager avec fallback automatique SignalR → WebSocket
const connectionManager = new ConnectionManager(config.ServerIp || config.signalR.serverUrl.replace('http://', '').replace('/signalR', ''));
// La connexion sera établie plus tard avec fallback automatique
signalRConnection = connectionManager;
adapter = new SocketIOAdapter(config.socketio.serverUrl);
// Les handlers d'état seront configurés après la connexion
// Démarrer la connexion (les handlers seront configurés après)
startSignalRConnection();
} catch (error) {
console.error('Erreur initialisation SignalR:', error);
signalRStatus = 'error';
sendSignalRStatus();
}
// Demarrer le health check polling
startHealthCheck();
}
function setupSignalRHandlers() {
// Configuration des handlers après la connexion
const connection = signalRConnection.getConnection();
if (!connection) {
console.error('Pas de connexion active pour configurer les handlers');
return;
}
// Health check periodique via GET /health
function startHealthCheck() {
const checkHealth = () => {
const serverUrl = config.socketio.serverUrl;
// === LOGGER UNIVERSEL POUR TOUS LES MESSAGES SIGNALR ===
// Intercepter TOUS les messages reçus du serveur pour découvrir les événements disponibles
// Initialiser le fichier de log avec une session
logSignalR('════════════════════════════════════════════════════════════');
logSignalR('🚀 NOUVELLE SESSION SIGNALR DÉMARRÉE');
logSignalR(`Application: SimpleConnect v${app.getVersion()}`);
logSignalR(`Serveur SignalR: ${config.signalR.serverUrl}`);
logSignalR(`Service Provider: ${config.signalR.serviceProvider}`);
logSignalR('════════════════════════════════════════════════════════════');
// Liste des événements connus pour les logger différemment
const knownEvents = ['IpbxEvent'];
// Créer un proxy pour intercepter tous les appels .on()
const originalOn = signalRConnection.on.bind(signalRConnection);
// Logger tous les événements possibles en essayant d'écouter les plus communs
const possibleEvents = [
'IpbxEvent', // Événements téléphoniques (confirmé)
'AgentStatusChanged', // Changement de statut agent
'QueueUpdate', // Mise à jour des files
'CallReceived', // Appel entrant
'CallEnded', // Fin d'appel
'MessageReceived', // Messages
'Notification', // Notifications générales
'StatusUpdate', // Mises à jour de statut
'SystemMessage', // Messages système
'BroadcastMessage', // Messages broadcast
'AgentUpdate', // Mises à jour agent
'QueueStatistics', // Statistiques de file
'PresenceUpdate' // Mise à jour de présence
];
// Écouter tous les événements possibles et logger ce qu'on reçoit
possibleEvents.forEach(eventName => {
connection.on(eventName, (...args) => {
// Logger dans la console avec formatage
console.log('═══════════════════════════════════════════════════════════');
console.log(`📨 MESSAGE SIGNALR REÇU: ${eventName}`);
console.log('Timestamp:', new Date().toISOString());
console.log('Nombre d\'arguments:', args.length);
// Logger chaque argument en détail
args.forEach((arg, index) => {
console.log(`Argument ${index}:`, JSON.stringify(arg, null, 2));
});
console.log('═══════════════════════════════════════════════════════════');
// Logger dans le fichier avec structure
const logData = {
event: eventName,
timestamp: new Date().toISOString(),
argumentCount: args.length,
arguments: args.map((arg, index) => ({
index: index,
type: typeof arg,
value: arg
})),
agent: currentAgent ? {
id: currentAgent.id,
name: currentAgent.name,
terminal: currentTerminal
} : null
};
logSignalR(`📨 MESSAGE SIGNALR REÇU: ${eventName}`, logData);
// Si c'est IpbxEvent, traiter comme avant
if (eventName === 'IpbxEvent') {
handleIpbxEventOriginal(args);
const request = net.request(`${serverUrl}/health`);
request.on('response', (response) => {
if (response.statusCode === 200) {
if (serverStatus !== 'connected') {
// Ne passer en 'connected' que si on n'a pas d'agent connecte
// (sinon le status est deja 'connected' via le login)
if (!currentAgent) {
serverStatus = 'connected';
sendServerStatus();
}
}
} else {
serverStatus = 'error';
sendServerStatus();
}
});
});
// Fonction originale pour traiter les IpbxEvent
function handleIpbxEventOriginal(args) {
if (!args || !agentConnectionInfo) return;
const [name, eventArgs] = args;
const event = eventArgs?.[0] || args[0];
console.log('🔍 Traitement IpbxEvent:', {
eventCode: event.eventCode,
terminal: event.terminal,
queueName: event.queueName,
fullEvent: event // Logger l'objet complet pour voir tous les champs
request.on('error', () => {
serverStatus = 'error';
sendServerStatus();
});
// 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 0:
console.log('📞 Code 0: Appel entrant/sonnerie (non implémenté)');
break;
case 1: // Appel décroché
console.log('✅ Code 1: Appel décroché - Traitement...');
handleCallPickedUp(event);
break;
case 2: // Appel raccroché
console.log('📴 Code 2: Appel raccroché - Traitement...');
handleCallHungUp(event);
break;
case 3:
console.log('⏸️ Code 3: Mise en attente (non implémenté)');
break;
case 4:
console.log('↔️ Code 4: Transfert d\'appel (non implémenté)');
break;
case 5:
console.log('👥 Code 5: Conférence (non implémenté)');
break;
default:
console.log('❓ Code événement inconnu:', event.eventCode);
console.log('Données complètes:', JSON.stringify(event, null, 2));
}
}
// Logger aussi les méthodes qu'on peut invoquer
console.log('📋 MÉTHODES SIGNALR DISPONIBLES POUR INVOCATION:');
console.log('- AgentLogin(email, password, terminal)');
console.log('- AgentLogoff(accessCode)');
console.log('- GetTerminalListByServiceProvider(serviceProvider)');
console.log('ℹ️ D\'autres méthodes peuvent être disponibles sur le serveur');
request.end();
};
// Check immediat puis toutes les 10s
checkHealth();
healthCheckInterval = setInterval(checkHealth, 10000);
}
// Gérer un appel entrant
function sendServerStatus() {
if (mainWindow && !mainWindow.isDestroyed()) {
mainWindow.webContents.send('server-status', serverStatus);
}
}
// Gerer 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,
@@ -281,17 +157,15 @@ function handleCallPickedUp(event) {
eventType: 'call_pickup'
});
} else {
console.warn('Aucun centre trouvé pour la file:', event.queueName);
console.warn('Aucun centre trouve pour la file:', event.queueName);
}
}
// Gérer la fin d'un appel
// Gerer 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,
@@ -299,68 +173,45 @@ function handleCallHungUp(event) {
});
}
async function startSignalRConnection() {
try {
signalRStatus = 'connecting';
sendSignalRStatus();
logSignalR('🔌 Tentative de connexion au serveur...', {
serverUrl: config.ServerIp || config.signalR.serverUrl,
status: 'connecting'
});
// Le ConnectionManager gère le fallback automatiquement
const connection = await signalRConnection.connect();
// Déterminer quel type de connexion a réussi
const connectionInfo = signalRConnection.getConnectionInfo();
console.log(`Connexion établie via ${connectionInfo.type}`);
logSignalR(`✅ Connexion établie avec succès (${connectionInfo.type})`, {
connectionType: connectionInfo.type,
isSignalR: connectionInfo.isSignalR,
isRestSocketIO: connectionInfo.isRestSocketIO,
status: 'connected',
serverUrl: connectionInfo.serverUrl
});
// Maintenant configurer les handlers sur la connexion active
setupSignalRHandlers();
signalRStatus = 'connected';
sendSignalRStatus();
} catch (error) {
console.error('Erreur connexion SignalR:', error);
logSignalR('❌ Erreur de connexion SignalR', {
error: error.message,
stack: error.stack,
serverUrl: config.signalR.serverUrl
});
signalRStatus = 'error';
sendSignalRStatus();
// Réessayer dans 5 secondes
setTimeout(() => {
if (signalRConnection && signalRStatus !== 'connected') {
startSignalRConnection();
}
}, 5000);
}
}
// Configurer les handlers d'evenements Socket.IO apres connexion
function setupEventHandlers() {
if (!adapter) return;
function sendSignalRStatus() {
if (mainWindow && !mainWindow.isDestroyed()) {
mainWindow.webContents.send('signalr-status', signalRStatus);
}
log('Session Socket.IO demarree', {
serverUrl: config.socketio.serverUrl,
serviceProvider: config.socketio.serviceProvider
});
// Ecouter les evenements d'appels IPBX
adapter.on('ipbx_event', (data) => {
log('ipbx_event recu', data);
if (!agentConnectionInfo) return;
// Verifier que l'evenement est pour notre terminal
if (data.terminal !== currentTerminal) {
console.log('Evenement ignore - terminal different:', data.terminal, '!==', currentTerminal);
return;
}
switch (data.eventCode) {
case 1:
handleCallPickedUp(data);
break;
case 2:
handleCallHungUp(data);
break;
default:
log('Code evenement non gere:', data);
}
});
}
// Initialisation de l'application
app.whenReady().then(() => {
// Supprimer le menu de l'application complètement (toutes plateformes)
const { Menu } = require('electron');
Menu.setApplicationMenu(null);
// Configuration de la session pour éviter les problèmes CORS
session.defaultSession.webRequest.onBeforeSendHeaders((details, callback) => {
details.requestHeaders['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
callback({ requestHeaders: details.requestHeaders });
@@ -377,33 +228,30 @@ app.whenReady().then(() => {
loadConfig();
createWindow();
// Initialiser SignalR après le chargement de la config
initializeSignalR();
initializeSocketIO();
});
// Quitter quand toutes les fenêtres sont fermées
// Quitter quand toutes les fenetres sont fermees
app.on('window-all-closed', async () => {
// Déconnexion propre avant de quitter
if (currentAgent && signalRConnection && signalRStatus === 'connected') {
if (healthCheckInterval) {
clearInterval(healthCheckInterval);
}
// Deconnexion propre avant de quitter
if (currentAgent && adapter) {
try {
await signalRConnection.invoke('AgentLogoff', currentAgent.accessCode);
console.log('Déconnexion agent avant fermeture');
await adapter.logoff();
console.log('Agent deconnecte avant fermeture');
} catch (error) {
console.error('Erreur déconnexion:', error);
console.error('Erreur deconnexion:', error);
}
}
// Ne pas appeler disconnect() pour éviter l'envoi du CloseMessage
// Le serveur .NET ne supporte pas ce message
// On laisse la connexion se fermer naturellement avec l'application
if (process.platform !== 'darwin') {
app.quit();
}
});
// Réactiver l'app sur macOS
app.on('activate', () => {
if (mainWindow === null) {
createWindow();
@@ -412,108 +260,107 @@ app.on('activate', () => {
// === IPC HANDLERS ===
// Obtenir la configuration
ipcMain.handle('get-config', () => {
return config;
});
// Obtenir la version de l'application
ipcMain.handle('get-app-version', () => {
return app.getVersion();
});
// Obtenir le statut SignalR
ipcMain.handle('get-signalr-status', () => {
return signalRStatus;
// Renomme : get-signalr-status -> get-server-status
ipcMain.handle('get-server-status', () => {
return serverStatus;
});
// Récupérer la liste des terminaux téléphoniques
// Recuperer la liste des terminaux via REST
ipcMain.handle('get-terminal-list', async () => {
// Mode simulation si SignalR non connecté
if (!signalRConnection || signalRStatus !== 'connected') {
console.log('SignalR non connecté, utilisation des terminaux de simulation');
return config.signalR.terminalsSimulation || ['3001', '3002', '3003'];
if (!config.socketio || !config.socketio.serverUrl) {
return [];
}
try {
console.log('Récupération des terminaux pour:', config.signalR.serviceProvider);
logSignalR('📡 Invocation SignalR: GetTerminalListByServiceProvider', {
method: 'GetTerminalListByServiceProvider',
serviceProvider: config.signalR.serviceProvider
const provider = config.socketio.serviceProvider;
const url = `${config.socketio.serverUrl}/terminals?provider=${encodeURIComponent(provider)}`;
console.log('Recuperation des terminaux:', url);
return new Promise((resolve, reject) => {
const request = net.request(url);
let body = '';
request.on('response', (response) => {
response.on('data', (chunk) => {
body += chunk.toString();
});
response.on('end', () => {
if (response.statusCode === 200) {
try {
const terminals = JSON.parse(body);
log('Terminaux recuperes', { count: terminals.length, terminals });
resolve(Array.isArray(terminals) ? terminals : []);
} catch (e) {
console.error('Erreur parsing terminaux:', e);
resolve([]);
}
} else {
console.error('Erreur terminaux HTTP', response.statusCode);
resolve([]);
}
});
});
request.on('error', (error) => {
console.error('Erreur recuperation terminaux:', error);
resolve([]);
});
request.end();
});
const terminals = await signalRConnection.invoke(
'GetTerminalListByServiceProvider',
config.signalR.serviceProvider
);
console.log('Terminaux disponibles:', terminals);
logSignalR('📞 Terminaux récupérés', {
count: terminals.length,
terminals: terminals
});
return terminals || [];
} catch (error) {
console.error('Erreur récupération terminaux:', error);
// Retourner les terminaux de simulation en cas d'erreur
return config.signalR.terminalsSimulation || ['3001', '3002', '3003'];
console.error('Erreur recuperation terminaux:', error);
return [];
}
});
// Connexion agent via SignalR
// Connexion agent via Socket.IO
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.'
if (!adapter) {
return {
success: false,
message: 'Socket.IO non initialise. Veuillez reessayer.'
};
}
try {
console.log('Tentative de connexion agent:', credentials.email, 'Terminal:', credentials.terminal);
logSignalR('🔐 Tentative de connexion agent', {
log('Tentative de connexion agent', {
email: credentials.email,
terminal: credentials.terminal,
forceDisconnect: credentials.forceDisconnect || false
});
// Si déconnexion forcée demandée, déconnecter d'abord la session précédente
if (credentials.forceDisconnect) {
console.log('Déconnexion forcée demandée pour:', credentials.email);
try {
// Tenter la déconnexion avec le code d'accès
await signalRConnection.invoke('AgentLogoff', credentials.email);
console.log('Session précédente déconnectée avec succès');
logSignalR('🔓 Session précédente déconnectée (forceDisconnect)', {
email: credentials.email
});
} catch (logoffError) {
console.warn('Erreur lors de la déconnexion forcée (session peut-être déjà fermée):', logoffError.message);
logSignalR('⚠️ Erreur déconnexion forcée', {
email: credentials.email,
error: logoffError.message
});
// Continuer même si la déconnexion échoue - la session est peut-être déjà fermée
}
// Deconnecter l'adapter precedent s'il y en a un
if (adapter.state === 'connected') {
adapter.disconnect();
}
// Appel SignalR pour l'authentification
logSignalR('📡 Invocation SignalR: AgentLogin', {
method: 'AgentLogin',
email: credentials.email,
terminal: credentials.terminal
});
const result = await signalRConnection.invoke('AgentLogin',
// Recreer l'adapter pour une connexion fraiche
adapter = new SocketIOAdapter(config.socketio.serverUrl);
// Configurer les handlers d'evenements AVANT connect
setupEventHandlers();
// Connexion avec auth au handshake
const result = await adapter.connect(
credentials.email,
credentials.password,
credentials.terminal
);
if (result) {
console.log('Connexion réussie:', result);
logSignalR('✅ Connexion agent réussie', {
console.log('Connexion reussie:', result);
log('Connexion agent reussie', {
accessCode: result.accessCode,
firstName: result.firstName,
lastName: result.lastName,
@@ -521,12 +368,10 @@ ipcMain.handle('login-agent', async (event, credentials) => {
connListCount: result.connList ? result.connList.length : 0,
connList: result.connList
});
// Stocker les informations de connexion
agentConnectionInfo = result;
currentTerminal = credentials.terminal;
// Créer l'objet agent pour compatibilité
currentAgent = {
id: result.accessCode,
accessCode: result.accessCode,
@@ -536,31 +381,32 @@ ipcMain.handle('login-agent', async (event, credentials) => {
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 v${app.getVersion()} - Agent: ${currentAgent.accessCode} (${result.firstName} ${result.lastName}) - Tel: ${credentials.terminal}`
);
}
serverStatus = 'connected';
sendServerStatus();
return {
success: true,
agent: currentAgent,
centres: centres
};
}
return { success: false, message: 'Échec de l\'authentification' };
return { success: false, message: 'Echec 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: error.message || 'Erreur de connexion au serveur'
};
}
});
@@ -568,10 +414,10 @@ ipcMain.handle('login-agent', async (event, credentials) => {
// 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 || '');
@@ -579,8 +425,8 @@ function processApplicationUrls(connList) {
if (url.includes('#MP#')) {
url = url.replace('#MP#', conn.password || '');
}
// Gérer les cas spécifiques des plateformes connues
// Gerer les cas specifiques des plateformes connues
if (url === 'pro.mondocteur.fr' || url.includes('mondocteur.fr')) {
if (!url.startsWith('http')) {
url = 'https://pro.mondocteur.fr/backoffice.do';
@@ -590,11 +436,9 @@ function processApplicationUrls(connList) {
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}`,
@@ -604,68 +448,54 @@ function processApplicationUrls(connList) {
username: conn.accessCode,
password: conn.password
},
queueName: conn.queueName // Garder pour le mapping avec les événements IPBX
queueName: conn.queueName
};
});
}
// 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
// Deconnexion agent via Socket.IO
ipcMain.handle('logout', async () => {
if (currentAgent && signalRConnection && signalRStatus === 'connected') {
if (currentAgent && adapter) {
try {
// Appeler SignalR pour la déconnexion
logSignalR('📡 Invocation SignalR: AgentLogoff', {
method: 'AgentLogoff',
log('Logoff agent', {
accessCode: currentAgent.accessCode
});
await signalRConnection.invoke('AgentLogoff', currentAgent.accessCode);
console.log('Agent déconnecté du serveur SignalR');
logSignalR('👋 Agent déconnecté avec succès', {
await adapter.logoff();
console.log('Agent deconnecte du serveur');
log('Agent deconnecte avec succes', {
accessCode: currentAgent.accessCode,
name: currentAgent.name
});
} catch (error) {
console.error('Erreur lors de la déconnexion SignalR:', error);
console.error('Erreur lors de la deconnexion:', 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 v${app.getVersion()}`);
}
return { success: true };
});
// Handler pour quitter l'application proprement
ipcMain.handle('quit-app', async () => {
// Ne pas appeler disconnect() pour éviter l'envoi du CloseMessage
// Le serveur .NET ne supporte pas ce message
// On laisse la connexion se fermer naturellement avec l'application
// (comme le fait le client de prod)
// Quitter l'application
app.quit();
});
// Obtenir l'agent actuel
ipcMain.handle('get-current-agent', () => {
if (!currentAgent || !agentConnectionInfo) return null;
// Retourner les centres traités depuis SignalR
const centres = processApplicationUrls(agentConnectionInfo.connList);
return {
agent: currentAgent,
centres: centres,
@@ -673,17 +503,15 @@ ipcMain.handle('get-current-agent', () => {
};
});
// Simuler un appel entrant
ipcMain.handle('simulate-call', (event, callData) => {
// Envoyer l'événement d'appel entrant à la fenêtre
mainWindow.webContents.send('incoming-call', callData);
return { success: true };
});
// Obtenir les données pour simuler des appels
ipcMain.handle('get-simulated-calls', () => {
if (!config.cti || !config.cti.appelSimules) return [];
return config.cti.appelSimules.map(appel => {
const centre = config.centres.find(c => c.id === appel.centreId);
const centre = config.centres ? config.centres.find(c => c.id === appel.centreId) : null;
return {
...appel,
centreNom: centre ? centre.nom : 'Centre inconnu'
@@ -691,18 +519,16 @@ ipcMain.handle('get-simulated-calls', () => {
});
});
// Sauvegarder les notes de l'agent (un seul fichier par agent)
// Sauvegarder les notes de l'agent
ipcMain.handle('save-notes', (event, noteData) => {
const notesDir = path.join(__dirname, 'notes');
if (!fs.existsSync(notesDir)) {
fs.mkdirSync(notesDir);
}
// Un seul fichier par agent, mis à jour à chaque sauvegarde
const fileName = `notes_${currentAgent.id}.json`;
const filePath = path.join(notesDir, fileName);
// Lire l'historique existant si le fichier existe
let notesData = {
agent: currentAgent.id,
agentName: currentAgent.name,
@@ -711,12 +537,10 @@ ipcMain.handle('save-notes', (event, noteData) => {
centre: noteData.centre,
history: []
};
// Si le fichier existe, préserver l'historique
if (fs.existsSync(filePath)) {
try {
const existingData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
// Ajouter l'ancienne note à l'historique si elle a changé
if (existingData.currentNote && existingData.currentNote !== noteData.content) {
notesData.history = existingData.history || [];
notesData.history.unshift({
@@ -724,27 +548,25 @@ ipcMain.handle('save-notes', (event, noteData) => {
date: existingData.lastModified,
centre: existingData.centre
});
// Limiter l'historique à 50 entrées
notesData.history = notesData.history.slice(0, 50);
}
} catch (error) {
console.error('Erreur lecture notes existantes:', error);
}
}
fs.writeFileSync(filePath, JSON.stringify(notesData, null, 2));
return { success: true, file: fileName };
});
// Récupérer les notes de l'agent
ipcMain.handle('get-notes', () => {
if (!currentAgent) return null;
const notesDir = path.join(__dirname, 'notes');
const fileName = `notes_${currentAgent.id}.json`;
const filePath = path.join(notesDir, fileName);
if (fs.existsSync(filePath)) {
try {
const data = fs.readFileSync(filePath, 'utf8');
@@ -754,11 +576,10 @@ ipcMain.handle('get-notes', () => {
return null;
}
}
return null;
});
// Obtenir l'historique des appels
ipcMain.handle('get-call-history', () => {
const historyFile = path.join(__dirname, 'call_history.json');
if (fs.existsSync(historyFile)) {
@@ -768,30 +589,27 @@ ipcMain.handle('get-call-history', () => {
return [];
});
// Sauvegarder un appel dans l'historique
ipcMain.handle('save-call-history', (event, callData) => {
const historyFile = path.join(__dirname, 'call_history.json');
let history = [];
if (fs.existsSync(historyFile)) {
const data = fs.readFileSync(historyFile, 'utf8');
history = JSON.parse(data);
}
history.unshift({
...callData,
agentId: currentAgent?.id,
timestamp: new Date().toISOString()
});
// Garder seulement les 100 derniers appels
history = history.slice(0, 100);
fs.writeFileSync(historyFile, JSON.stringify(history, null, 2));
return { success: true };
});
// Vérifier si on est en mode développement
ipcMain.handle('is-development', () => {
return process.env.NODE_ENV === 'development';
});
});

2
package.json
View File

@@ -1,6 +1,6 @@
{
"name": "simpleconnect-electron",
"version": "1.5.0",
"version": "2.0.0",
"description": "Application de gestion centralisée des plannings médicaux pour centres d'appels",
"main": "main.js",
"scripts": {

48
renderer.js
View File

@@ -29,18 +29,18 @@ document.addEventListener('DOMContentLoaded', async () => {
versionLoginElement.textContent = `v${appVersion}`;
}
// Initialiser l'indicateur SignalR
// Initialiser l'indicateur de statut serveur
// Écouter les changements de statut SignalR
ipcRenderer.on('signalr-status', (event, status) => {
updateSignalRIndicator(status);
// Recharger les terminaux à chaque changement de statut
// Ecouter les changements de statut serveur
ipcRenderer.on('server-status', (event, status) => {
updateServerIndicator(status);
// Recharger les terminaux a chaque changement de statut
loadTerminals();
});
// Obtenir le statut initial SignalR
const initialStatus = await ipcRenderer.invoke('get-signalr-status');
updateSignalRIndicator(initialStatus);
// Obtenir le statut initial
const initialStatus = await ipcRenderer.invoke('get-server-status');
updateServerIndicator(initialStatus);
// Charger immédiatement les terminaux pour la page de login
await loadTerminals();
@@ -129,7 +129,7 @@ document.addEventListener('DOMContentLoaded', async () => {
handleIncomingCall(callData);
});
// Écouter les événements SignalR de basculement de centre
// Ecouter les evenements de basculement de centre
ipcRenderer.on('switch-to-center', (event, data) => {
console.log('Basculement vers le centre:', data.centreName);
@@ -162,7 +162,7 @@ document.addEventListener('DOMContentLoaded', async () => {
});
});
// Connexion via SignalR
// Connexion agent
async function handleLogin(e) {
e.preventDefault();
@@ -221,7 +221,7 @@ async function handleLogin(e) {
await new Promise(resolve => setTimeout(resolve, 300));
try {
// Préparer les credentials pour SignalR
// Preparer les credentials
const credentials = {
email: accessCode, // Utiliser directement le code agent comme email
password: password,
@@ -229,7 +229,7 @@ async function handleLogin(e) {
forceDisconnect: forceDisconnect // Ajouter l'option de déconnexion forcée
};
// Appeler l'authentification SignalR
// Appeler l'authentification
const result = await ipcRenderer.invoke('login-agent', credentials);
if (result.success) {
@@ -835,7 +835,7 @@ async function loadTerminals() {
console.log('Chargement des terminaux...');
try {
// Récupérer les terminaux depuis le serveur SignalR
// Recuperer les terminaux depuis le serveur
const terminals = await ipcRenderer.invoke('get-terminal-list');
availableTerminals = terminals || [];
console.log(`${terminals.length} terminaux récupérés`);
@@ -1235,20 +1235,20 @@ function refreshCurrentWebview() {
}
}
// === GESTION INDICATEUR SIGNALR ===
function updateSignalRIndicator(status) {
// === GESTION INDICATEUR STATUT SERVEUR ===
function updateServerIndicator(status) {
const indicator = document.getElementById('signalrIndicator');
const text = document.getElementById('signalrText');
if (!indicator || !text) return;
// Réinitialiser les classes
// Reinitialiser les classes
indicator.className = 'signalr-indicator';
switch(status) {
case 'connected':
indicator.classList.add('connected');
text.textContent = 'Connecté au serveur';
text.textContent = 'Serveur connecte';
break;
case 'connecting':
indicator.classList.add('connecting');
@@ -1256,17 +1256,17 @@ function updateSignalRIndicator(status) {
break;
case 'disconnected':
indicator.classList.add('disconnected');
text.textContent = 'Serveur déconnecté';
text.textContent = 'Serveur deconnecte';
break;
case 'error':
indicator.classList.add('error');
text.textContent = 'Erreur de connexion';
text.textContent = 'Serveur injoignable';
break;
case 'disabled':
indicator.classList.add('disabled');
text.textContent = 'SignalR désactivé';
text.textContent = 'Non configure';
break;
default:
text.textContent = 'État inconnu';
text.textContent = 'Etat inconnu';
}
}

151
socketio-adapter.js Normal file
View File

@@ -0,0 +1,151 @@
/**
* Adaptateur Socket.IO natif pour le serveur Python SimpleServer
*
* Connexion directe au port 8004, auth au handshake,
* reconnexion native illimitee.
*/
const io = require('socket.io-client');
class SocketIOAdapter {
constructor(serverUrl) {
this.serverUrl = serverUrl;
this.socket = null;
this._state = 'disconnected'; // disconnected, connecting, connected, error
this._eventHandlers = new Map();
}
/**
* Connexion avec auth au handshake.
* Le serveur authentifie dans le handler connect et emet 'login_ok' avec le resultat.
* @returns {Promise<object>} connResult (accessCode, firstName, lastName, connList)
*/
connect(accessCode, password, terminal) {
return new Promise((resolve, reject) => {
this._state = 'connecting';
this.socket = io(this.serverUrl, {
auth: { access_code: accessCode, password, terminal },
transports: ['websocket'],
reconnection: true,
reconnectionAttempts: Infinity,
reconnectionDelay: 2000,
reconnectionDelayMax: 10000,
});
let settled = false;
// Le serveur emet 'login_ok' avec les donnees de session
this.socket.once('login_ok', (data) => {
if (settled) return;
settled = true;
this._state = 'connected';
resolve(data);
});
// Le serveur emet 'login_error' si auth echouee (avant return false)
this.socket.once('login_error', (data) => {
if (settled) return;
settled = true;
this._state = 'error';
this.socket.disconnect();
reject(new Error(data.message || 'Authentification refusee'));
});
// Erreur de connexion (serveur injoignable ou return false du handler connect)
this.socket.on('connect_error', (err) => {
if (!settled) {
settled = true;
this._state = 'error';
this.socket.disconnect();
reject(new Error(err.message || 'Connexion refusee'));
}
// Apres login reussi : reconnexion auto geree par socket.io
});
// Timeout de connexion initiale (15s)
setTimeout(() => {
if (!settled) {
settled = true;
this._state = 'error';
this.socket.disconnect();
reject(new Error('Timeout de connexion au serveur'));
}
}, 15000);
// Restaurer les handlers enregistres avant connect
this._eventHandlers.forEach((handler, event) => {
this.socket.on(event, handler);
});
});
}
/**
* Deconnexion volontaire avec logoff IPBX.
* Emet 'logout' et attend 'logout_ok' du serveur.
*/
logoff() {
return new Promise((resolve) => {
if (!this.socket || !this.socket.connected) {
this._state = 'disconnected';
resolve();
return;
}
this.socket.once('logout_ok', () => {
this._state = 'disconnected';
resolve();
});
this.socket.emit('logout');
// Timeout si le serveur ne repond pas
setTimeout(() => {
if (this.socket) {
this.socket.disconnect();
}
this._state = 'disconnected';
resolve();
}, 5000);
});
}
/**
* Deconnexion brute (sans logoff IPBX).
*/
disconnect() {
if (this.socket) {
this.socket.disconnect();
}
this._state = 'disconnected';
}
/**
* Ecouter un evenement serveur.
*/
on(event, handler) {
this._eventHandlers.set(event, handler);
if (this.socket) {
this.socket.on(event, handler);
}
}
/**
* Retirer un handler d'evenement.
*/
off(event) {
this._eventHandlers.delete(event);
if (this.socket) {
this.socket.off(event);
}
}
/**
* Etat de la connexion.
*/
get state() {
return this._state;
}
}
module.exports = SocketIOAdapter;