iatoolkit 0.8.1__py3-none-any.whl → 0.63.4__py3-none-any.whl

iatoolkit/services/user_feedback_service.py

@@ -3,65 +3,101 @@
 #
 # IAToolkit is open source software.
 
-from iatoolkit.repositories.models import UserFeedback
+from iatoolkit.repositories.models import UserFeedback, Company
 from injector import inject
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from iatoolkit.infra.google_chat_app import GoogleChatApp
+from iatoolkit.infra.mail_app import MailApp  # <-- 1. Importar MailApp
 import logging
 
 
 class UserFeedbackService:
     @inject
-    def __init__(self, profile_repo: ProfileRepo, google_chat_app: GoogleChatApp):
+    def __init__(self,
+                 profile_repo: ProfileRepo,
+                 google_chat_app: GoogleChatApp,
+                 mail_app: MailApp):
         self.profile_repo = profile_repo
         self.google_chat_app = google_chat_app
+        self.mail_app = mail_app
+
+    def _send_google_chat_notification(self, space_name: str, message_text: str):
+        """Envía una notificación de feedback a un espacio de Google Chat."""
+        try:
+            chat_data = {
+                "type": "MESSAGE_TRIGGER",
+                "space": {"name": space_name},
+                "message": {"text": message_text}
+            }
+            chat_result = self.google_chat_app.send_message(message_data=chat_data)
+            if not chat_result.get('success'):
+                logging.warning(f"Error al enviar notificación a Google Chat: {chat_result.get('message')}")
+        except Exception as e:
+            logging.exception(f"Fallo inesperado al enviar notificación a Google Chat: {e}")
+
+    def _send_email_notification(self, destination_email: str, company_name: str, message_text: str):
+        """Envía una notificación de feedback por correo electrónico."""
+        try:
+            subject = f"Nuevo Feedback de {company_name}"
+            # Convertir el texto plano a un HTML simple para mantener los saltos de línea
+            html_body = message_text.replace('\n', '<br>')
+            self.mail_app.send_email(to=destination_email, subject=subject, body=html_body)
+        except Exception as e:
+            logging.exception(f"Fallo inesperado al enviar email de feedback: {e}")
+
+    def _handle_notification(self, company: Company, message_text: str):
+        """Lee la configuración de la empresa y envía la notificación al canal correspondiente."""
+        feedback_params = company.parameters.get('user_feedback')
+        if not isinstance(feedback_params, dict):
+            logging.warning(f"No se encontró configuración de 'user_feedback' para la empresa {company.short_name}.")
+            return
+
+        # get channel and destination
+        channel = feedback_params.get('channel')
+        destination = feedback_params.get('destination')
+        if not channel or not destination:
+            logging.warning(f"Configuración 'user_feedback' incompleta para {company.short_name}. Faltan 'channel' o 'destination'.")
+            return
+
+        if channel == 'google_chat':
+            self._send_google_chat_notification(space_name=destination, message_text=message_text)
+        elif channel == 'email':
+            self._send_email_notification(destination_email=destination, company_name=company.short_name, message_text=message_text)
+        else:
+            logging.warning(f"Canal de feedback '{channel}' no reconocido para la empresa {company.short_name}.")
 
     def new_feedback(self,
                      company_short_name: str,
                      message: str,
-                     external_user_id: str = None,
-                     local_user_id: int = 0,
-                     space: str = None,
-                     type: str = None,
+                     user_identifier: str,
                      rating: int = None) -> dict:
         try:
-            # validate company
+            # 1. Validar empresa
             company = self.profile_repo.get_company_by_short_name(company_short_name)
             if not company:
                 return {'error': f'No existe la empresa: {company_short_name}'}
 
-            # send notification to Google Chat
-            chat_message = f"*Nuevo feedback de {company_short_name}*:\n*Usuario:* {external_user_id or local_user_id}\n*Mensaje:* {message}\n*Calificación:* {rating}"
-
-            # TO DO: get the space and type from the input data
-            chat_data = {
-                "type": type,
-                "space": {
-                    "name": space
-                },
-                "message": {
-                    "text": chat_message
-                }
-            }
-
-            chat_result = self.google_chat_app.send_message(message_data=chat_data)
-
-            if not chat_result.get('success'):
-                logging.warning(f"Error al enviar notificación a Google Chat: {chat_result.get('message')}")
+            # 2. Enviar notificación según la configuración de la empresa
+            notification_text = (f"*Nuevo feedback de {company_short_name}*:\n"
+                                 f"*Usuario:* {user_identifier}\n"
+                                 f"*Mensaje:* {message}\n"
+                                 f"*Calificación:* {rating if rating is not None else 'N/A'}")
+            self._handle_notification(company, notification_text)
 
-            # create the UserFeedback object
-            new_feedback = UserFeedback(
+            # 3. Guardar el feedback en la base de datos (independientemente del éxito de la notificación)
+            new_feedback_obj = UserFeedback(
                 company_id=company.id,
                 message=message,
-                local_user_id=local_user_id,
-                external_user_id=external_user_id,
+                user_identifier=user_identifier,
                 rating=rating
             )
-            new_feedback = self.profile_repo.save_feedback(new_feedback)
-            if not new_feedback:
+            saved_feedback = self.profile_repo.save_feedback(new_feedback_obj)
+            if not saved_feedback:
+                logging.error(f"No se pudo guardar el feedback para el usuario {user_identifier} en la empresa {company_short_name}")
                 return {'error': 'No se pudo guardar el feedback'}
 
             return {'message': 'Feedback guardado correctamente'}
 
         except Exception as e:
+            logging.exception(f"Error crítico en el servicio de feedback: {e}")
             return {'error': str(e)}

iatoolkit/services/user_session_context_service.py

@@ -6,80 +6,138 @@
 from iatoolkit.infra.redis_session_manager import RedisSessionManager
 from typing import List, Dict, Optional
 import json
+import logging
 
 
 class UserSessionContextService:
     """
-    Gestiona el contexto de la sesión del usuario, incluyendo el historial
-    de conversación con el LLM y datos de la sesión del usuario.
-
-    Usa RedisSessionManager para persistencia directa en Redis.
+    Gestiona el contexto de la sesión del usuario usando un único Hash de Redis por sesión.
+    Esto mejora la atomicidad y la eficiencia.
     """
 
-    def _get_llm_history_key(self, company_short_name: str, user_identifier: str) -> str:
-        user_identifier = (user_identifier or "").strip()
-        if not user_identifier:
-            return None
-        return f"llm_history:{company_short_name}/{user_identifier}"
-
-    def _get_user_data_key(self, company_short_name: str, user_identifier: str) -> str:
+    def _get_session_key(self, company_short_name: str, user_identifier: str) -> Optional[str]:
+        """Devuelve la clave única de Redis para el Hash de sesión del usuario."""
         user_identifier = (user_identifier or "").strip()
-        if not user_identifier:
+        if not company_short_name or not user_identifier:
             return None
-        return f"user_data:{company_short_name}/{user_identifier}"
+        return f"session:{company_short_name}/{user_identifier}"
 
     def clear_all_context(self, company_short_name: str, user_identifier: str):
-        """Limpia todo el contexto de sesión para un usuario."""
-        self.clear_llm_history(company_short_name, user_identifier)
-        self.clear_user_session_data(company_short_name, user_identifier)
+        """Limpia el contexto del LLM en la sesión para un usuario de forma atómica."""
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            # RedisSessionManager.remove(session_key)
+            # 'profile_data' should not be deleted
+            RedisSessionManager.hdel(session_key, 'context_version')
+            RedisSessionManager.hdel(session_key, 'context_history')
+            RedisSessionManager.hdel(session_key, 'last_response_id')
 
     def clear_llm_history(self, company_short_name: str, user_identifier: str):
-        history_key = self._get_llm_history_key(company_short_name, user_identifier)
-        if history_key:
-            RedisSessionManager.remove(history_key)
-
-    def get_last_response_id(self, company_short_name: str, user_identifier: str) -> str:
-        history_key = self._get_llm_history_key(company_short_name, user_identifier)
-        if not history_key:
+        """Limpia solo los campos relacionados con el historial del LLM (ID y chat)."""
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            RedisSessionManager.hdel(session_key, 'last_response_id', 'context_history')
+
+    def get_last_response_id(self, company_short_name: str, user_identifier: str) -> Optional[str]:
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
             return None
-
-        return RedisSessionManager.get(history_key, '')
+        return RedisSessionManager.hget(session_key, 'last_response_id')
 
     def save_last_response_id(self, company_short_name: str, user_identifier: str, response_id: str):
-        user_identifier = (user_identifier or "").strip()
-        history_key = self._get_llm_history_key(company_short_name, user_identifier)
-        if not history_key or not user_identifier:
-            return
-
-        RedisSessionManager.set(history_key, response_id)
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            RedisSessionManager.hset(session_key, 'last_response_id', response_id)
 
     def save_context_history(self, company_short_name: str, user_identifier: str, context_history: List[Dict]):
-        history_key = f"chat_history:{company_short_name}/{user_identifier}"
-        if not history_key:
-            return
-        RedisSessionManager.set(history_key, json.dumps(context_history))
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            try:
+                history_json = json.dumps(context_history)
+                RedisSessionManager.hset(session_key, 'context_history', history_json)
+            except (TypeError, ValueError) as e:
+                logging.error(f"Error al serializar context_history para {session_key}: {e}")
 
     def get_context_history(self, company_short_name: str, user_identifier: str) -> Optional[List[Dict]]:
-        history_key = f"chat_history:{company_short_name}/{user_identifier}"
-        return RedisSessionManager.get_json(history_key, {})
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
+            return None
 
-    def save_user_session_data(self, company_short_name: str, user_identifier: str, data: dict):
-        """Guarda un diccionario de datos en la sesión del usuario."""
-        user_identifier = (user_identifier or "").strip()
-        data_key = self._get_user_data_key(company_short_name, user_identifier)
-        if data_key:
-            RedisSessionManager.set_json(data_key, data)
-
-    def get_user_session_data(self, company_short_name: str, user_identifier: str) -> dict:
-        """Recupera el diccionario de datos de la sesión del usuario."""
-        data_key = self._get_user_data_key(company_short_name, user_identifier)
-        if not data_key:
+        history_json = RedisSessionManager.hget(session_key, 'context_history')
+        if not history_json:
+            return []
+
+        try:
+            return json.loads(history_json)
+        except json.JSONDecodeError:
+            return []
+
+    def save_profile_data(self, company_short_name: str, user_identifier: str, data: dict):
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            try:
+                data_json = json.dumps(data)
+                RedisSessionManager.hset(session_key, 'profile_data', data_json)
+            except (TypeError, ValueError) as e:
+                logging.error(f"Error al serializar profile_data para {session_key}: {e}")
+
+    def get_profile_data(self, company_short_name: str, user_identifier: str) -> dict:
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
             return {}
 
-        return RedisSessionManager.get_json(data_key, {})
+        data_json = RedisSessionManager.hget(session_key, 'profile_data')
+        if not data_json:
+            return {}
 
-    def clear_user_session_data(self, company_short_name: str, user_identifier: str):
-        """Limpia los datos de la sesión del usuario."""
-        data_key = self._get_user_data_key(company_short_name, user_identifier)
-        if data_key:
-            RedisSessionManager.remove(data_key)
+        try:
+            return json.loads(data_json)
+        except json.JSONDecodeError:
+            return {}
+
+    def save_context_version(self, company_short_name: str, user_identifier: str, version: str):
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            RedisSessionManager.hset(session_key, 'context_version', version)
+
+    def get_context_version(self, company_short_name: str, user_identifier: str) -> Optional[str]:
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
+            return None
+        return RedisSessionManager.hget(session_key, 'context_version')
+
+    def save_prepared_context(self, company_short_name: str, user_identifier: str, context: str, version: str):
+        """Guarda un contexto de sistema pre-renderizado y su versión, listos para ser enviados al LLM."""
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            RedisSessionManager.hset(session_key, 'prepared_context', context)
+            RedisSessionManager.hset(session_key, 'prepared_context_version', version)
+
+    def get_and_clear_prepared_context(self, company_short_name: str, user_identifier: str) -> tuple:
+        """Obtiene el contexto preparado y su versión, y los elimina para asegurar que se usan una sola vez."""
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
+            return None, None
+
+        pipe = RedisSessionManager.pipeline()
+        pipe.hget(session_key, 'prepared_context')
+        pipe.hget(session_key, 'prepared_context_version')
+        pipe.hdel(session_key, 'prepared_context', 'prepared_context_version')
+        results = pipe.execute()
+
+        # results[0] es el contexto, results[1] es la versión
+        return (results[0], results[1]) if results else (None, None)
+
+    # --- Métodos de Bloqueo ---
+    def acquire_lock(self, lock_key: str, expire_seconds: int) -> bool:
+        """Intenta adquirir un lock. Devuelve True si se adquiere, False si no."""
+        # SET con NX (solo si no existe) y EX (expiración) es una operación atómica.
+        return RedisSessionManager.set(lock_key, "1", ex=expire_seconds, nx=True)
+
+    def release_lock(self, lock_key: str):
+        """Libera un lock."""
+        RedisSessionManager.remove(lock_key)
+
+    def is_locked(self, lock_key: str) -> bool:
+        """Verifica si un lock existe."""
+        return RedisSessionManager.exists(lock_key)

iatoolkit/static/js/{chat_feedback.js → chat_feedback_button.js}

@@ -42,14 +42,11 @@ $(document).ready(function () {
         submitButton.html('<i class="bi bi-send me-1 icon-spaced"></i>Enviando...');
 
         const response = await sendFeedback(feedbackText);
-
         $('#feedbackModal').modal('hide');
-
-        if (response) {
-            Swal.fire({ icon: 'success', title: 'Feedback enviado', text: 'Gracias por tu comentario.' });
-        } else {
-            Swal.fire({ icon: 'error', title: 'Error', text: 'No se pudo enviar el feedback, intente nuevamente.' });
-        }
+        if (response)
+            toastr.success('¡Gracias por tu comentario!', 'Feedback Enviado');
+        else
+            toastr.error('No se pudo enviar el feedback, por favor intente nuevamente.', 'Error');
     });
 
     // Evento para abrir el modal de feedback
@@ -98,15 +95,13 @@ $(document).ready(function () {
 const sendFeedback = async function(message) {
     const activeStars = $('.star.active').length;
     const data = {
-        "external_user_id": window.externalUserId,
+        "user_identifier": window.user_identifier,
         "message": message,
         "rating": activeStars,
-        "space": "spaces/AAQAupQldd4", // Este valor podría necesitar ser dinámico
-        "type": "MESSAGE_TRIGGER"
     };
     try {
         // Asumiendo que callLLMAPI está definido globalmente en otro archivo (ej. chat_main.js)
-        const responseData = await callLLMAPI('/feedback', data, "POST");
+        const responseData = await callToolkit('/api/feedback', data, "POST");
         return responseData;
     } catch (error) {
         console.error("Error al enviar feedback:", error);

iatoolkit/static/js/chat_history_button.js

@@ -0,0 +1,126 @@
+$(document).ready(function () {
+    // Evento para abrir el modal de historial
+    $('#history-button').on('click', function() {
+        loadHistory();
+        $('#historyModal').modal('show');
+    });
+
+    // Evento delegado para el icono de copiar.
+    // Se adjunta UNA SOLA VEZ al cuerpo de la tabla y funciona para todas las filas
+    // que se añadan dinámicamente.
+    $('#history-table-body').on('click', '.copy-query-icon', function() {
+        const queryText = $(this).data('query');
+
+        // Copiar el texto al textarea del chat
+        if (queryText) {
+            $('#question').val(queryText);
+            autoResizeTextarea($('#question')[0]);
+            $('#send-button').removeClass('disabled');
+
+            // Cerrar el modal
+            $('#historyModal').modal('hide');
+
+            // Hacer focus en el textarea
+            $('#question').focus();
+        }
+    });
+
+    // Variables globales para el historial
+    let historyData = [];
+
+    // Función para cargar el historial
+    async function loadHistory() {
+        const historyLoading = $('#history-loading');
+        const historyError = $('#history-error');
+        const historyContent = $('#history-content');
+
+        // Mostrar loading
+        historyLoading.show();
+        historyError.hide();
+        historyContent.hide();
+
+        try {
+            const responseData = await callToolkit("/api/history", {}, "POST");
+
+            if (responseData && responseData.history) {
+                // Guardar datos globalmente
+                historyData = responseData.history;
+
+                // Mostrar todos los datos
+                displayAllHistory();
+
+                // Mostrar contenido
+                historyContent.show();
+            } else {
+                throw new Error('La respuesta del servidor no contenía el formato esperado.');
+            }
+        } catch (error) {
+            console.error("Error al cargar historial:", error);
+
+            const friendlyErrorMessage = "No hemos podido cargar tu historial en este momento. Por favor, cierra esta ventana y vuelve a intentarlo en unos instantes.";
+            const errorHtml = `
+                <div class="text-center p-4">
+                    <i class="bi bi-exclamation-triangle text-danger" style="font-size: 2.5rem; opacity: 0.8;"></i>
+                    <h5 class="mt-3 mb-2">Ocurrió un Problema</h5>
+                    <p class="text-muted">${friendlyErrorMessage}</p>
+                </div>
+            `;
+            historyError.html(errorHtml).show();
+        } finally {
+            historyLoading.hide();
+        }
+    }
+
+    // Función para mostrar todo el historial
+    function displayAllHistory() {
+        const historyTableBody = $('#history-table-body');
+
+        // Limpiar tabla
+        historyTableBody.empty();
+
+        // Filtrar solo consultas que son strings simples
+        const filteredHistory = historyData.filter(item => {
+            try {
+                JSON.parse(item.query);
+                return false;
+            } catch (e) {
+                return true;
+            }
+        });
+
+        // Poblar la tabla
+        filteredHistory.forEach((item, index) => {
+            const icon = $('<i>').addClass('bi bi-pencil-fill');
+
+            const link = $('<a>')
+                .attr('href', 'javascript:void(0);')
+                .addClass('copy-query-icon')
+                .attr('title', 'Copiar consulta al chat')
+                .data('query', item.query)
+                .append(icon);
+
+            const row = $('<tr>').append(
+                $('<td>').addClass('date-cell').text(formatDate(item.created_at)),
+                $('<td>').text(item.query),
+                $('<td>').addClass('text-center').append(link),
+            );
+
+            historyTableBody.append(row);
+        });
+    }
+
+    // Función para formatear fecha
+    function formatDate(dateString) {
+        const date = new Date(dateString);
+
+        const padTo2Digits = (num) => num.toString().padStart(2, '0');
+
+        const day = padTo2Digits(date.getDate());
+        const month = padTo2Digits(date.getMonth() + 1);
+        const year = date.getFullYear();
+        const hours = padTo2Digits(date.getHours());
+        const minutes = padTo2Digits(date.getMinutes());
+
+        return `${day}-${month} ${hours}:${minutes}`;
+    }
+});

iatoolkit/static/js/chat_logout_button.js

@@ -0,0 +1,36 @@
+document.addEventListener('DOMContentLoaded', function() {
+    const logoutButton = document.getElementById('logout-button');
+    if (!logoutButton) {
+        console.warn('El botón de logout con id "logout-button" no fue encontrado.');
+        return;
+    }
+
+    if (window.toastr) {
+        toastr.options = { "positionClass": "toast-bottom-right", "preventDuplicates": true };
+    }
+
+    logoutButton.addEventListener('click', async function(event) {
+        event.preventDefault();
+
+        try {
+            const apiPath = '/api/logout';
+            const data = await callToolkit(apiPath, null, 'GET');
+
+            // Procesar la respuesta
+            if (data && data.status === 'success' && data.url) {
+                window.top.location.href = data.url;
+            } else {
+                // Si algo falla, callToolkit usualmente muestra un error.
+                // Mostramos un toast como fallback.
+                if (window.toastr) {
+                    toastr.error('No se pudo procesar el cierre de sesión. Por favor, intente de nuevo.');
+                }
+            }
+        } catch (error) {
+            console.error('Error durante el logout:', error);
+            if (window.toastr) {
+                toastr.error('Ocurrió un error de red al intentar cerrar sesión.');
+            }
+        }
+    });
+});