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

iatoolkit/infra/redis_session_manager.py

@@ -37,9 +37,14 @@ class RedisSessionManager:
         return cls._client
 
     @classmethod
-    def set(cls, key: str, value: str, ex: int = None):
+    def set(cls, key: str, value: str, **kwargs):
+        """
+        Método set flexible que pasa argumentos opcionales (como ex, nx)
+        directamente al cliente de redis.
+        """
         client = cls._get_client()
-        result = client.set(key, value, ex=ex)
+        # Pasa todos los argumentos de palabra clave adicionales al cliente real
+        result = client.set(key, value, **kwargs)
         return result
 
     @classmethod
@@ -49,12 +54,53 @@ class RedisSessionManager:
         result = value if value is not None else default
         return result
 
+    @classmethod
+    def hset(cls, key: str, field: str, value: str):
+        """
+        Establece un campo en un Hash de Redis.
+        """
+        client = cls._get_client()
+        return client.hset(key, field, value)
+
+    @classmethod
+    def hget(cls, key: str, field: str):
+        """
+        Obtiene el valor de un campo de un Hash de Redis.
+        Devuelve None si la clave o el campo no existen.
+        """
+        client = cls._get_client()
+        return client.hget(key, field)
+
+    @classmethod
+    def hdel(cls, key: str, *fields):
+        """
+        Elimina uno o más campos de un Hash de Redis.
+        """
+        client = cls._get_client()
+        return client.hdel(key, *fields)
+
+    @classmethod
+    def pipeline(cls):
+        """
+        Inicia una transacción (pipeline) de Redis.
+        """
+        client = cls._get_client()
+        return client.pipeline()
+
+
     @classmethod
     def remove(cls, key: str):
         client = cls._get_client()
         result = client.delete(key)
         return result
 
+    @classmethod
+    def exists(cls, key: str) -> bool:
+        """Verifica si una clave existe en Redis."""
+        client = cls._get_client()
+        # El comando EXISTS de Redis devuelve un entero (0 o 1). Lo convertimos a booleano.
+        return bool(client.exists(key))
+
     @classmethod
     def set_json(cls, key: str, value: dict, ex: int = None):
         json_str = json.dumps(value)

iatoolkit/repositories/database_manager.py

@@ -21,8 +21,23 @@ class DatabaseManager:
         :param echo: Si True, habilita logs de SQL.
         """
         self.url = make_url(database_url)
-        self._engine = create_engine(database_url, echo=False)
-        self.SessionFactory = sessionmaker(bind=self._engine)
+        if database_url.startswith('sqlite'):       # for tests
+            self._engine = create_engine(database_url, echo=False)
+        else:
+            self._engine = create_engine(
+                database_url,
+                echo=False,
+                pool_size=2,  # per worker
+                max_overflow=3,
+                pool_timeout=30,
+                pool_recycle=1800,
+                pool_pre_ping=True,
+                future=True,
+            )
+        self.SessionFactory = sessionmaker(bind=self._engine,
+                                           autoflush=False,
+                                           autocommit=False,
+                                           expire_on_commit=False)
         self.scoped_session = scoped_session(self.SessionFactory)
 
         # REGISTRAR pgvector para cada nueva conexión solo en postgres

iatoolkit/repositories/models.py

@@ -3,9 +3,10 @@
 #
 # IAToolkit is open source software.
 
-from sqlalchemy import Column, Integer, String, DateTime, Enum, Text, JSON, Boolean, ForeignKey, Table
+from sqlalchemy import Column, Integer, BigInteger, String, DateTime, Enum, Text, JSON, Boolean, ForeignKey, Table
 from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.orm import relationship, class_mapper, declarative_base
+from sqlalchemy.sql import func
 from datetime import datetime
 from pgvector.sqlalchemy import Vector
 from enum import Enum as PyEnum
@@ -57,10 +58,11 @@ class Company(Base):
     openai_api_key = Column(String, nullable=True)
     gemini_api_key = Column(String, nullable=True)
 
-    logo_file = Column(String(128), nullable=True, default='')
-    parameters = Column(JSON, nullable=True, default={})
+    branding = Column(JSON, nullable=True)
+    onboarding_cards = Column(JSON, nullable=True)
+    parameters = Column(JSON, nullable=True)
     created_at = Column(DateTime, default=datetime.now)
-    allow_jwt = Column(Boolean, default=False, nullable=True)
+    allow_jwt = Column(Boolean, default=True, nullable=True)
 
     documents = relationship("Document",
                              back_populates="company",
@@ -264,8 +266,7 @@ class UserFeedback(Base):
     id = Column(Integer, primary_key=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                                             ondelete='CASCADE'), nullable=False)
-    local_user_id = Column(Integer, default=0, nullable=True)
-    external_user_id = Column(String(128), default='', nullable=True)
+    user_identifier = Column(String(128), default='', nullable=True)
     message = Column(Text, nullable=False)
     rating = Column(Integer, nullable=False)
     created_at = Column(DateTime, default=datetime.now)
@@ -307,3 +308,27 @@ class Prompt(Base):
 
     company = relationship("Company", back_populates="prompts")
     category = relationship("PromptCategory", back_populates="prompts")
+
+class AccessLog(Base):
+    # Modelo ORM para registrar cada intento de acceso a la plataforma.
+    __tablename__ = 'iat_access_log'
+
+    id = Column(BigInteger, primary_key=True)
+
+    timestamp = Column(DateTime(timezone=True), server_default=func.now(), nullable=False, index=True)
+    company_short_name = Column(String(100), nullable=False, index=True)
+    user_identifier = Column(String(255), index=True)
+
+    # Cómo y el Resultado
+    auth_type = Column(String(20), nullable=False) # 'local', 'external_api', 'redeem_token', etc.
+    outcome = Column(String(10), nullable=False)   # 'success' o 'failure'
+    reason_code = Column(String(50))               # Causa de fallo, ej: 'INVALID_CREDENTIALS'
+
+    # Contexto de la Petición
+    source_ip = Column(String(45), nullable=False)
+    user_agent_hash = Column(String(16))           # Hash corto del User-Agent
+    request_path = Column(String(255), nullable=False)
+
+    def __repr__(self):
+        return (f"<AccessLog(id={self.id}, company='{self.company_short_name}', "
+                f"user='{self.user_identifier}', outcome='{self.outcome}')>")

iatoolkit/repositories/profile_repo.py

@@ -72,9 +72,14 @@ class ProfileRepo:
     def create_company(self, new_company: Company):
         company = self.session.query(Company).filter_by(name=new_company.name).first()
         if company:
-            company.parameters = new_company.parameters
-            company.logo_file = new_company.logo_file
+            if company.parameters != new_company.parameters:
+                company.parameters = new_company.parameters
+            if company.branding != new_company.branding:
+                company.branding = new_company.branding
+            if company.onboarding_cards != new_company.onboarding_cards:
+                company.onboarding_cards = new_company.onboarding_cards
         else:
+            # Si la compañía no existe, la añade a la sesión.
             self.session.add(new_company)
             company = new_company
 

iatoolkit/services/auth_service.py

@@ -0,0 +1,188 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import request
+from injector import inject
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.jwt_service import JWTService
+from iatoolkit.repositories.database_manager import DatabaseManager
+from iatoolkit.repositories.models import AccessLog
+from flask import request
+import logging
+import hashlib
+
+
+class AuthService:
+    """
+    Centralized service for handling authentication for all incoming requests.
+    It determines the user's identity based on either a Flask session cookie or an API Key.
+    """
+
+    @inject
+    def __init__(self, profile_service: ProfileService,
+                 jwt_service: JWTService,
+                 db_manager: DatabaseManager
+                 ):
+        self.profile_service = profile_service
+        self.jwt_service = jwt_service
+        self.db_manager = db_manager
+
+    def login_local_user(self, company_short_name: str, email: str, password: str) -> dict:
+        # try to autenticate a local user, register the event and return the result
+        auth_response = self.profile_service.login(
+            company_short_name=company_short_name,
+            email=email,
+            password=password
+        )
+
+        if not auth_response.get('success'):
+            self.log_access(
+                company_short_name=company_short_name,
+                user_identifier=email,
+                auth_type='local',
+                outcome='failure',
+                reason_code='INVALID_CREDENTIALS',
+            )
+        else:
+            self.log_access(
+                company_short_name=company_short_name,
+                auth_type='local',
+                outcome='success',
+                user_identifier=auth_response.get('user_identifier')
+            )
+
+        return auth_response
+
+    def redeem_token_for_session(self, company_short_name: str, token: str) -> dict:
+        # redeem a token for a session, register the event and return the result
+        payload = self.jwt_service.validate_chat_jwt(token)
+
+        if not payload:
+            self.log_access(
+                company_short_name=company_short_name,
+                auth_type='redeem_token',
+                outcome='failure',
+                reason_code='JWT_INVALID'
+            )
+            return {'success': False, 'error': 'Token inválido o expirado'}
+
+        # 2. if token is valid, extract the user_identifier
+        user_identifier = payload.get('user_identifier')
+        try:
+            # create the Flask session
+            self.profile_service.set_session_for_user(company_short_name, user_identifier)
+            self.log_access(
+                company_short_name=company_short_name,
+                auth_type='redeem_token',
+                outcome='success',
+                user_identifier=user_identifier
+            )
+            return {'success': True, 'user_identifier': user_identifier}
+        except Exception as e:
+            logging.error(f"Error al crear la sesión desde token para {user_identifier}: {e}")
+            self.log_access(
+                company_short_name=company_short_name,
+                auth_type='redeem_token',
+                outcome='failure',
+                reason_code='SESSION_CREATION_FAILED',
+                user_identifier=user_identifier
+            )
+            return {'success': False, 'error': 'No se pudo crear la sesión del usuario'}
+
+    def verify(self, anonymous: bool = False) -> dict:
+        """
+        Verifies the current request and identifies the user.
+        If anonymous is True the non-presence of use_identifier is ignored
+
+        Returns a dictionary with:
+        - success: bool
+        - user_identifier: str (if successful)
+        - company_short_name: str (if successful)
+        - error_message: str (on failure)
+        - status_code: int (on failure)
+        """
+        # --- Priority 1: Check for a valid Flask web session ---
+        session_info = self.profile_service.get_current_session_info()
+        if session_info and session_info.get('user_identifier'):
+            # User is authenticated via a web session cookie.
+            return {
+                "success": True,
+                "company_short_name": session_info['company_short_name'],
+                "user_identifier": session_info['user_identifier'],
+            }
+
+        # --- Priority 2: Check for a valid API Key in headers ---
+        api_key = None
+        auth = request.headers.get('Authorization', '')
+        if isinstance(auth, str) and auth.lower().startswith('bearer '):
+            api_key =  auth.split(' ', 1)[1].strip()
+
+        if not api_key:
+            # --- Failure: No valid credentials found ---
+            logging.info(f"Authentication required. No session cookie or API Key provided.")
+            return {"success": False,
+                    "error_message": "Authentication required. No session cookie or API Key provided.",
+                    "status_code": 401}
+
+        # check if the api-key is valid and active
+        api_key_entry = self.profile_service.get_active_api_key_entry(api_key)
+        if not api_key_entry:
+            logging.info(f"Invalid or inactive API Key {api_key}")
+            return {"success": False, "error_message": "Invalid or inactive API Key",
+                    "status_code": 402}
+
+        # get the company from the api_key_entry
+        company = api_key_entry.company
+
+        # For API calls, the external_user_id must be provided in the request.
+        data = request.get_json(silent=True) or {}
+        user_identifier = data.get('user_identifier', '')
+        if not anonymous and not user_identifier:
+            logging.info(f"No user_identifier provided for API call.")
+            return {"success": False, "error_message": "No user_identifier provided for API call.",
+                    "status_code": 403}
+
+        return {
+            "success": True,
+            "company_short_name": company.short_name,
+            "user_identifier": user_identifier
+        }
+
+
+    def log_access(self,
+                   company_short_name: str,
+                   auth_type: str,
+                   outcome: str,
+                   user_identifier: str = None,
+                   reason_code: str = None):
+        """
+        Registra un intento de acceso en la base de datos.
+        Es "best-effort" y no debe interrumpir el flujo de autenticación.
+        """
+        session = self.db_manager.scoped_session()
+        try:
+            # Capturar datos del contexto de la petición de Flask
+            source_ip = request.headers.get('X-Forwarded-For', request.remote_addr)
+            path = request.path
+            ua = request.headers.get('User-Agent', '')
+            ua_hash = hashlib.sha256(ua.encode()).hexdigest()[:16] if ua else None
+
+            # Crear la entrada de log
+            log_entry = AccessLog(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier,
+                auth_type=auth_type,
+                outcome=outcome,
+                reason_code=reason_code,
+                source_ip=source_ip,
+                user_agent_hash=ua_hash,
+                request_path=path,
+            )
+            session.add(log_entry)
+            session.commit()
+
+        except Exception as e:
+            logging.error(f"Fallo al escribir en AccessLog: {e}", exc_info=False)
+            session.rollback()

iatoolkit/services/branding_service.py

@@ -0,0 +1,147 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.repositories.models import Company
+
+
+class BrandingService:
+    """
+    Servicio centralizado que gestiona la configuración de branding.
+    """
+
+    def __init__(self):
+        """
+        Define los estilos de branding por defecto para la aplicación.
+        """
+        self._default_branding = {
+            # --- Estilos del Encabezado Principal ---
+            "header_background_color": "#FFFFFF",
+            "header_text_color": "#6C757D",
+            "primary_font_weight": "600",
+            "primary_font_size": "1.2rem",
+            "secondary_font_weight": "400",
+            "secondary_font_size": "0.9rem",
+            "tertiary_font_weight": "300",
+            "tertiary_font_size": "0.8rem",
+            "tertiary_opacity": "0.7",
+
+            # headings
+            "brand_text_heading_color": "#334155",  # Gris pizarra por defecto
+
+            # Estilos Globales de la Marca ---
+            "brand_primary_color": "#0d6efd",  # Azul de Bootstrap por defecto
+            "brand_secondary_color": "#6c757d",  # Gris de Bootstrap por defecto
+            "brand_text_on_primary": "#FFFFFF",  # Texto blanco sobre color primario
+            "brand_text_on_secondary": "#FFFFFF",  # Texto blanco sobre color secundario
+
+            # Estilos para Alertas de Error ---
+            "brand_danger_color": "#dc3545",  # Rojo principal para alertas
+            "brand_danger_bg": "#f8d7da",  # Fondo rojo pálido
+            "brand_danger_text": "#842029",  # Texto rojo oscuro
+            "brand_danger_border": "#f5c2c7",  # Borde rojo intermedio
+
+            # Estilos para Alertas Informativas ---
+            "brand_info_bg": "#F0F4F8",         # Un fondo de gris azulado muy pálido
+            "brand_info_text": "#0d6efd",       # Texto en el color primario
+            "brand_info_border": "#D9E2EC",     # Borde de gris azulado pálido
+
+            # Estilos para el Asistente de Prompts ---
+            "prompt_assistant_bg": "#f8f9fa",
+            "prompt_assistant_border": "#dee2e6",
+            "prompt_assistant_button_bg": "#FFFFFF",
+            "prompt_assistant_button_text": "#495057",
+            "prompt_assistant_button_border": "#ced4da",
+            "prompt_assistant_dropdown_bg": "#f8f9fa",
+            "prompt_assistant_header_bg": "#e9ecef",
+            "prompt_assistant_header_text": "#495057",
+
+            # this use the primary by default
+            "prompt_assistant_icon_color": None,
+            "prompt_assistant_item_hover_bg": None,
+            "prompt_assistant_item_hover_text": None,
+
+            # Color para el botón de Enviar ---
+            "send_button_color": "#212529"          # Gris oscuro/casi negro por defecto
+        }
+
+    def get_company_branding(self, company: Company | None) -> dict:
+        """
+        Retorna los estilos de branding finales para una compañía,
+        fusionando los valores por defecto con los personalizados.
+        """
+        final_branding_values = self._default_branding.copy()
+
+        if company and company.branding:
+            final_branding_values.update(company.branding)
+
+        # Función para convertir HEX a RGB
+        def hex_to_rgb(hex_color):
+            hex_color = hex_color.lstrip('#')
+            return tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4))
+
+        primary_rgb = hex_to_rgb(final_branding_values['brand_primary_color'])
+        secondary_rgb = hex_to_rgb(final_branding_values['brand_secondary_color'])
+
+        # --- CONSTRUCCIÓN DE ESTILOS Y VARIABLES CSS ---
+        primary_text_style = (
+            f"font-weight: {final_branding_values['primary_font_weight']}; "
+            f"font-size: {final_branding_values['primary_font_size']};"
+        )
+        secondary_text_style = (
+            f"font-weight: {final_branding_values['secondary_font_weight']}; "
+            f"font-size: {final_branding_values['secondary_font_size']};"
+        )
+        tertiary_text_style = (
+            f"font-weight: {final_branding_values['tertiary_font_weight']}; "
+            f"font-size: {final_branding_values['tertiary_font_size']}; "
+            f"opacity: {final_branding_values['tertiary_opacity']};"
+        )
+
+        # Generamos el bloque de variables CSS
+        css_variables = f"""
+            :root {{
+                --brand-primary-color: {final_branding_values['brand_primary_color']};
+                --brand-secondary-color: {final_branding_values['brand_secondary_color']};
+                --brand-header-bg: {final_branding_values['header_background_color']};
+                --brand-header-text: {final_branding_values['header_text_color']};
+                --brand-text-heading-color: {final_branding_values['brand_text_heading_color']};
+
+                --brand-primary-color-rgb: {', '.join(map(str, primary_rgb))};
+                --brand-secondary-color-rgb: {', '.join(map(str, secondary_rgb))};
+                --brand-text-on-primary: {final_branding_values['brand_text_on_primary']};
+                --brand-text-on-secondary: {final_branding_values['brand_text_on_secondary']};
+                --brand-modal-header-bg: {final_branding_values['header_background_color']};
+                --brand-modal-header-text: {final_branding_values['header_text_color']};
+                --brand-danger-color: {final_branding_values['brand_danger_color']};
+                --brand-danger-bg: {final_branding_values['brand_danger_bg']};
+                --brand-danger-text: {final_branding_values['brand_danger_text']};
+                --brand-danger-border: {final_branding_values['brand_danger_border']};
+                --brand-info-bg: {final_branding_values['brand_info_bg']};
+                --brand-info-text: {final_branding_values['brand_info_text'] or final_branding_values['brand_primary_color']};
+                --brand-info-border: {final_branding_values['brand_info_border']};
+                --brand-prompt-assistant-bg: {final_branding_values['prompt_assistant_bg']};
+                --brand-prompt-assistant-border: {final_branding_values['prompt_assistant_border']};
+                --brand-prompt-assistant-icon-color: {final_branding_values['prompt_assistant_icon_color'] or final_branding_values['brand_primary_color']};
+                --brand-prompt-assistant-button-bg: {final_branding_values['prompt_assistant_button_bg']};
+                --brand-prompt-assistant-button-text: {final_branding_values['prompt_assistant_button_text']};
+                --brand-prompt-assistant-button-border: {final_branding_values['prompt_assistant_button_border']};
+                --brand-prompt-assistant-dropdown-bg: {final_branding_values['prompt_assistant_dropdown_bg']};
+                --brand-prompt-assistant-header-bg: {final_branding_values['prompt_assistant_header_bg']};
+                --brand-prompt-assistant-header-text: {final_branding_values['prompt_assistant_header_text']};
+                --brand-prompt-assistant-item-hover-bg: {final_branding_values['prompt_assistant_item_hover_bg'] or final_branding_values['brand_primary_color']};
+                --brand-prompt-assistant-item-hover-text: {final_branding_values['prompt_assistant_item_hover_text'] or final_branding_values['brand_text_on_primary']};
+
+            }}
+        """
+
+        return {
+            "name": company.name if company else "IAToolkit",
+            "primary_text_style": primary_text_style,
+            "secondary_text_style": secondary_text_style,
+            "tertiary_text_style": tertiary_text_style,
+            "header_text_color": final_branding_values['header_text_color'],
+            "css_variables": css_variables,
+            "send_button_color": final_branding_values['send_button_color']
+        }

iatoolkit/services/dispatcher_service.py

@@ -10,7 +10,6 @@ from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.repositories.models import Company, Function
 from iatoolkit.services.excel_service import ExcelService
 from iatoolkit.services.mail_service import MailService
-from iatoolkit.common.session_manager import SessionManager
 from iatoolkit.common.util import Utility
 from injector import inject
 import logging
@@ -171,50 +170,21 @@ class Dispatcher:
             tools.append(ai_tool)
         return tools
 
-    def get_user_info(self, company_name: str, user_identifier: str, is_local_user: bool) -> dict:
+    def get_user_info(self, company_name: str, user_identifier: str) -> dict:
         if company_name not in self.company_instances:
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
                                      f"Empresa no configurada: {company_name}")
 
-        raw_user_data = {}
-        if is_local_user:
-            # source 1: local user login into IAToolkit
-            raw_user_data = SessionManager.get('user', {})
-        else:
-            # source 2: external company user
-            company_instance = self.company_instances[company_name]
-            try:
-                raw_user_data = company_instance.get_user_info(user_identifier)
-            except Exception as e:
-                logging.exception(e)
-                raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                                         f"Error en get_user_info de {company_name}: {str(e)}") from e
-
-        # always normalize the data for consistent structure
-        return self._normalize_user_data(raw_user_data, is_local_user)
-
-    def _normalize_user_data(self, raw_data: dict, is_local: bool) -> dict:
-        """
-        Asegura que los datos del usuario siempre tengan una estructura consistente.
-        """
-        # default values
-        normalized_user = {
-            "id": raw_data.get("id", 0),
-            "user_email": raw_data.get("email", ""),
-            "user_fullname": raw_data.get("user_fullname", ""),
-            "company_id": raw_data.get("company_id", 0),
-            "company_name": raw_data.get("company", ""),
-            "company_short_name": raw_data.get("company_short_name", ""),
-            "is_local": is_local,
-            "extras": raw_data.get("extras", {})
-        }
-
-        # get the extras from the raw data, if any
-        extras = raw_data.get("extras", {})
-        if isinstance(extras, dict):
-            normalized_user.update(extras)
+        # source 2: external company user
+        company_instance = self.company_instances[company_name]
+        try:
+            external_user_profile = company_instance.get_user_info(user_identifier)
+        except Exception as e:
+            logging.exception(e)
+            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
+                                     f"Error en get_user_info de {company_name}: {str(e)}") from e
 
-        return normalized_user
+        return external_user_profile
 
     def get_metadata_from_filename(self, company_name: str, filename: str) -> dict:
         if company_name not in self.company_instances:

iatoolkit/services/excel_service.py

@@ -23,21 +23,21 @@ class ExcelService:
 
     def excel_generator(self, **kwargs) -> str:
         """
-                Genera un Excel a partir de una lista de diccionarios.
-
-                Parámetros esperados en kwargs:
-                  - filename: str (nombre lógico a mostrar, ej. "reporte_clientes.xlsx") [obligatorio]
-                  - data: list[dict] (filas del excel) [obligatorio]
-                  - sheet_name: str = "hoja 1"
-
-                Retorna:
-                     {
-                        "filename": "reporte.xlsx",
-                        "attachment_token": "8b7f8a66-...-c1c3.xlsx",
-                        "content_type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                        "download_link": "/download/8b7f8a66-...-c1c3.xlsx"
-                        }
-                """
+        Genera un Excel a partir de una lista de diccionarios.
+
+        Parámetros esperados en kwargs:
+          - filename: str (nombre lógico a mostrar, ej. "reporte_clientes.xlsx") [obligatorio]
+          - data: list[dict] (filas del excel) [obligatorio]
+          - sheet_name: str = "hoja 1"
+
+        Retorna:
+             {
+                "filename": "reporte.xlsx",
+                "attachment_token": "8b7f8a66-...-c1c3.xlsx",
+                "content_type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                "download_link": "/download/8b7f8a66-...-c1c3.xlsx"
+                }
+        """
         try:
             # get the parameters
             fname = kwargs.get('filename')

iatoolkit/services/history_service.py

@@ -5,29 +5,20 @@
 
 from injector import inject
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-
 from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.common.util import Utility
 
 
 class HistoryService:
     @inject
     def __init__(self, llm_query_repo: LLMQueryRepo,
-                 profile_repo: ProfileRepo,
-                 util: Utility):
+                 profile_repo: ProfileRepo):
         self.llm_query_repo = llm_query_repo
         self.profile_repo = profile_repo
-        self.util = util
 
     def get_history(self,
                      company_short_name: str,
-                     external_user_id: str = None,
-                     local_user_id: int = 0) -> dict:
+                     user_identifier: str) -> dict:
         try:
-            user_identifier, _ = self.util.resolve_user_identifier(external_user_id, local_user_id)
-            if not user_identifier:
-                return {'error': "No se pudo resolver el identificador del usuario"}
-
             # validate company
             company = self.profile_repo.get_company_by_short_name(company_short_name)
             if not company:
@@ -36,7 +27,7 @@ class HistoryService:
             history = self.llm_query_repo.get_history(company, user_identifier)
 
             if not history:
-                return {'error': 'No se pudo obtener el historial'}
+                return {'message': 'Historial vacio actualmente', 'history': []}
 
             history_list = [query.to_dict() for query in history]