data-primals-engine 1.0.10 → 1.1.0

package/client/src/AssistantChat.jsx

@@ -0,0 +1,280 @@
+// client/src/components/AssistantChat.jsx
+
+import React, { useState, useMemo, useEffect, useRef } from 'react';
+import { FaRobot, FaPaperPlane, FaTimes, FaExpand, FaCompress } from 'react-icons/fa';
+import './AssistantChat.scss';
+import { useModelContext } from "./contexts/ModelContext.jsx";
+import { Trans, useTranslation } from "react-i18next";
+import Markdown from 'react-markdown';
+import {useQueryClient} from "react-query";
+
+const AssistantChat = ({ config }) => {
+    const { selectedModel } = useModelContext();
+    const { t } = useTranslation();
+    const [isOpen, setIsOpen] = useState(false);
+    const [isMaximized, setIsMaximized] = useState(false);
+    const [messages, setMessages] = useState([
+        { from: 'bot', text: t('assistant.welcome') }
+    ]);
+    const [input, setInput] = useState('');
+    const [isLoading, setIsLoading] = useState(false);
+
+    // NOUVEL ÉTAT : Stocke une action en attente de confirmation de l'utilisateur
+    const [pendingConfirmation, setPendingConfirmation] = useState(null);
+
+    // NOUVEAU : Référence pour le défilement automatique
+    const messagesEndRef = useRef(null);
+
+    // Fonction pour défiler vers le bas
+    const scrollToBottom = () => {
+        messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+    };
+
+    const queryClient = useQueryClient();
+
+    // Défiler vers le bas à chaque nouveau message ou changement de statut de chargement
+    useEffect(scrollToBottom, [messages, isLoading]);
+
+    // Fonction centralisée pour appeler l'API de l'assistant
+    const handleApiCall = async (payload) => {
+        setIsLoading(true);
+        // On efface toute confirmation en attente dès qu'une nouvelle action est lancée
+        setPendingConfirmation(null);
+        const isConfirmation = !!payload.confirmedAction;
+        if (!isConfirmation) {
+            setPendingConfirmation(null);
+        }
+        try {
+            const response = await fetch('/api/assistant/chat', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+
+            if (!response.ok) {
+                throw new Error(`Erreur HTTP: ${response.status}`);
+            }
+
+            const result = await response.json();
+
+            if (result.success) {
+                if (isConfirmation) {
+                    const modelToInvalidate = payload.confirmedAction.params.model;
+                    if (modelToInvalidate) {
+                        console.log(`[Assistant] Action on model '${modelToInvalidate}' succeeded. Invalidating cache.`);
+                        // Invalide toutes les requêtes qui commencent par ce tableau.
+                        // C'est la mode la plus simple et la plus sûre pour s'assurer
+                        // que toutes les vues de ces données (paginées ou non) sont rafraîchies.
+                        queryClient.invalidateQueries(['api/data', modelToInvalidate]);
+                    }
+                }
+
+                // On crée un objet de message pour le bot qui peut contenir plus que du texte
+                const botMessage = {
+                    from: 'bot',
+                    text: null,
+                    actionDetails: null // Pour stocker les détails de l'action à afficher
+                };
+
+                // Gérer le texte à afficher
+                if (result.displayMessage) {
+                    botMessage.text = result.displayMessage;
+                } else if (result.codeMessage) {
+                    const code = typeof result.codeMessage === 'object'
+                        ? JSON.stringify(result.codeMessage, null, 2)
+                        : result.codeMessage;
+                    botMessage.text = `\`\`\`json\n${code}\n\`\`\``;
+                }
+
+                // NOUVEAU : Si une confirmation est demandée, on enrichit le message
+                if (result.confirmationRequest) {
+                    // On stocke l'action complète dans l'état pour l'envoyer si l'utilisateur confirme
+                    setPendingConfirmation(result.confirmationRequest);
+
+                    // On ajoute les détails (modèle, filtre, données) au message pour l'affichage
+                    botMessage.actionDetails = {
+                        model: result.model,
+                        filter: result.filter,
+                        data: result.data // Sera undefined si non présent, ce qui est correct
+                    };
+                } else if (isConfirmation) {
+                    // Si c'était un appel de confirmation et qu'il n'y a pas de nouvelle demande, on vide l'état
+                    setPendingConfirmation(null);
+                }
+
+                // On ajoute le message à la liste uniquement s'il a du contenu textuel
+                if (botMessage.text) {
+                    setMessages(prev => [...prev, botMessage]);
+                }
+
+            } else {
+                const errorMessage = { from: 'bot', text: t('assistant.error', `Désolé, une erreur est survenue : {{message}}`, { message: result.message }) };
+                setMessages(prev => [...prev, errorMessage]);
+            }
+
+        } catch (error) {
+            const errorMessage = { from: 'bot', text: t('assistant.contactError', `Désolé, impossible de contacter l'assistant. ({{message}})`, { message: error.message }) };
+            setMessages(prev => [...prev, errorMessage]);
+        } finally {
+            setIsLoading(false);
+        }
+    };
+
+    // Gère la soumission du formulaire de chat
+    const handleSubmit = async (e) => {
+        e.preventDefault();
+        // On ne soumet rien si le champ est vide, si une requête est en cours ou si une confirmation est attendue
+        if (!input.trim() || isLoading || pendingConfirmation) return;
+
+        const userMessage = { from: 'user', text: input };
+        const currentInput = input;
+
+        setMessages(prev => [...prev, userMessage]);
+        setInput('');
+
+        gtag('event', "Assistant Prior - msg");
+
+        await handleApiCall({
+            message: currentInput,
+            history: messages,
+            provider: selectedProvider,
+            context: { modelName: selectedModel?.name }
+        });
+    };
+
+    // NOUVELLE FONCTION : Gère la réponse de l'utilisateur à une demande de confirmation
+    const handleConfirmAction = async (isConfirmed) => {
+        if (!pendingConfirmation) return;
+
+        if (isConfirmed) {
+            // L'utilisateur a cliqué sur "Oui"
+            const confirmationMessage = { from: 'user', text: t('yes', 'Oui') };
+            setMessages(prev => [...prev, confirmationMessage]);
+
+            // On rappelle l'API en envoyant l'action à confirmer
+            await handleApiCall({
+                message: "Action confirmée par l'utilisateur.",
+                history: messages,
+                provider: selectedProvider,
+                context: { modelName: selectedModel?.name },
+                confirmedAction: pendingConfirmation
+            });
+        } else {
+            // L'utilisateur a cliqué sur "Non"
+            const cancelMessage = { from: 'user', text: t('no', 'Non') };
+            const botResponseMessage = { from: 'bot', text: t('assistant.actionCancelled', "Action annulée.") };
+            setMessages(prev => [...prev, cancelMessage, botResponseMessage]);
+            setPendingConfirmation(null); // On annule la demande de confirmation
+        }
+    };
+
+    // Logique pour le sélecteur de fournisseur (OpenAI/Google)
+    const availableProviders = useMemo(() => {
+        const providers = [];
+        if (config?.openai) providers.push({ value: 'openai', label: 'OpenAI' });
+        if (config?.google) providers.push({ value: 'google', label: 'Google' });
+        return providers;
+    }, [config]);
+
+    const [selectedProvider, setSelectedProvider] = useState(null);
+
+    useEffect(() => {
+        if (availableProviders.length > 0 && !selectedProvider) {
+            setSelectedProvider(availableProviders[0].value);
+        }
+    }, [availableProviders, selectedProvider]);
+
+    // Si le chat est fermé, on affiche juste le bouton flottant
+    if (!isOpen) {
+        return (
+            <button className="assistant-fab" onClick={() => setIsOpen(true)} title={t('assistant.open', "Ouvrir l'assistant Prior")}>
+                <FaRobot />
+            </button>
+        );
+    }
+
+    // Si le chat est ouvert, on affiche la fenêtre complète
+    return (
+        <div className={`assistant-chat-window ${isMaximized ? 'maximized' : ''}`}>
+            <div className="chat-header">
+                <h3><FaRobot style={{ marginRight: '8px' }} /> <Trans i18nKey="assistant.named" values={{ named: 'Prior' }} /></h3>
+                <div className="header-actions">
+                    {availableProviders.length > 1 && (
+                        <select
+                            className="provider-selector"
+                            value={selectedProvider}
+                            onChange={(e) => setSelectedProvider(e.target.value)}
+                        >
+                            {availableProviders.map(provider => (
+                                <option key={provider.value} value={provider.value}>
+                                    {provider.label}
+                                </option>
+                            ))}
+                        </select>
+                    )}
+                    <button onClick={() => setIsMaximized(!isMaximized)} title={isMaximized ? t('collapse', "Réduire") : t('expand', "Agrandir")}>
+                        {isMaximized ? <FaCompress /> : <FaExpand />}
+                    </button>
+                    <button onClick={() => setIsOpen(false)} title={t('close', "Fermer")}>
+                        <FaTimes />
+                    </button>
+                </div>
+            </div>
+
+            <div className="chat-messages">
+                {messages.map((msg, index) => (
+                    <div key={index} className={`message ${msg.from}`}>
+                        <Markdown>{msg.text}</Markdown>
+                        {msg.actionDetails && (
+                            <div className="action-details">
+                                {msg.actionDetails.model && (
+                                    <p><strong>{t('model', 'Modèle')}:</strong> <code>{msg.actionDetails.model}</code></p>
+                                )}
+                                {msg.actionDetails.filter && (
+                                    <>
+                                        <p><strong>{t('filter', 'Filtre')}:</strong></p>
+                                        {/* Utiliser Markdown pour afficher un bloc de code JSON formaté */}
+                                        <Markdown>{`\`\`\`json\n${JSON.stringify(msg.actionDetails.filter, null, 2)}\n\`\`\``}</Markdown>
+                                    </>
+                                )}
+                                {msg.actionDetails.data && (
+                                    <>
+                                        <p><strong>{t('data', 'Données')}:</strong></p>
+                                        <Markdown>{`\`\`\`json\n${JSON.stringify(msg.actionDetails.data, null, 2)}\n\`\`\``}</Markdown>
+                                    </>
+                                )}
+                            </div>
+                        )}
+                    </div>
+                ))}
+                {isLoading && <div className="message bot"><p>...</p></div>}
+
+                {/* NOUVEAU : Affichage des boutons de confirmation */}
+                {pendingConfirmation && !isLoading && (
+                    <div className="message bot confirmation-prompt">
+                        <button onClick={() => handleConfirmAction(true)}>{t('yes', 'Oui')}</button>
+                        <button onClick={() => handleConfirmAction(false)} className="cancel">{t('no', 'Non')}</button>
+                    </div>
+                )}
+                <div ref={messagesEndRef} />
+            </div>
+
+            <form className="chat-input-form" onSubmit={handleSubmit}>
+                <input
+                    type="text"
+                    value={input}
+                    onChange={(e) => setInput(e.target.value)}
+                    placeholder={t('assistant.type', "Écrivez votre message...")}
+                    // On désactive l'input si une requête est en cours ou si une confirmation est attendue
+                    disabled={isLoading || !!pendingConfirmation}
+                    autoFocus
+                />
+                <button type="submit" disabled={isLoading || !input.trim() || !!pendingConfirmation} title={t('send', "Envoyer")}>
+                    <FaPaperPlane />
+                </button>
+            </form>
+        </div>
+    );
+};
+
+export default AssistantChat;

package/client/src/AssistantChat.scss

@@ -0,0 +1,229 @@
+// client/src/components/AssistantChat.scss
+
+// Variables pour une maintenance facile
+$primary-color: #007bff;
+$bot-message-bg: #f1f0f0;
+$user-message-bg: #e6f2ff;
+$chat-window-bg: #ffffff;
+$header-height: 50px;
+$input-height: 50px;
+
+// Le bouton flottant (quand le chat est fermé)
+.assistant-fab {
+  position: fixed;
+  bottom: 20px;
+  right: 20px;
+  width: 60px;
+  height: 60px;
+  background-color: $primary-color;
+  color: white;
+  border-radius: 50%;
+  border: none;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 24px;
+  cursor: pointer;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+  z-index: 1000;
+  transition: transform 0.2s ease-in-out;
+
+  &:hover {
+    transform: scale(1.1);
+  }
+}
+
+// La fenêtre de chat (quand elle est ouverte)
+.assistant-chat-window {
+  position: fixed;
+  bottom: 20px;
+  right: 20px;
+  width: 100%;
+  left: 2px;
+  max-width: 720px;
+  min-height: 400px;
+  height: 60vh;
+  max-height: calc(100vh - 40px);
+  background: $chat-window-bg;
+  border-radius: 12px;
+  box-shadow: 0 5px 20px rgba(0, 0, 0, 0.25);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  z-index: 1001;
+  transition: all 0.3s cubic-bezier(0.25, 0.8, 0.25, 1);
+
+  // Style pour la vue maximisée
+  &.maximized {
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    width: 100%;
+    height: 100%;
+    border-radius: 0;
+    max-height: 100vh;
+    z-index: 10000000;
+  }
+}
+
+// En-tête du chat
+.chat-header {
+  height: $header-height;
+  background-color: #f7f7f7;
+  border-bottom: 1px solid #e0e0e0;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 15px;
+  flex-shrink: 0;
+
+  h3 {
+    font-size: 16px;
+    font-weight: 600;
+    display: flex;
+    align-items: center;
+  }
+
+  .header-actions {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+
+    // NOUVEAU : Style pour le sélecteur
+    .provider-selector {
+      background-color: #e9ecef;
+      border: 1px solid #ced4da;
+      border-radius: 4px;
+      padding: 2px 6px;
+      font-size: 12px;
+      margin-right: 5px;
+      cursor: pointer;
+    }
+
+    button {
+      background: none;
+      border: none;
+      cursor: pointer;
+      font-size: 16px;
+      color: #666;
+      padding: 5px;
+      border-radius: 50%;
+      &:hover {
+        background-color: #e0e0e0;
+      }
+    }
+  }
+}
+
+// Zone des messages
+.chat-messages {
+  flex-grow: 1;
+  padding: 15px;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+
+  .message {
+    max-width: 80%;
+    p {
+      padding: 4px 8px;
+      border-radius: 18px;
+      margin: 0;
+      line-height: 1.5;
+      word-wrap: break-word;
+    }
+
+    .action-details {
+      border-left: 3px solid #4a90e2; // Une bordure pour délimiter
+      padding: 10px;
+      margin-top: 12px;
+      background-color: rgba(0, 0, 0, 0.03); // Un fond léger
+      border-radius: 0 8px 8px 0;
+      font-size: 0.9em;
+
+      p {
+        margin: 0 0 5px 0;
+      }
+
+      // Style pour le nom du modèle
+      code {
+        background-color: rgba(0, 0, 0, 0.08);
+        padding: 2px 5px;
+        border-radius: 4px;
+      }
+
+      // Style pour les blocs de code JSON (filtre et données)
+      pre {
+        white-space: pre-wrap;
+        word-wrap: break-word;
+        background-color: #f5f5f5 !important; // Assurez-vous que le fond est visible
+        padding: 10px;
+        border-radius: 4px;
+      }
+    }
+    &.bot {
+      align-self: flex-start;
+      p {
+        background-color: $bot-message-bg;
+        border-bottom-left-radius: 4px;
+      }
+    }
+
+    &.user {
+      align-self: flex-end;
+      p {
+        background-color: $user-message-bg;
+        color: #333;
+        border-bottom-right-radius: 4px;
+      }
+    }
+  }
+}
+
+// Formulaire de saisie
+.chat-input-form {
+  height: $input-height;
+  display: flex;
+  border-top: 1px solid #e0e0e0;
+  padding: 5px;
+  flex-shrink: 0;
+
+  input {
+    flex-grow: 1;
+    border: none;
+    padding: 0 10px;
+    font-size: 14px;
+    &:focus {
+      outline: none;
+    }
+  }
+
+  button {
+    background-color: $primary-color;
+    color: white;
+    border: none;
+    border-radius: 8px;
+    width: 40px;
+    height: 40px;
+    cursor: pointer;
+    font-size: 16px;
+    transition: background-color 0.2s;
+
+    &:hover {
+      background-color: darken($primary-color, 10%);
+    }
+    &:disabled {
+      background-color: #a0cfff;
+      cursor: not-allowed;
+    }
+  }
+}
+
+
+.message{
+  pre {
+    white-space: break-spaces;
+  }
+}

package/client/src/Button.jsx

@@ -0,0 +1,12 @@
+import "./Button.scss";
+
+function Button({ children, disabled, className, ...rest }) {
+  const cn = `${className || ""} btn${disabled ? " btn-disabled" : ""}`;
+  return (
+    <button disabled={disabled} {...rest} className={cn}>
+      {children}
+    </button>
+  );
+}
+
+export default Button;