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

iatoolkit/views/login_view.py

@@ -7,54 +7,138 @@ from flask.views import MethodView
 from flask import request, redirect, render_template, url_for
 from injector import inject
 from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.jwt_service import JWTService
+from iatoolkit.services.query_service import QueryService
+from iatoolkit.services.prompt_manager_service import PromptService
+from iatoolkit.services.branding_service import BrandingService
+from iatoolkit.services.onboarding_service import OnboardingService
+from iatoolkit.views.base_login_view import BaseLoginView
+import logging
 
-class LoginView(MethodView):
-    @inject
-    def __init__(self, profile_service: ProfileService):
-        self.profile_service = profile_service
 
-    def get(self, company_short_name: str):
-        # get company info
+class LoginView(BaseLoginView):
+    """
+    Handles login for local users.
+    Authenticates and then delegates the path decision (fast/slow) to the base class.
+    """
+    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
+            return render_template('error.html',
+                        company_short_name=company_short_name,
+                        message="Empresa no encontrada"), 404
 
-        return render_template('login.html',
-                               company=company,
-                               company_short_name=company_short_name)
+        branding_data = self.branding_service.get_company_branding(company)
+        email = request.form.get('email')
+        password = request.form.get('password')
+
+        # 1. Authenticate internal user
+        auth_response = self.auth_service.login_local_user(
+            company_short_name=company_short_name,
+            email=email,
+            password=password
+        )
+
+        if not auth_response['success']:
+
+            return render_template(
+                'home.html',
+                company_short_name=company_short_name,
+                company=company,
+                branding=branding_data,
+                form_data={"email": email},
+                alert_message=auth_response["message"]
+            ), 400
+
+        user_identifier = auth_response['user_identifier']
+
+        # 3. define URL to call when slow path is finished
+        target_url = url_for('finalize_no_token',
+                             company_short_name=company_short_name,
+                             _external=True)
+
+        # 2. Delegate the path decision to the centralized logic.
+        try:
+            return self._handle_login_path(company, user_identifier, target_url)
+        except Exception as e:
+            return render_template("error.html",
+            company_short_name=company_short_name,
+            branding=branding_data,
+            message=f"Error processing login path: {str(e)}"), 500
+
+
+class FinalizeContextView(MethodView):
+    """
+    Finalizes context loading in the slow path.
+    This view is invoked by the iframe inside onboarding_shell.html.
+    """
+    @inject
+    def __init__(self,
+                 profile_service: ProfileService,
+                 auth_service: AuthService,
+                 query_service: QueryService,
+                 prompt_service: PromptService,
+                 branding_service: BrandingService,
+                 onboarding_service: OnboardingService,
+                 jwt_service: JWTService,
+                 ):
+        self.profile_service = profile_service
+        self.jwt_service = jwt_service
+        self.query_service = query_service
+        self.prompt_service = prompt_service
+        self.branding_service = branding_service
+        self.onboarding_service = onboarding_service
+
+    def get(self, company_short_name: str, token: str = None):
+        session_info = self.profile_service.get_current_session_info()
+        if session_info:
+            # session exists, internal user
+            user_identifier = session_info.get('user_identifier')
+            token = ''
+        elif token:
+            # user identified by api-key
+            payload = self.jwt_service.validate_chat_jwt(token)
+            if not payload:
+                logging.warning("Fallo crítico: No se pudo leer el auth token.")
+                return redirect(url_for('index', company_short_name=company_short_name))
+
+            user_identifier = payload.get('user_identifier')
+        else:
+            logging.warning("Fallo crítico: missing session information or auth token")
+            return redirect(url_for('index', company_short_name=company_short_name))
 
-    def post(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',
+                        company_short_name=company_short_name,
+                        message="Empresa no encontrada"), 404
+        branding_data = self.branding_service.get_company_branding(company)
 
-        email = request.form.get('email')
         try:
-            password = request.form.get('password')
+            # 2. Finalize the context rebuild (the heavy task).
+            self.query_service.finalize_context_rebuild(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier
+            )
+
+            # 3. render the chat page.
+            prompts = self.prompt_service.get_user_prompts(company_short_name)
+            onboarding_cards = self.onboarding_service.get_onboarding_cards(company)
 
-            response = self.profile_service.login(
+            return render_template(
+                "chat.html",
                 company_short_name=company_short_name,
-                email=email,
-                password=password
-                )
-
-            if "error" in response:
-                return render_template(
-                'login.html',
-                                    company_short_name=company_short_name,
-                                    company=company,
-                                    form_data={
-                                           "email": email,
-                                           "password": password,
-                                       },
-                                    alert_message=response["error"]), 400
-
-            return redirect(url_for('chat', company_short_name=company_short_name))
+                user_identifier=user_identifier,
+                branding=branding_data,
+                prompts=prompts,
+                onboarding_cards=onboarding_cards,
+                redeem_token=token
+            )
 
         except Exception as e:
             return render_template("error.html",
-                                   company=company,
                                    company_short_name=company_short_name,
-                                   message="Ha ocurrido un error inesperado."), 500
+                                   branding=branding_data,
+                                   message=f"An unexpected error occurred during context loading: {str(e)}"), 500
 

iatoolkit/views/logout_api_view.py

@@ -0,0 +1,45 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask.views import MethodView
+from flask import redirect, url_for, jsonify
+from injector import inject
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.common.session_manager import SessionManager
+
+
+class LogoutApiView(MethodView):
+    @inject
+    def __init__(self,
+                 profile_service: ProfileService,
+                 auth_service: AuthService):
+        self.profile_service = profile_service
+        self.auth_service = auth_service
+
+    def get(self, company_short_name: str = None):
+        # 1. Get the authenticated user's
+        auth_result = self.auth_service.verify(anonymous=True)
+        if not auth_result.get("success"):
+            return jsonify(auth_result), auth_result.get("status_code", 401)
+
+        company = self.profile_service.get_company_by_short_name(company_short_name)
+        if not company:
+            return jsonify({"error": "Empresa no encontrada"}), 404
+
+        # get URL for redirection
+        url_for_redirect = company.parameters.get('external_urls', {}).get('logout_url')
+        if not url_for_redirect:
+            url_for_redirect = url_for('home', company_short_name=company_short_name)
+
+        # clear de session cookie
+        SessionManager.clear()
+
+        return {
+            'status': 'success',
+            'url': url_for_redirect,
+        }
+
+

iatoolkit/views/{prompt_view.py → prompt_api_view.py}

@@ -6,24 +6,24 @@
 from flask import jsonify
 from flask.views import MethodView
 from iatoolkit.services.prompt_manager_service import PromptService
-from iatoolkit.common.auth import IAuthentication
+from iatoolkit.services.auth_service import AuthService
 from injector import inject
 import logging
 
 
-class PromptView(MethodView):
+class PromptApiView(MethodView):
     @inject
     def __init__(self,
-                 iauthentication: IAuthentication,
+                 auth_service: AuthService,
                  prompt_service: PromptService ):
-        self.iauthentication = iauthentication
+        self.auth_service = auth_service
         self.prompt_service = prompt_service
 
     def get(self, company_short_name):
         # get access credentials
-        iaut = self.iauthentication.verify(company_short_name)
-        if not iaut.get("success"):
-            return jsonify(iaut), 401
+        auth_result = self.auth_service.verify(anonymous=True)
+        if not auth_result.get("success"):
+            return jsonify(auth_result), auth_result.get('status_code')
 
         try:
             response = self.prompt_service.get_user_prompts(company_short_name)

iatoolkit/views/signup_view.py

@@ -4,18 +4,20 @@
 # IAToolkit is open source software.
 
 from flask.views import MethodView
-from flask import render_template
+from flask import render_template, request, url_for, session, redirect
 from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.branding_service import BrandingService # 1. Importar BrandingService
 from injector import inject
 from itsdangerous import URLSafeTimedSerializer
-from flask import url_for, request
 import os
 
 
 class SignupView(MethodView):
     @inject
-    def __init__(self, profile_service: ProfileService):
+    def __init__(self, profile_service: ProfileService,
+                 branding_service: BrandingService):
         self.profile_service = profile_service
+        self.branding_service = branding_service # 3. Guardar la instancia
         self.serializer = URLSafeTimedSerializer(os.getenv("USER_VERIF_KEY"))
 
 
@@ -23,21 +25,27 @@ class SignupView(MethodView):
         # 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',
+                            company_short_name=company_short_name,
+                            message="Empresa no encontrada"), 404
+
+        # Obtener los datos de branding
+        branding_data = self.branding_service.get_company_branding(company)
 
-        user_agent = request.user_agent
-        is_mobile = user_agent.platform in ["android", "iphone", "ipad"] or "mobile" in user_agent.string.lower()
         return render_template('signup.html',
                                company=company,
                                company_short_name=company_short_name,
-                               is_mobile=is_mobile)
+                               branding=branding_data)
 
     def post(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',
+                        company_short_name=company_short_name,
+                        message="Empresa no encontrada"), 404
 
+        branding_data = self.branding_service.get_company_branding(company)
         try:
             first_name = request.form.get('first_name')
             last_name = request.form.get('last_name')
@@ -60,28 +68,29 @@ class SignupView(MethodView):
 
             if "error" in response:
                 return render_template(
-                'signup.html',
-                                    company=company,
-                                    company_short_name=company_short_name,
-                                    form_data={
-                                           "first_name": first_name,
-                                           "last_name": last_name,
-                                           "email": email,
-                                            "password": password,
-                                            "confirm_password": confirm_password
-                                       },
-                                    alert_message=response["error"]), 400
-
-            # all is OK
-            return render_template(
-                'login.html',
-                            company=company,
-                            company_short_name=company_short_name,
-                                   alert_icon='success',
-                                   alert_message=response["message"]), 200
+                    'signup.html',
+                    company=company,
+                    company_short_name=company_short_name,
+                    branding=branding_data,
+                    form_data={
+                        "first_name": first_name,
+                        "last_name": last_name,
+                        "email": email,
+                        "password": password,
+                        "confirm_password": confirm_password
+                    },
+                    alert_message=response["error"]), 400
+
+            # Guardamos el mensaje de éxito en la sesión
+            session['alert_message'] = response["message"]
+            session['alert_icon'] = 'success'
+
+            # Redirigimos al usuario a la página de login
+            return redirect(url_for('home', company_short_name=company_short_name))
+
         except Exception as e:
             return render_template("error.html",
-                                   company=company,
                                    company_short_name=company_short_name,
-                                   message="Ha ocurrido un error inesperado."), 500
+                                   branding=branding_data,
+                                   message=f"Ha ocurrido un error inesperado: {str(e)}"), 500
 

iatoolkit/views/{tasks_view.py → tasks_api_view.py}

@@ -7,54 +7,28 @@ from flask.views import MethodView
 from flask import request, jsonify
 from iatoolkit.services.tasks_service import TaskService
 from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.services.auth_service import AuthService
 from injector import inject
 from datetime import datetime
 import logging
 from typing import Optional
 
 
-class TaskView(MethodView):
+class TaskApiView(MethodView):
     @inject
-    def __init__(self, task_service: TaskService, profile_repo: ProfileRepo):
+    def __init__(self,
+                 auth_service: AuthService,
+                 task_service: TaskService,
+                 profile_repo: ProfileRepo):
+        self.auth_service = auth_service
         self.task_service = task_service
         self.profile_repo = profile_repo
 
-    def _authenticate_requesting_company_via_api_key(self) -> tuple[
-        Optional[int], Optional[str], Optional[tuple[dict, int]]]:
-        """
-        Autentica a la compañía  usando su API Key.
-        Retorna (company_id, company_short_name, None) en éxito.
-        Retorna (None, None, (error_json, status_code)) en fallo.
-        """
-        api_key_header = request.headers.get('Authorization')
-        if not api_key_header or not api_key_header.startswith('Bearer '):
-            return None, None, ({"error": "API Key faltante o mal formada en el header Authorization"}, 401)
-
-        api_key_value = api_key_header.split('Bearer ')[1]
-        try:
-            api_key_entry = self.profile_repo.get_active_api_key_entry(api_key_value)
-            if not api_key_entry:
-                return None, None, ({"error": "API Key inválida o inactiva"}, 401)
-
-            # api_key_entry.company ya está cargado por joinedload en get_active_api_key_entry
-            if not api_key_entry.company:  # Sanity check
-                logging.error(
-                    f"ChatTokenRequest: API Key {api_key_value[:5]}... no tiene compañía asociada a pesar de ser válida.")
-                return None, None, ({"error": "Error interno del servidor al verificar API Key"}, 500)
-
-            return api_key_entry.company_id, api_key_entry.company.short_name, None
-
-        except Exception as e:
-            logging.exception(f"ChatTokenRequest: Error interno durante validación de API Key: {e}")
-            return None, None, ({"error": "Error interno del servidor al validar API Key"}, 500)
-
-
     def post(self):
         try:
-            # only requests with valid api-key are allowed
-            auth_company_id, auth_company_short_name, error = self._authenticate_requesting_company_via_api_key()
-            if error:
-                return jsonify(error[0]), error[1]
+            auth_result = self.auth_service.verify(anonymous=True)
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
 
             req_data = request.get_json()
             files = request.files.getlist('files')

iatoolkit/views/tasks_review_api_view.py

@@ -0,0 +1,55 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask.views import MethodView
+from flask import request, jsonify
+from iatoolkit.services.tasks_service import TaskService
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.services.auth_service import AuthService
+from injector import inject
+import logging
+from typing import Optional
+
+
+class TaskReviewApiView(MethodView):
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 task_service: TaskService,
+                 profile_repo: ProfileRepo):
+        self.auth_service = auth_service
+        self.task_service = task_service
+        self.profile_repo = profile_repo
+
+    def post(self, task_id: int):
+        auth_result = self.auth_service.verify(anonymous=True)
+        if not auth_result.get("success"):
+            return jsonify(auth_result), auth_result.get("status_code")
+
+        try:
+            req_data = request.get_json()
+            required_fields = ['review_user', 'approved']
+            for field in required_fields:
+                if field not in req_data:
+                    return jsonify({"error": f"El campo {field} es requerido"}), 400
+
+            review_user = req_data.get('review_user', '')
+            approved = req_data.get('approved', False)
+            comment = req_data.get('comment', '')
+
+            new_task = self.task_service.review_task(
+                task_id=task_id,
+                review_user=review_user,
+                approved=approved,
+                comment=comment)
+
+            return jsonify({
+                "task_id": new_task.id,
+                "status": new_task.status.name
+            }), 200
+
+        except Exception as e:
+            logging.exception("Error al revisar la tarea: %s", str(e))
+            return jsonify({"error": str(e)}), 500

iatoolkit/views/{user_feedback_view.py → user_feedback_api_view.py}

@@ -3,59 +3,47 @@
 #
 # IAToolkit is open source software.
 
-from flask import request, jsonify, render_template
+from flask import request, jsonify
 from flask.views import MethodView
 from iatoolkit.services.user_feedback_service import UserFeedbackService
-from iatoolkit.common.auth import IAuthentication
+from iatoolkit.services.auth_service import AuthService
 from injector import inject
 import logging
 
 
-class UserFeedbackView(MethodView):
+class UserFeedbackApiView(MethodView):
     @inject
     def __init__(self,
-                 iauthentication: IAuthentication,
+                 auth_service: AuthService,
                  user_feedback_service: UserFeedbackService ):
-        self.iauthentication = iauthentication
+        self.auth_service = auth_service
         self.user_feedback_service = user_feedback_service
 
     def post(self, company_short_name):
+        # get access credentials
+        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')
+
         data = request.get_json()
         if not data:
-            return jsonify({"error_message": "Cuerpo de la solicitud JSON inválido o faltante"}), 400
-
-        # get access credentials
-        iaut = self.iauthentication.verify(company_short_name, data.get("external_user_id"))
-        if not iaut.get("success"):
-            return jsonify(iaut), 401
+            return jsonify({"error_message": "Cuerpo de la solicitud JSON inválido o faltante"}), 402
 
         message = data.get("message")
         if not message:
             return jsonify({"error_message": "Falta el mensaje de feedback"}), 400
         
-        space = data.get("space")
-        if not space:
-            return jsonify({"error_message": "Falta el espacio de Google Chat"}), 400
-        
-        type = data.get("type")
-        if not type:
-            return jsonify({"error_message": "Falta el tipo de feedback"}), 400
-        
         rating = data.get("rating")
         if not rating:
             return jsonify({"error_message": "Falta la calificación"}), 400
 
-        external_user_id = data.get("external_user_id")
-        local_user_id = data.get("local_user_id", 0)
-
         try:
             response = self.user_feedback_service.new_feedback(
                 company_short_name=company_short_name,
                 message=message,
-                external_user_id=external_user_id,
-                local_user_id=local_user_id,
-                space=space,
-                type=type,
+                user_identifier=user_identifier,
                 rating=rating
             )
 
@@ -66,9 +54,6 @@ class UserFeedbackView(MethodView):
         except Exception as e:
             logging.exception(
                 f"Error inesperado al procesar feedback para company {company_short_name}: {e}")
-            if local_user_id:
-                return render_template("error.html",
-                                       message="Ha ocurrido un error inesperado."), 500
-            else:
-                return jsonify({"error_message": str(e)}), 500
+
+            return jsonify({"error_message": str(e)}), 500
 

iatoolkit/views/verify_user_view.py

@@ -4,17 +4,19 @@
 # IAToolkit is open source software.
 
 from flask.views import MethodView
-from flask import render_template
+from flask import render_template, url_for, redirect, session
 from iatoolkit.services.profile_service import ProfileService
 from itsdangerous import URLSafeTimedSerializer, SignatureExpired
+from iatoolkit.services.branding_service import BrandingService  # ¡Importante!
 from injector import inject
 import os
 
 
 class VerifyAccountView(MethodView):
     @inject
-    def __init__(self, profile_service: ProfileService):
+    def __init__(self, profile_service: ProfileService, branding_service: BrandingService):
         self.profile_service = profile_service
+        self.branding_service = branding_service
         self.serializer = URLSafeTimedSerializer(os.getenv("USER_VERIF_KEY"))
 
     def get(self, company_short_name: str, token: str):
@@ -23,6 +25,7 @@ class VerifyAccountView(MethodView):
         if not company:
             return render_template('error.html', message="Empresa no encontrada"), 404
 
+        branding_data = self.branding_service.get_company_branding(company)
         try:
             # decode the token from the URL
             email = self.serializer.loads(token, salt='email-confirm', max_age=3600*5)
@@ -30,6 +33,7 @@ class VerifyAccountView(MethodView):
             return render_template('signup.html',
                                    company=company,
                                    company_short_name=company_short_name,
+                                   branding=branding_data,
                                    token=token,
                                    alert_message="El enlace de verificación ha expirado. Por favor, solicita uno nuevo."), 400
 
@@ -40,16 +44,17 @@ class VerifyAccountView(MethodView):
                     'signup.html',
                     company=company,
                     company_short_name=company_short_name,
+                    branding=branding_data,
                     token=token,
                     alert_message=response["error"]), 400
 
-            return render_template('login.html',
-                                   company=company,
-                                   company_short_name=company_short_name,
-                                   alert_icon='success',
-                                   alert_message=response['message'])
+            # Guardamos el mensaje y el icono en la sesión manualmente
+            session['alert_message'] = response['message']
+            session['alert_icon'] = "success"
+            return redirect(url_for('home', company_short_name=company_short_name))
+
         except Exception as e:
             return render_template("error.html",
-                                   company=company,
                                    company_short_name=company_short_name,
+                                   branding=branding_data,
                                    message="Ha ocurrido un error inesperado."), 500

{iatoolkit-0.8.1.dist-info → iatoolkit-0.63.4.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 0.8.1
+Version: 0.63.4
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: aiohappyeyeballs==2.4.4
 Requires-Dist: aiohttp==3.11.9