ajout du control denvoi de message et interface up

static/js/app.js

@@ -63,7 +63,10 @@ async function loadInitialData() {
             loadUsers(),
             loadStatus(),
             loadSubtitles(),
-            loadGenerations()
+            loadGenerations(),
+            checkAutoSubtitleStatus(), // Ajouter la vérification du statut auto
+            checkAutoMessageStatus(), // Ajouter la vérification du statut auto messages
+            checkChatMessageStatus() // Ajouter la vérification du statut chat messages
         ]);
     } catch (error) {
         console.error('Erreur lors du chargement des données:', error);
@@ -558,6 +561,40 @@ async function generateFromSubtitle() {
     }
 }
 
+function processSubtitles() {
+    // Afficher un indicateur de chargement
+    const button = event.target;
+    const originalText = button.innerHTML;
+    button.innerHTML = '<i class="fas fa-spinner fa-spin me-2"></i>Traitement en cours...';
+    button.disabled = true;
+    
+    fetch('/api/subtitles/process', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            showAlert(data.message, 'success');
+            // Actualiser les sous-titres
+            loadSubtitles();
+        } else {
+            showAlert('Erreur: ' + data.error, 'danger');
+        }
+    })
+    .catch(error => {
+        console.error('Erreur:', error);
+        showAlert('Erreur lors du traitement des sous-titres', 'danger');
+    })
+    .finally(() => {
+        // Restaurer le bouton
+        button.innerHTML = originalText;
+        button.disabled = false;
+    });
+}
+
 // === GESTION DES GÉNÉRATIONS ===
 
 // Chargement des générations
@@ -685,6 +722,28 @@ function showToast(message, type = 'info') {
     });
 }
 
+// === FONCTIONS UTILITAIRES ===
+
+function showAlert(message, type = 'info') {
+    const alertDiv = document.createElement('div');
+    alertDiv.className = `alert alert-${type} alert-dismissible fade show`;
+    alertDiv.innerHTML = `
+        ${message}
+        <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
+    `;
+    
+    // Ajouter l'alerte en haut de la page
+    const container = document.querySelector('.container-fluid');
+    container.insertBefore(alertDiv, container.firstChild);
+    
+    // Supprimer automatiquement après 5 secondes
+    setTimeout(() => {
+        if (alertDiv.parentNode) {
+            alertDiv.remove();
+        }
+    }, 5000);
+}
+
 // Gestion des erreurs globales
 window.addEventListener('error', function(e) {
     console.error('Erreur JavaScript:', e.error);
@@ -1201,4 +1260,381 @@ async function deleteUser(userId) {
         console.error('Erreur:', error);
         showToast('Erreur lors de la suppression', 'error');
     }
+} 
+
+// Variables globales pour la génération automatique
+let autoSubtitleRunning = false;
+
+// Variables globales pour l'envoi automatique de messages
+let autoMessageRunning = false;
+
+// Écouteurs Socket.IO pour la génération automatique
+socket.on('subtitle_processing_start', function(data) {
+    console.log('Début de traitement:', data.file);
+    showProcessingFile(data.file);
+});
+
+socket.on('subtitle_processing_complete', function(data) {
+    console.log('Traitement terminé:', data.file);
+    hideProcessingFile();
+    showAlert(`Sous-titre créé pour ${data.file}: ${data.subtitle}`, 'success');
+    loadSubtitles(); // Actualiser les sous-titres
+});
+
+socket.on('subtitle_processing_error', function(data) {
+    console.log('Erreur de traitement:', data.file, data.error);
+    hideProcessingFile();
+    showAlert(`Erreur pour ${data.file}: ${data.error}`, 'danger');
+});
+
+// Écouteurs Socket.IO pour l'envoi automatique de messages
+socket.on('message_sending_start', function(data) {
+    console.log('Début d\'envoi de message:', data.message);
+    showAlert(`Envoi en cours: ${data.message}`, 'info');
+});
+
+socket.on('message_sending_complete', function(data) {
+    console.log('Message envoyé:', data.message);
+    showAlert(`Message envoyé: ${data.message}`, 'success');
+    loadGenerations(); // Actualiser les générations
+});
+
+socket.on('message_sending_error', function(data) {
+    console.log('Erreur d\'envoi:', data.message, data.error);
+    showAlert(`Erreur d'envoi: ${data.error}`, 'danger');
+});
+
+// Fonction pour activer/désactiver l'envoi automatique de messages
+async function toggleAutoMessage() {
+    const toggle = document.getElementById('autoMessageToggle');
+    const statusElement = document.getElementById('autoMessageStatus');
+    
+    if (toggle.checked) {
+        // Démarrer l'envoi automatique de messages
+        try {
+            const response = await fetch('/api/messages/auto/start', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                autoMessageRunning = true;
+                statusElement.textContent = 'En cours...';
+                statusElement.className = 'text-success';
+                showAlert('Envoi automatique de messages démarré', 'success');
+            } else {
+                toggle.checked = false;
+                showAlert('Erreur: ' + result.error, 'danger');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = false;
+            showAlert('Erreur lors du démarrage', 'danger');
+        }
+    } else {
+        // Arrêter l'envoi automatique de messages
+        try {
+            const response = await fetch('/api/messages/auto/stop', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                autoMessageRunning = false;
+                statusElement.textContent = 'Arrêté';
+                statusElement.className = 'text-muted';
+                showAlert('Envoi automatique de messages arrêté', 'info');
+            } else {
+                toggle.checked = true;
+                showAlert('Erreur: ' + result.error, 'danger');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = true;
+            showAlert('Erreur lors de l\'arrêt', 'danger');
+        }
+    }
+}
+
+// Fonction pour vérifier le statut de l'envoi automatique de messages au chargement
+async function checkAutoMessageStatus() {
+    try {
+        const response = await fetch('/api/messages/auto/status');
+        const status = await response.json();
+        
+        const toggle = document.getElementById('autoMessageToggle');
+        const statusElement = document.getElementById('autoMessageStatus');
+        
+        if (toggle && statusElement) {
+            // Synchroniser l'état du toggle avec le serveur
+            toggle.checked = status.running;
+            autoMessageRunning = status.running;
+            
+            if (status.running) {
+                statusElement.textContent = 'En cours...';
+                statusElement.className = 'text-success';
+                console.log('Envoi automatique de messages actif');
+            } else {
+                statusElement.textContent = 'Arrêté';
+                statusElement.className = 'text-muted';
+                console.log('Envoi automatique de messages arrêté');
+            }
+        }
+    } catch (error) {
+        console.error('Erreur lors de la vérification du statut:', error);
+        // En cas d'erreur, forcer l'arrêt
+        const toggle = document.getElementById('autoMessageToggle');
+        const statusElement = document.getElementById('autoMessageStatus');
+        if (toggle && statusElement) {
+            toggle.checked = false;
+            statusElement.textContent = 'Arrêté';
+            statusElement.className = 'text-muted';
+            autoMessageRunning = false;
+        }
+    }
+}
+
+// Fonction pour activer/désactiver la génération automatique
+async function toggleAutoSubtitle() {
+    const toggle = document.getElementById('autoSubtitleToggle');
+    const statusElement = document.getElementById('autoSubtitleStatus');
+    
+    if (toggle.checked) {
+        // Démarrer la génération automatique
+        try {
+            const response = await fetch('/api/subtitles/auto/start', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                autoSubtitleRunning = true;
+                statusElement.textContent = 'En cours...';
+                statusElement.className = 'text-success';
+                showAlert('Génération automatique démarrée', 'success');
+            } else {
+                toggle.checked = false;
+                showAlert('Erreur: ' + result.error, 'danger');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = false;
+            showAlert('Erreur lors du démarrage', 'danger');
+        }
+    } else {
+        // Arrêter la génération automatique
+        try {
+            const response = await fetch('/api/subtitles/auto/stop', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                autoSubtitleRunning = false;
+                statusElement.textContent = 'Arrêté';
+                statusElement.className = 'text-muted';
+                hideProcessingFile();
+                showAlert('Génération automatique arrêtée', 'info');
+            } else {
+                toggle.checked = true;
+                showAlert('Erreur: ' + result.error, 'danger');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = true;
+            showAlert('Erreur lors de l\'arrêt', 'danger');
+        }
+    }
+}
+
+// Fonction pour afficher le fichier en cours de traitement
+function showProcessingFile(fileName) {
+    const processingElement = document.getElementById('processing-file');
+    const fileNameElement = document.getElementById('current-file-name');
+    
+    if (processingElement && fileNameElement) {
+        fileNameElement.textContent = `Traitement de: ${fileName}`;
+        processingElement.classList.remove('d-none');
+    }
+}
+
+// Fonction pour masquer le fichier en cours de traitement
+function hideProcessingFile() {
+    const processingElement = document.getElementById('processing-file');
+    
+    if (processingElement) {
+        processingElement.classList.add('d-none');
+    }
+}
+
+// Fonction pour vérifier le statut de la génération automatique au chargement
+async function checkAutoSubtitleStatus() {
+    try {
+        const response = await fetch('/api/subtitles/auto/status');
+        const status = await response.json();
+        
+        const toggle = document.getElementById('autoSubtitleToggle');
+        const statusElement = document.getElementById('autoSubtitleStatus');
+        
+        if (toggle && statusElement) {
+            toggle.checked = status.running;
+            autoSubtitleRunning = status.running;
+            
+            if (status.running) {
+                statusElement.textContent = 'En cours...';
+                statusElement.className = 'text-success';
+                
+                if (status.current_file) {
+                    showProcessingFile(status.current_file);
+                }
+            } else {
+                statusElement.textContent = 'Arrêté';
+                statusElement.className = 'text-muted';
+                hideProcessingFile();
+            }
+        }
+    } catch (error) {
+        console.error('Erreur lors de la vérification du statut:', error);
+    }
+} 
+
+// Fonction pour forcer l'arrêt de l'envoi automatique
+async function forceStopAutoMessage() {
+    try {
+        const response = await fetch('/api/messages/auto/force-stop', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        const result = await response.json();
+        
+        if (result.success) {
+            // Mettre à jour l'interface
+            const toggle = document.getElementById('autoMessageToggle');
+            const statusElement = document.getElementById('autoMessageStatus');
+            
+            if (toggle && statusElement) {
+                toggle.checked = false;
+                statusElement.textContent = 'Arrêté';
+                statusElement.className = 'text-muted';
+                autoMessageRunning = false;
+            }
+            
+            showAlert('Arrêt forcé de l\'envoi automatique de messages', 'warning');
+        } else {
+            showAlert('Erreur: ' + result.error, 'danger');
+        }
+    } catch (error) {
+        console.error('Erreur lors de l\'arrêt forcé:', error);
+        showAlert('Erreur lors de l\'arrêt forcé', 'danger');
+    }
+} 
+
+// Fonction pour activer/désactiver l'envoi de messages dans le chat
+async function toggleChatMessage() {
+    const toggle = document.getElementById('chatMessageToggle');
+    const statusElement = document.getElementById('chatMessageStatus');
+    
+    if (toggle.checked) {
+        // Activer l'envoi de messages
+        try {
+            const response = await fetch('/api/chat/messages/enable', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                statusElement.textContent = 'Activé';
+                statusElement.className = 'text-success';
+                showAlert('Envoi de messages dans le chat activé', 'success');
+            } else {
+                toggle.checked = false;
+                showAlert('Erreur: ' + result.error, 'danger');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = false;
+            showAlert('Erreur lors de l\'activation', 'danger');
+        }
+    } else {
+        // Désactiver l'envoi de messages
+        try {
+            const response = await fetch('/api/chat/messages/disable', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                statusElement.textContent = 'Désactivé';
+                statusElement.className = 'text-muted';
+                showAlert('Envoi de messages dans le chat désactivé', 'info');
+            } else {
+                toggle.checked = true;
+                showAlert('Erreur: ' + result.error, 'danger');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = true;
+            showAlert('Erreur lors de la désactivation', 'danger');
+        }
+    }
+}
+
+// Fonction pour vérifier le statut de l'envoi de messages chat au chargement
+async function checkChatMessageStatus() {
+    try {
+        const response = await fetch('/api/chat/messages/status');
+        const status = await response.json();
+        
+        const toggle = document.getElementById('chatMessageToggle');
+        const statusElement = document.getElementById('chatMessageStatus');
+        
+        if (toggle && statusElement) {
+            toggle.checked = status.enabled;
+            
+            if (status.enabled) {
+                statusElement.textContent = 'Activé';
+                statusElement.className = 'text-success';
+            } else {
+                statusElement.textContent = 'Désactivé';
+                statusElement.className = 'text-muted';
+            }
+        }
+    } catch (error) {
+        console.error('Erreur lors de la vérification du statut chat:', error);
+        // En cas d'erreur, forcer l'activation par défaut
+        const toggle = document.getElementById('chatMessageToggle');
+        const statusElement = document.getElementById('chatMessageStatus');
+        if (toggle && statusElement) {
+            toggle.checked = true;
+            statusElement.textContent = 'Activé';
+            statusElement.className = 'text-success';
+        }
+    }
 }