iatoolkit 0.63.1__py3-none-any.whl → 0.67.0__py3-none-any.whl

iatoolkit/services/history_service.py

@@ -6,32 +6,33 @@
 from injector import inject
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.services.i18n_service import I18nService
+
 
 
 class HistoryService:
     @inject
     def __init__(self, llm_query_repo: LLMQueryRepo,
-                 profile_repo: ProfileRepo):
+                 profile_repo: ProfileRepo,
+                 i18n_service: I18nService):
         self.llm_query_repo = llm_query_repo
         self.profile_repo = profile_repo
+        self.i18n_service = i18n_service
 
     def get_history(self,
                      company_short_name: str,
                      user_identifier: str) -> dict:
         try:
-            # validate company
             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}'}
+                return {"error": self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
             history = self.llm_query_repo.get_history(company, user_identifier)
-
             if not history:
-                return {'message': 'Historial vacio actualmente', 'history': []}
+                return {'message': 'empty history', 'history': []}
 
             history_list = [query.to_dict() for query in history]
-
-            return {'message': 'Historial obtenido correctamente', 'history': history_list}
+            return {'message': 'history loaded ok', 'history': history_list}
 
         except Exception as e:
             return {'error': str(e)}

iatoolkit/services/i18n_service.py

@@ -0,0 +1,104 @@
+# iatoolkit/services/i18n_service.py
+import os
+import logging
+from injector import inject, singleton
+from iatoolkit.common.util import Utility
+from iatoolkit.services.language_service import LanguageService
+
+@singleton
+class I18nService:
+    """
+    Servicio centralizado para manejar la internacionalización (i18n).
+    Carga todas las traducciones desde archivos YAML en memoria al iniciar.
+    """
+    FALLBACK_LANGUAGE = 'es'
+
+    @inject
+    def __init__(self, util: Utility, language_service: LanguageService):
+        self.util = util
+        self.language_service = language_service
+
+        self.translations = {}
+        self._load_translations()
+
+    def _load_translations(self):
+        """
+        Carga todos los archivos .yaml del directorio 'locales' en memoria.
+        """
+        locales_dir = os.path.join(os.path.dirname(__file__), '..', 'locales')
+        if not os.path.exists(locales_dir):
+            logging.error("Directory 'locales' not found.")
+            return
+
+        for filename in os.listdir(locales_dir):
+            if filename.endswith('.yaml'):
+                lang_code = filename.split('.')[0]
+                filepath = os.path.join(locales_dir, filename)
+                try:
+                    self.translations[lang_code] = self.util.load_schema_from_yaml(filepath)
+                except Exception as e:
+                    logging.error(f"Error while loading the translation file {filepath}: {e}")
+
+    def _get_nested_key(self, lang: str, key: str):
+        """
+        Obtiene un valor de un diccionario anidado usando una clave con puntos.
+        """
+        data = self.translations.get(lang, {})
+        keys = key.split('.')
+        for k in keys:
+            if isinstance(data, dict) and k in data:
+                data = data[k]
+            else:
+                return None
+        return data
+
+    def get_translation_block(self, key: str, lang: str = None) -> dict:
+        """
+        Gets a whole dictionary block from the translations.
+        Useful for passing a set of translations to JavaScript.
+        """
+        if lang is None:
+            lang = self.language_service.get_current_language()
+
+        # 1. Try to get the block in the requested language
+        block = self._get_nested_key(lang, key)
+
+        # 2. If not found, try the fallback language
+        if not isinstance(block, dict):
+            block = self._get_nested_key(self.FALLBACK_LANGUAGE, key)
+
+        return block if isinstance(block, dict) else {}
+
+    def t(self, key: str, lang: str = None, **kwargs) -> str:
+        """
+        Gets the translation for a given key.
+        If 'lang' is provided, it's used. Otherwise, it's determined automatically.
+        """
+        # If no specific language is requested, determine it from the current context.
+        if lang is None:
+            lang = self.language_service.get_current_language()
+
+        # 1. Attempt to get the translation in the requested language
+        message = self._get_nested_key(lang, key)
+
+        # 2. If not found, try the fallback language
+        if message is None and lang != self.FALLBACK_LANGUAGE:
+            logging.warning(
+                f"Translation key '{key}' not found for language '{lang}'. Attempting fallback to '{self.FALLBACK_LANGUAGE}'.")
+            message = self._get_nested_key(self.FALLBACK_LANGUAGE, key)
+
+        # 3. If still not found, return the key itself as a last resort
+        if message is None:
+            logging.error(
+                f"Translation key '{key}' not found, even in fallback '{self.FALLBACK_LANGUAGE}'.")
+            return key
+
+        # 4. If variables are provided, format the message
+        if kwargs:
+            try:
+                return message.format(**kwargs)
+            except KeyError as e:
+                logging.error(f"Error formatting key '{key}': missing variable {e} in arguments.")
+                return message
+
+        return message

iatoolkit/services/jwt_service.py

@@ -20,8 +20,8 @@ class JWTService:
             self.secret_key = app.config['JWT_SECRET_KEY']
             self.algorithm = app.config['JWT_ALGORITHM']
         except KeyError as e:
-            logging.error(f"Configuración JWT faltante en app.config: {e}. JWTService no funcionará correctamente.")
-            raise RuntimeError(f"Configuración JWT esencial faltante: {e}")
+            logging.error(f"missing JWT configuration: {e}.")
+            raise RuntimeError(f"missing JWT configuration variables: {e}")
 
     def generate_chat_jwt(self,
                           company_short_name: str,
@@ -58,25 +58,23 @@ class JWTService:
 
             # Validaciones adicionales
             if payload.get('type') != 'chat_session':
-                logging.warning(f"Validación JWT fallida: tipo incorrecto '{payload.get('type')}'")
+                logging.warning(f"Invalid JWT type '{payload.get('type')}'")
                 return None
 
             # user_identifier debe estar presente
             if not payload.get('user_identifier'):
-                logging.warning(f"Validación JWT fallida: user_identifier ausente o vacío.")
+                logging.warning(f"missing user_identifier in JWT payload.")
                 return None
 
             if not payload.get('company_short_name'):
-                logging.warning(f"Validación JWT fallida: company_short_name ausente.")
+                logging.warning(f"missing company_short_name in JWT payload.")
                 return None
 
-            logging.debug(
-                f"JWT validado exitosamente para company: {payload.get('company_short_name')}, user: {payload.get('external_user_id')}")
             return payload
 
         except jwt.InvalidTokenError as e:
-            logging.warning(f"Validación JWT fallida: token inválido . Error: {e}")
+            logging.warning(f"Invalid JWT token:: {e}")
             return None
         except Exception as e:
-            logging.error(f"Error inesperado durante validación de JWT : {e}")
+            logging.error(f"unexpected error during JWT validation: {e}")
             return None

iatoolkit/services/language_service.py

@@ -0,0 +1,79 @@
+# iatoolkit/services/language_service.py
+
+import logging
+from injector import inject, singleton
+from flask import g, request
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.common.session_manager import SessionManager
+
+@singleton
+class LanguageService:
+    """
+    Determines the correct language for the current request
+    based on a defined priority order (session, URL, etc.)
+    and caches it in the Flask 'g' object for the request's lifecycle.
+    """
+
+    FALLBACK_LANGUAGE = 'es'
+
+    @inject
+    def __init__(self, profile_repo: ProfileRepo):
+        self.profile_repo = profile_repo
+
+    def _get_company_short_name(self) -> str | None:
+        """
+        Gets the company_short_name from the current request context.
+        This handles different scenarios like web sessions, public URLs, and API calls.
+
+        Priority Order:
+        1. Flask Session (for logged-in web users).
+        2. URL rule variable (for public pages and API endpoints).
+        """
+        # 1. Check session for logged-in users
+        company_short_name = SessionManager.get('company_short_name')
+        if company_short_name:
+            return company_short_name
+
+        # 2. Check URL arguments (e.g., /<company_short_name>/login)
+        # This covers public pages and most API calls.
+        if request.view_args and 'company_short_name' in request.view_args:
+            return request.view_args['company_short_name']
+
+        return None
+
+    def get_current_language(self) -> str:
+        """
+        Determines and caches the language for the current request using a priority order:
+        1. User's preference (from their profile).
+        2. Company's default language.
+        3. System-wide fallback language ('es').
+        """
+        if 'lang' in g:
+            return g.lang
+
+        try:
+            # Priority 1: User's preferred language
+            user_identifier = SessionManager.get('user_identifier')
+            if user_identifier:
+                user = self.profile_repo.get_user_by_email(user_identifier)
+                if user and user.preferred_language:
+                    logging.debug(f"Language determined by user preference: {user.preferred_language}")
+                    g.lang = user.preferred_language
+                    return g.lang
+
+            # Priority 2: Company's default language
+            company_short_name = self._get_company_short_name()
+            if company_short_name:
+                company = self.profile_repo.get_company_by_short_name(company_short_name)
+                if company and company.default_language:
+                    logging.debug(f"Language determined by company default: {company.default_language}")
+                    g.lang = company.default_language
+                    return g.lang
+        except Exception as e:
+            logging.info(f"Could not determine language, falling back to default. Reason: {e}")
+            pass
+
+        # Priority 3: System-wide fallback
+        logging.info(f"Language determined by system fallback: {self.FALLBACK_LANGUAGE}")
+        g.lang = self.FALLBACK_LANGUAGE
+        return g.lang

iatoolkit/services/load_documents_service.py

@@ -72,7 +72,7 @@ class LoadDocumentsService:
         """
         if not connector_config:
             raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER,
-                        f"Falta configurar conector")
+                        f"Missing connector config")
 
         try:
             if not filters:
@@ -123,7 +123,7 @@ class LoadDocumentsService:
 
         if not company:
             raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER,
-                        f"Falta configurar empresa")
+                        f"missing company")
 
         # check if file exist in repositories
         if self.doc_repo.get(company_id=company.id,filename=filename):
@@ -182,6 +182,6 @@ class LoadDocumentsService:
             self.doc_repo.session.rollback()
 
             # if something fails, throw exception
-            logging.exception("Error procesando el archivo %s: %s", filename, str(e))
+            logging.exception("Error processing file %s: %s", filename, str(e))
             raise IAToolkitException(IAToolkitException.ErrorType.LOAD_DOCUMENT_ERROR,
-                               f"Error al procesar el archivo {filename}")
+                               f"Error while processing file: {filename}")

iatoolkit/services/mail_service.py

@@ -4,6 +4,7 @@
 # IAToolkit is open source software.
 
 from iatoolkit.infra.mail_app import MailApp
+from iatoolkit.services.i18n_service import I18nService
 from injector import inject
 from pathlib import Path
 from iatoolkit.common.exceptions import IAToolkitException
@@ -13,18 +14,22 @@ TEMP_DIR = Path("static/temp")
 
 class MailService:
     @inject
-    def __init__(self, mail_app: MailApp):
+    def __init__(self,
+                 mail_app: MailApp,
+                 i18n_service: I18nService):
         self.mail_app = mail_app
+        self.i18n_service = i18n_service
+
 
     def _read_token_bytes(self, token: str) -> bytes:
         # Defensa simple contra path traversal
         if not token or "/" in token or "\\" in token or token.startswith("."):
             raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
-                               "attachment_token inválido")
+                               "attachment_token invalid")
         path = TEMP_DIR / token
         if not path.is_file():
             raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
-                               f"Adjunto no encontrado: {token}")
+                               f"attach file not found: {token}")
         return path.read_bytes()
 
     def send_mail(self, **kwargs):
@@ -59,4 +64,4 @@ class MailService:
             body=body,
             attachments=norm_attachments)
 
-        return 'mail enviado'
+        return self.i18n_service.t('services.mail_sent')

iatoolkit/services/onboarding_service.py

@@ -4,7 +4,9 @@
 # IAToolkit is open source software.
 
 from iatoolkit.repositories.models import Company
+from iatoolkit.services.configuration_service import ConfigurationService
 from typing import List, Dict, Any
+from injector import inject
 
 
 class OnboardingService:
@@ -12,11 +14,13 @@ class OnboardingService:
     Servicio para gestionar las tarjetas de contenido que se muestran
     durante la pantalla de carga (onboarding).
     """
-
-    def __init__(self):
+    @inject
+    def __init__(self, config_service: ConfigurationService):
         """
         Define el conjunto de tarjetas de onboarding por defecto.
         """
+        self.config_service = config_service
+
         self._default_cards = [
             {'icon': 'fas fa-users', 'title': 'Clientes',
              'text': 'Conozco en detalle a nuestros clientes: antigüedad, contactos, historial de operaciones.<br><br><strong>Ejemplo:</strong> ¿cuántos clientes nuevos se incorporaron a mi cartera este año?'},
@@ -37,7 +41,9 @@ class OnboardingService:
         Si la compañía tiene tarjetas personalizadas, las devuelve.
         De lo contrario, devuelve las tarjetas por defecto.
         """
-        if company and company.onboarding_cards:
-            return company.onboarding_cards
+        if company:
+            onboarding_cards = self.config_service.get_company_content(company.short_name, 'onboarding_cards')
+
+            return onboarding_cards
 
         return self._default_cards

iatoolkit/services/profile_service.py

@@ -5,7 +5,7 @@
 
 from injector import inject
 from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.services.dispatcher_service import Dispatcher
+from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.repositories.models import User, Company, ApiKey
 from flask_bcrypt import check_password_hash
 from iatoolkit.common.session_manager import SessionManager
@@ -16,16 +16,19 @@ import random
 import re
 import secrets
 import string
+import logging
 from iatoolkit.services.dispatcher_service import Dispatcher
 
 
 class ProfileService:
     @inject
     def __init__(self,
+                 i18n_service: I18nService,
                  profile_repo: ProfileRepo,
                  session_context_service: UserSessionContextService,
                  dispatcher: Dispatcher,
                  mail_app: MailApp):
+        self.i18n_service = i18n_service
         self.profile_repo = profile_repo
         self.dispatcher = dispatcher
         self.session_context = session_context_service
@@ -38,23 +41,23 @@ class ProfileService:
             # check if user exists
             user = self.profile_repo.get_user_by_email(email)
             if not user:
-                return {'success': False, "message": "Usuario no encontrado"}
+                return {'success': False, 'message': self.i18n_service.t('errors.auth.user_not_found')}
 
             # check the encrypted password
             if not check_password_hash(user.password, password):
-                return {'success': False, "message": "Contraseña inválida"}
+                return {'success': False, 'message': self.i18n_service.t('errors.auth.invalid_password')}
 
             company = self.profile_repo.get_company_by_short_name(company_short_name)
             if not company:
-                return {'success': False, "message": "Empresa no encontrada"}
+                return {'success': False, "message": "missing company"}
 
             # check that user belongs to company
             if company not in user.companies:
-                return {'success': False, "message": "Usuario no esta autorizado para esta empresa"}
+                return {'success': False, "message": self.i18n_service.t('errors.services.user_not_authorized')}
 
             if not user.verified:
                 return {'success': False,
-                        "message": "Tu cuenta no ha sido verificada. Por favor, revisa tu correo."}
+                        "message": self.i18n_service.t('errors.services.account_not_verified')}
 
             # 1. Build the local user profile dictionary here.
             # the user_profile variables are used on the LLM templates also (see in query_main.prompt)
@@ -71,8 +74,9 @@ class ProfileService:
 
             # 3. create the web session
             self.set_session_for_user(company.short_name, user_identifier)
-            return {'success': True, "user_identifier": user_identifier, "message": "Login exitoso"}
+            return {'success': True, "user_identifier": user_identifier, "message": "Login ok"}
         except Exception as e:
+            logging.error(f"Error in login: {e}")
             return {'success': False, "message": str(e)}
 
     def create_external_user_profile_context(self, company: Company, user_identifier: str):
@@ -131,6 +135,24 @@ class ProfileService:
             "profile": profile
         }
 
+    def update_user_language(self, user_identifier: str, new_lang: str) -> dict:
+        """
+        Business logic to update a user's preferred language.
+        It validates the language and then calls the generic update method.
+        """
+        # 1. Validate that the language is supported by checking the loaded translations.
+        if new_lang not in self.i18n_service.translations:
+            return {'success': False, 'error_message': self.i18n_service.t('errors.general.unsupported_language')}
+
+        try:
+            # 2. Call the generic update_user method, passing the specific field to update.
+            self.update_user(user_identifier, preferred_language=new_lang)
+            return {'success': True, 'message': 'Language updated successfully.'}
+        except Exception as e:
+            # Log the error and return a generic failure message.
+            logging.error(f"Failed to update language for {user_identifier}: {e}")
+            return {'success': False, 'error_message': self.i18n_service.t('errors.general.unexpected_error', error=str(e))}
+
 
     def get_profile_by_identifier(self, company_short_name: str, user_identifier: str) -> dict:
         """
@@ -155,7 +177,8 @@ class ProfileService:
             # get company info
             company = self.profile_repo.get_company_by_short_name(company_short_name)
             if not company:
-                return {"error": f"la empresa {company_short_name} no existe"}
+                return {
+                    "error": self.i18n_service.t('errors.signup.company_not_found', company_name=company_short_name)}
 
             # normalize  format's
             email = email.lower()
@@ -165,24 +188,25 @@ class ProfileService:
             if existing_user:
                 # validate password
                 if not self.bcrypt.check_password_hash(existing_user.password, password):
-                    return {"error": "La contraseña es incorrecta. No se puede agregar a la nueva empresa."}
+                    return {"error": self.i18n_service.t('errors.signup.incorrect_password_for_existing_user', email=email)}
 
                 # check if register
                 if company in existing_user.companies:
-                    return {"error": "Usuario ya registrado en esta empresa"}
+                    return {"error": self.i18n_service.t('errors.signup.user_already_registered', email=email)}
                 else:
                     # add new company to existing user
                     existing_user.companies.append(company)
                     self.profile_repo.save_user(existing_user)
-                    return {"message": "Usuario asociado a nueva empresa"}
+                    return {"message": self.i18n_service.t('flash_messages.user_associated_success')}
 
             # add the new user
             if password != confirm_password:
-                return {"error": "Las contraseñas no coinciden. Por favor, inténtalo de nuevo."}
+                return {"error": self.i18n_service.t('errors.signup.password_mismatch')}
 
             is_valid, message = self.validate_password(password)
             if not is_valid:
-                return {"error": message}
+                # Translate the key returned by validate_password
+                return {"error": self.i18n_service.t(message)}
 
             # encrypt the password
             hashed_password = self.bcrypt.generate_password_hash(password).decode('utf-8')
@@ -204,9 +228,9 @@ class ProfileService:
             # send email with verification
             self.send_verification_email(new_user, company_short_name)
 
-            return {"message": "Registro exitoso. Por favor, revisa tu correo para verificar tu cuenta."}
+            return {"message": self.i18n_service.t('flash_messages.signup_success')}
         except Exception as e:
-            return {"error": str(e)}
+            return {"error": self.i18n_service.t('errors.general.unexpected_error', error=str(e))}
 
     def update_user(self, email: str, **kwargs) -> User:
         return self.profile_repo.update_user(email, **kwargs)
@@ -216,14 +240,14 @@ class ProfileService:
             # check if user exist
             user = self.profile_repo.get_user_by_email(email)
             if not user:
-                return {"error": "El usuario no existe."}
+                return {"error": self.i18n_service.t('errors.verification.user_not_found')}
 
             # activate the user account
             self.profile_repo.verify_user(email)
-            return {"message": "Tu cuenta ha sido verificada exitosamente. Ahora puedes iniciar sesión."}
+            return {"message": self.i18n_service.t('flash_messages.account_verified_success')}
 
         except Exception as e:
-            return {"error": str(e)}
+            return {"error": self.i18n_service.t('errors.general.unexpected_error')}
 
     def change_password(self,
                          email: str,
@@ -232,28 +256,28 @@ class ProfileService:
                          confirm_password: str):
         try:
             if new_password != confirm_password:
-                return {"error": "Las contraseñas no coinciden. Por favor, inténtalo nuevamente."}
+                return {"error": self.i18n_service.t('errors.change_password.password_mismatch')}
 
             # check the temporary code
             user = self.profile_repo.get_user_by_email(email)
             if not user or user.temp_code != temp_code:
-                return {"error": "El código temporal no es válido. Por favor, verifica o solicita uno nuevo."}
+                return {"error": self.i18n_service.t('errors.change_password.invalid_temp_code')}
 
             # encrypt and save the password, make the temporary code invalid
             hashed_password = self.bcrypt.generate_password_hash(new_password).decode('utf-8')
             self.profile_repo.update_password(email, hashed_password)
             self.profile_repo.reset_temp_code(email)
 
-            return {"message": "La clave se cambio correctamente"}
+            return {"message": self.i18n_service.t('flash_messages.password_changed_success')}
         except Exception as e:
-            return {"error": str(e)}
+            return {"error": self.i18n_service.t('errors.general.unexpected_error')}
 
     def forgot_password(self, email: str, reset_url: str):
         try:
             # Verificar si el usuario existe
             user = self.profile_repo.get_user_by_email(email)
             if not user:
-                return {"error": "El usuario no existe."}
+                return {"error": self.i18n_service.t('errors.forgot_password.user_not_registered', email=email)}
 
             # Gen a temporary code and store in the repositories
             temp_code = ''.join(random.choices(string.ascii_letters + string.digits, k=6)).upper()
@@ -262,35 +286,31 @@ class ProfileService:
             # send email to the user
             self.send_forgot_password_email(user, reset_url)
 
-            return {"message": "se envio mail para cambio de clave"}
+            return {"message": self.i18n_service.t('flash_messages.forgot_password_success')}
         except Exception as e:
-            return {"error": str(e)}
+            return {"error": self.i18n_service.t('errors.general.unexpected_error')}
 
     def validate_password(self, password):
         """
-        Valida que una contraseña cumpla con los siguientes requisitos:
-        - Al menos 8 caracteres de longitud
-        - Contiene al menos una letra mayúscula
-        - Contiene al menos una letra minúscula
-        - Contiene al menos un número
-        - Contiene al menos un carácter especial
+        Validates that a password meets all requirements.
+        Returns (True, "...") on success, or (False, "translation.key") on failure.
         """
         if len(password) < 8:
-            return False, "La contraseña debe tener al menos 8 caracteres."
+            return False, "errors.validation.password_too_short"
 
         if not any(char.isupper() for char in password):
-            return False, "La contraseña debe tener al menos una letra mayúscula."
+            return False, "errors.validation.password_no_uppercase"
 
         if not any(char.islower() for char in password):
-            return False, "La contraseña debe tener al menos una letra minúscula."
+            return False, "errors.validation.password_no_lowercase"
 
         if not any(char.isdigit() for char in password):
-            return False, "La contraseña debe tener al menos un número."
+            return False, "errors.validation.password_no_digit"
 
         if not re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
-            return False, "La contraseña debe tener al menos un carácter especial."
+            return False, "errors.validation.password_no_special_char"
 
-        return True, "La contraseña es válida."
+        return True, "Password is valid."
 
     def get_companies(self):
         return self.profile_repo.get_companies()
@@ -304,7 +324,7 @@ class ProfileService:
     def new_api_key(self, company_short_name: str):
         company = self.get_company_by_short_name(company_short_name)
         if not company:
-            return {"error": f"la empresa {company_short_name} no existe"}
+            return {"error": self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
         length = 40     # lenght of the api key
         alphabet = string.ascii_letters + string.digits