iatoolkit 0.11.0__py3-none-any.whl → 0.71.2__py3-none-any.whl

iatoolkit/views/{file_store_view.py → file_store_api_view.py}

@@ -6,23 +6,30 @@
 from flask.views import MethodView
 from flask import request, jsonify
 from iatoolkit.services.load_documents_service import LoadDocumentsService
+from iatoolkit.services.auth_service import AuthService
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from injector import inject
 import base64
 
 
-class FileStoreView(MethodView):
+class FileStoreApiView(MethodView):
     @inject
     def __init__(self,
+                 auth_service: AuthService,
                  doc_service: LoadDocumentsService,
                  profile_repo: ProfileRepo,):
+        self.auth_service = auth_service
         self.doc_service = doc_service
         self.profile_repo = profile_repo
 
     def post(self):
         try:
-            req_data = request.get_json()
+            # 1. Authenticate the API request.
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
 
+            req_data = request.get_json()
             required_fields = ['company', 'filename', 'content']
             for field in required_fields:
                 if field not in req_data:
@@ -41,7 +48,7 @@ class FileStoreView(MethodView):
             # get the file content from base64
             content = base64.b64decode(base64_content)
 
-            new_document = self.doc_service.load_file_callback(
+            new_document = self.doc_service._file_processing_callback(
                 filename=filename,
                 content=content,
                 company=company,

iatoolkit/views/forgot_password_view.py

@@ -4,35 +4,47 @@
 # IAToolkit is open source software.
 
 from flask.views import MethodView
-from flask import render_template, request, url_for
+from flask import render_template, request, url_for, redirect, session, flash
 from injector import inject
 from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.branding_service import BrandingService
+from iatoolkit.services.i18n_service import I18nService
 from itsdangerous import URLSafeTimedSerializer
 import os
 
 class ForgotPasswordView(MethodView):
     @inject
-    def __init__(self, profile_service: ProfileService):
+    def __init__(self, profile_service: ProfileService,
+                 branding_service: BrandingService,
+                 i18n_service: I18nService):
         self.profile_service = profile_service
+        self.branding_service = branding_service
+        self.i18n_service = i18n_service
+
         self.serializer = URLSafeTimedSerializer(os.getenv("PASS_RESET_KEY"))
 
     def get(self, company_short_name: str):
         # get company info
         company = self.profile_service.get_company_by_short_name(company_short_name)
         if not company:
-            return render_template('error.html', message="Empresa no encontrada"), 404
+            return render_template('error.html',
+                                   message=self.i18n_service.t('errors.templates.company_not_found')), 404
 
+        branding_data = self.branding_service.get_company_branding(company_short_name)
         return render_template('forgot_password.html',
-                               company=company,
-                               company_short_name=company_short_name
+                               company_short_name=company_short_name,
+                               branding=branding_data
                                )
 
     def post(self, company_short_name: str):
-        company = self.profile_service.get_company_by_short_name(company_short_name)
-        if not company:
-            return render_template('error.html', message="Empresa no encontrada"), 404
 
         try:
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                return render_template('error.html',
+                                       message=self.i18n_service.t('errors.templates.company_not_found')), 404
+
+            branding_data = self.branding_service.get_company_branding(company_short_name)
             email = request.form.get('email')
 
             # create a safe token and url for it
@@ -43,22 +55,16 @@ class ForgotPasswordView(MethodView):
 
             response = self.profile_service.forgot_password(email=email, reset_url=reset_url)
             if "error" in response:
+                flash(response["error"], 'error')
                 return render_template(
                     'forgot_password.html',
-                    company=company,
                     company_short_name=company_short_name,
-                    form_data={"email": email },
-                    alert_message=response["error"]), 400
+                    branding=branding_data,
+                    form_data={"email": email}), 400
 
+            flash(self.i18n_service.t('flash_messages.forgot_password_success'), 'success')
+            return redirect(url_for('home', company_short_name=company_short_name))
 
-            return render_template('login.html',
-                                   company=company,
-                                   company_short_name=company_short_name,
-                                   alert_icon='success',
-                                   alert_message="Hemos enviado un enlace a tu correo para restablecer la contraseña.")
         except Exception as e:
-            return render_template("error.html",
-                                   company=company,
-                                   company_short_name=company_short_name,
-                                   message="Ha ocurrido un error inesperado."), 500
-
+            flash(self.i18n_service.t('errors.general.unexpected_error'), 'error')
+            return redirect(url_for('home', company_short_name=company_short_name))

iatoolkit/views/help_content_api_view.py

@@ -0,0 +1,54 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import request, jsonify
+from flask.views import MethodView
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.services.auth_service import AuthService
+from injector import inject
+import logging
+
+
+class HelpContentApiView(MethodView):
+    """
+    Handles requests from the web UI to fetch a user's query history.
+    Authentication is based on the active Flask session.
+    """
+
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 config_service: ConfigurationService,
+                 i18n_service: I18nService):
+        self.auth_service = auth_service
+        self.config_service = config_service
+        self.i18n_service = i18n_service
+
+    def post(self, company_short_name: str):
+        try:
+            # 1. Get the authenticated user's
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            user_identifier = auth_result.get('user_identifier')
+
+            # 2. Call the config service with the unified identifier.
+            response = self.config_service.get_configuration(
+                company_short_name=company_short_name,
+                content_key='help_content'      # specific key for this service
+            )
+
+            if "error" in response:
+                # Handle errors reported by the service itself.
+                return jsonify({'error_message': response["error"]}), 400
+
+            return jsonify(response), 200
+
+        except Exception as e:
+            logging.exception(
+                f"Unexpected error fetching help_content for {company_short_name}: {e}")
+            return jsonify({"error_message": self.i18n_service.t('errors.general.unexpected_error', error=str(e))}), 500

iatoolkit/views/history_api_view.py

@@ -0,0 +1,56 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import request, jsonify
+from flask.views import MethodView
+from iatoolkit.services.history_service import HistoryService
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.i18n_service import I18nService
+from injector import inject
+import logging
+
+
+class HistoryApiView(MethodView):
+    """
+    Handles requests from the web UI to fetch a user's query history.
+    Authentication is based on the active Flask session.
+    """
+
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 history_service: HistoryService,
+                 i18n_service: I18nService):
+        self.auth_service = auth_service
+        self.history_service = history_service
+        self.i18n_service = i18n_service
+
+
+    def post(self, company_short_name: str):
+        try:
+            # 1. Get the authenticated user's
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            user_identifier = auth_result.get('user_identifier')
+
+            # 2. Call the history service with the unified identifier.
+            # The service's signature should now only expect user_identifier.
+            response = self.history_service.get_history(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier
+            )
+
+            if "error" in response:
+                # Handle errors reported by the service itself.
+                return jsonify({'error_message': response["error"]}), 400
+
+            return jsonify(response), 200
+
+        except Exception as e:
+            logging.exception(
+                f"Unexpected error: {e}")
+            return jsonify({"error_message": self.i18n_service.t('errors.general.unexpected_error', error=str(e))}), 500

iatoolkit/views/home_view.py

@@ -1,34 +1,61 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
+# iatoolkit/views/home_view.py
+from flask import render_template,  render_template_string
 from flask.views import MethodView
-from flask import render_template, request
 from injector import inject
 from iatoolkit.services.profile_service import ProfileService
-import os
-
+from iatoolkit.services.branding_service import BrandingService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.common.util import Utility
 
 class HomeView(MethodView):
+    """
+    Handles the rendering of the company-specific home page with a login widget.
+    If the custom template is not found or fails, it renders an error page.
+    """
+
     @inject
     def __init__(self,
-                 profile_service: ProfileService):
+                 profile_service: ProfileService,
+                 branding_service: BrandingService,
+                 i18n_service: I18nService,
+                 utility: Utility):
         self.profile_service = profile_service
+        self.branding_service = branding_service
+        self.i18n_service = i18n_service
+        self.util = utility
+
+    def get(self, company_short_name: str):
+        branding_data = {}
+        try:
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                return render_template('error.html',
+                                       message=self.i18n_service.t('errors.templates.company_not_found')), 404
 
-    def get(self):
-        user_agent = request.user_agent
-        is_mobile = user_agent.platform in ["android", "iphone", "ipad"] or "mobile" in user_agent.string.lower()
-        alert_message = request.args.get('alert_message', None)
-        companies = self.profile_service.get_companies()
+            branding_data = self.branding_service.get_company_branding(company_short_name)
+            home_template = self.util.get_company_template(company_short_name, "home.html")
 
-        # Esta API_KEY para el login
-        api_key_for_login = os.getenv("IATOOLKIT_API_KEY", "tu_api_key_por_defecto_o_error")
+            # 2. Verificamos si el archivo de plantilla personalizado no existe.
+            if not home_template:
+                message = self.i18n_service.t('errors.templates.home_template_not_found', company_name=company_short_name)
+                return render_template(
+                    "error.html",
+                    company_short_name=company_short_name,
+                    branding=branding_data,
+                    message=message
+                ), 500
 
-        return render_template('home.html',
-                               companies=companies,
-                               is_mobile=is_mobile,
-                               alert_message=alert_message,
-                               alert_icon='success' if alert_message else None,
-                               api_key=api_key_for_login
-                               )
+            # 3. Si el archivo existe, intentamos leerlo y renderizarlo.
+            return render_template_string(
+                home_template,
+                company_short_name=company_short_name,
+                branding=branding_data,
+            )
+        except Exception as e:
+            message = self.i18n_service.t('errors.templates.processing_error', error=str(e))
+            return render_template(
+                "error.html",
+                company_short_name=company_short_name,
+                branding=branding_data,
+                message=message
+            ), 500

iatoolkit/views/index_view.py

@@ -0,0 +1,14 @@
+# iatoolkit/views/index_view.py
+
+from flask import render_template, session
+from flask.views import MethodView
+
+
+class IndexView(MethodView):
+    """
+    Handles the rendering of the generic landing page, which no longer depends
+    on a specific company.
+    """
+
+    def get(self):
+        return render_template('index.html')

iatoolkit/views/init_context_api_view.py

@@ -0,0 +1,74 @@
+from flask.views import MethodView
+from injector import inject
+from iatoolkit.services.query_service import QueryService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.i18n_service import I18nService
+from flask import jsonify, request
+import logging
+
+
+class InitContextApiView(MethodView):
+    """
+    API endpoint to force a full context rebuild for a user.
+    Handles both web users (via session) and API users (via API Key).
+    """
+
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 query_service: QueryService,
+                 profile_service: ProfileService,
+                 i18n_service: I18nService):
+        self.auth_service = auth_service
+        self.query_service = query_service
+        self.profile_service = profile_service
+        self.i18n_service = i18n_service
+
+    def post(self, company_short_name: str):
+        """
+        Cleans and rebuilds the context. The user is identified either by
+        an active web session or by the external_user_id in the JSON payload
+        for API calls.
+        """
+        try:
+            # 1. Authenticate the request. This handles both session and API Key.
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            user_identifier = auth_result.get('user_identifier')
+
+            # check if model was sent as a parameter
+            data = request.get_json(silent=True) or {}
+            model = data.get('model', '')
+
+            # reinit the LLM context
+            response = self.query_service.init_context(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier,
+                model=model)
+
+            # Respond with JSON, as this is an API endpoint.
+            success_message = self.i18n_service.t('api_responses.context_reloaded_success')
+            response_message = {'status': 'OK', 'message': success_message}
+
+            # if received a response ID with the context, return it
+            if response.get('response_id'):
+                response_message['response_id'] = response['response_id']
+
+            return jsonify(response_message), 200
+
+        except Exception as e:
+            logging.exception(f"errors while reloading context: {e}")
+            error_message = self.i18n_service.t('errors.general.unexpected_error', error=str(e))
+            return jsonify({"error_message": error_message}), 406
+
+    def options(self, company_short_name):
+        """
+        Maneja las solicitudes preflight de CORS.
+        Su única función es existir y devolver una respuesta exitosa para que
+        el middleware Flask-CORS pueda interceptarla y añadir las cabeceras
+        'Access-Control-Allow-*'.
+        """
+        return {}, 200

iatoolkit/views/llmquery_api_view.py

@@ -0,0 +1,58 @@
+from flask.views import MethodView
+from flask import request, jsonify
+from injector import inject
+from iatoolkit.services.query_service import QueryService
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.i18n_service import I18nService
+import logging
+
+class LLMQueryApiView(MethodView):
+    """
+    API-only endpoint for submitting queries. Authenticates via API Key.
+    """
+
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 query_service: QueryService,
+                 profile_service: ProfileService,
+                 i18n_service: I18nService):
+        self.auth_service = auth_service
+        self.query_service = query_service
+        self.profile_service = profile_service
+        self.i18n_service = i18n_service
+
+    def post(self, company_short_name: str):
+        try:
+            # 1. Authenticate the API request.
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            # 2. Get the user identifier from the payload.
+            user_identifier = auth_result.get('user_identifier')
+
+            data = request.get_json()
+            if not data:
+                return jsonify({"error": "Invalid JSON body"}), 400
+
+            # 4. Call the unified query service method.
+            result = self.query_service.llm_query(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier,
+                question=data.get('question', ''),
+                prompt_name=data.get('prompt_name'),
+                client_data=data.get('client_data', {}),
+                response_id = data.get('response_id'),
+                files=data.get('files', [])
+            )
+            if 'error' in result:
+                return jsonify(result), 407
+
+            return jsonify(result), 200
+
+        except Exception as e:
+            logging.exception(
+                f"Unexpected error: {e}")
+            return jsonify({"error_message": self.i18n_service.t('errors.general.unexpected_error', error=str(e))}), 500

iatoolkit/views/login_simulation_view.py

@@ -0,0 +1,93 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import requests
+import json
+import os
+from flask.views import MethodView
+from flask import render_template, request, Response
+from injector import inject
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.branding_service import BrandingService
+
+
+class LoginSimulationView(MethodView):
+    @inject
+    def __init__(self,
+                 profile_service: ProfileService,
+                 branding_service: BrandingService):
+        self.profile_service = profile_service
+        self.branding_service = branding_service
+
+
+    def get(self, company_short_name: str = None):
+        company = self.profile_service.get_company_by_short_name(company_short_name)
+        if not company:
+            return render_template('error.html',
+                                   company_short_name=company_short_name,
+                                   message="Empresa no encontrada"), 404
+
+        branding_data = self.branding_service.get_company_branding(company_short_name)
+
+        return render_template('login_simulation.html',
+                               branding=branding_data,
+                               company_short_name=company_short_name
+                               )
+
+    def post(self, company_short_name: str):
+        """
+        Recibe el POST del formulario y actúa como un proxy servidor-a-servidor.
+        Llama al endpoint 'external_login' y devuelve su respuesta (HTML y headers).
+        """
+        api_key = os.getenv("IATOOLKIT_API_KEY")
+        # Obtenemos la URL base de la petición actual para construir la URL interna
+        base_url = request.host_url.rstrip('/')
+
+        # 1. Obtener el user_identifier del formulario
+        user_identifier = request.form.get('external_user_id')
+
+        if not user_identifier:
+            return Response("Error: El campo 'external_user_id' es requerido.", status=400)
+
+        # 2. Preparar la llamada a la API real de external_login
+        target_url = f"{base_url}/{company_short_name}/external_login"
+        headers = {
+            'Content-Type': 'application/json',
+            'Authorization': f'Bearer {api_key}'
+        }
+        # El payload debe ser un diccionario que se convertirá a JSON
+        payload = {'user_identifier': user_identifier}
+
+        try:
+            # 3. Llamada POST segura desde este servidor al endpoint de IAToolkit
+            internal_response = requests.post(
+                target_url,
+                headers=headers,
+                data=json.dumps(payload),
+                timeout=120,
+                stream=True  # Usamos stream para manejar la respuesta eficientemente
+            )
+            internal_response.raise_for_status()
+
+            # 4. Creamos una nueva Response de Flask para el navegador del usuario.
+            user_response = Response(
+                internal_response.iter_content(chunk_size=1024),
+                status=internal_response.status_code
+            )
+
+            # 5. Copiamos TODAS las cabeceras de la respuesta interna a la respuesta final.
+            # Esto es CRUCIAL para que las cookies ('Set-Cookie') lleguen al navegador.
+            for key, value in internal_response.headers.items():
+                # Excluimos cabeceras que no debemos pasar (controladas por el servidor WSGI)
+                if key.lower() not in ['content-encoding', 'content-length', 'transfer-encoding', 'connection']:
+                    user_response.headers[key] = value
+
+            return user_response
+
+        except requests.exceptions.HTTPError as e:
+            error_text = f"Error en la llamada interna a la API: {e.response.status_code}. Respuesta: {e.response.text}"
+            return Response(error_text, status=e.response.status_code, mimetype='text/plain')
+        except requests.exceptions.RequestException as e:
+            return Response(f'Error de conexión con el servicio de IA: {str(e)}', status=502, mimetype='text/plain')