iatoolkit 0.71.4__py3-none-any.whl → 0.91.1__py3-none-any.whl

iatoolkit/services/jwt_service.py

@@ -17,7 +17,7 @@ class JWTService:
     def __init__(self,  app: Flask):
         # Acceder a la configuración directamente desde app.config
         try:
-            self.secret_key = app.config['JWT_SECRET_KEY']
+            self.secret_key = app.config['IATOOLKIT_SECRET_KEY']
             self.algorithm = app.config['JWT_ALGORITHM']
         except KeyError as e:
             logging.error(f"missing JWT configuration: {e}.")

iatoolkit/services/language_service.py

@@ -48,6 +48,7 @@ class LanguageService:
     def get_current_language(self) -> str:
         """
         Determines and caches the language for the current request using a priority order:
+        0. Query parameter '?lang=<code>' (highest priority; e.g., 'en', 'es').
         1. User's preference (from their profile).
         2. Company's default language.
         3. System-wide fallback language ('es').
@@ -56,6 +57,12 @@ class LanguageService:
             return g.lang
 
         try:
+            # Priority 0: Explicit query parameter (?lang=)
+            lang_arg = request.args.get('lang')
+            if lang_arg:
+                g.lang = lang_arg
+                return g.lang
+
             # Priority 1: User's preferred language
             user_identifier = SessionManager.get('user_identifier')
             if user_identifier:
@@ -74,10 +81,9 @@ class LanguageService:
                     g.lang = company_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}")
+        logging.debug(f"Language determined by system fallback: {self.FALLBACK_LANGUAGE}")
         g.lang = self.FALLBACK_LANGUAGE
         return g.lang

iatoolkit/services/license_service.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import jwt
+import os
+import logging
+from pathlib import Path
+from iatoolkit.common.exceptions import IAToolkitException
+from injector import inject, singleton
+
+
+@singleton
+class LicenseService:
+    """
+    Manages system restrictions and features based on a license (JWT).
+    If no license or an invalid license is provided, Community Edition limits apply.
+    """
+    @inject
+    def __init__(self):
+        self.limits = self._load_limits()
+
+    def _load_limits(self):
+        # 1. Define default limits (Community Edition)
+        default_limits = {
+            "license_type": "Community Edition",
+            "plan": "Open Source (Community Edition)",
+            "max_companies": 1,
+            "max_tools": 3,
+            "features": {
+                "multi_tenant": False,
+                "rag_advanced": False,
+            }
+        }
+        return default_limits
+
+
+    # --- Information Getters ---
+    def get_license_type(self) -> str:
+        return self.limits.get("license_type", "Community Edition")
+
+    def get_plan_name(self) -> str:
+        return self.limits.get("plan", "Unknown")
+
+    def get_max_companies(self) -> int:
+        return self.limits.get("max_companies", 1)
+
+    def get_max_tools_per_company(self) -> int:
+        return self.limits.get("max_tools", 3)
+
+    def get_license_info(self) -> str:
+        return f"Plan: {self.get_plan_name()}, Companies: {self.get_max_companies()}, Tools: {self.get_max_tools_per_company()}"
+
+    # --- Restriction Validators ---
+
+    def validate_company_limit(self, current_count: int):
+        """Raises exception if the limit of active companies is exceeded."""
+        limit = self.get_max_companies()
+        # -1 means unlimited
+        if limit != -1 and current_count > limit:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.PERMISSION,
+                f"Company limit ({limit}) reached for plan '{self.get_plan_name()}'."
+            )
+
+
+    def validate_tool_config_limit(self, tools_config: list):
+        """Validates a configuration list before processing it."""
+        limit = self.get_max_tools_per_company()
+        if limit != -1 and len(tools_config) > limit:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.PERMISSION,
+                f"Configuration defines {len(tools_config)} tools, but limit is {limit}."
+            )
+
+    # --- Feature Gating Validators ---
+
+    def has_feature(self, feature_key: str) -> bool:
+        """Checks if a specific feature is enabled in the license."""
+        features = self.limits.get("features", {})
+        return features.get(feature_key, False)

iatoolkit/services/mail_service.py

@@ -3,43 +3,40 @@
 #
 # IAToolkit is open source software.
 
-from iatoolkit.infra.mail_app import MailApp
+from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.infra.brevo_mail_app import BrevoMailApp
 from injector import inject
 from pathlib import Path
-from iatoolkit.common.exceptions import IAToolkitException
 import base64
+import os
+import smtplib
+from email.message import EmailMessage
+from iatoolkit.common.exceptions import IAToolkitException
+
 
 TEMP_DIR = Path("static/temp")
 
 class MailService:
     @inject
     def __init__(self,
-                 mail_app: MailApp,
-                 i18n_service: I18nService):
+                 config_service: ConfigurationService,
+                 mail_app: BrevoMailApp,
+                 i18n_service: I18nService,
+                 brevo_mail_app: BrevoMailApp):
         self.mail_app = mail_app
+        self.config_service = config_service
         self.i18n_service = i18n_service
+        self.brevo_mail_app = brevo_mail_app
 
 
-    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 invalid")
-        path = TEMP_DIR / token
-        if not path.is_file():
-            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
-                               f"attach file not found: {token}")
-        return path.read_bytes()
-
-    def send_mail(self, **kwargs):
-        from_email = kwargs.get('from_email', 'iatoolkit@iatoolkit.com')
+    def send_mail(self, company_short_name: str, **kwargs):
         recipient = kwargs.get('recipient')
         subject = kwargs.get('subject')
         body = kwargs.get('body')
         attachments = kwargs.get('attachments')
 
-        # Normalizar a payload de MailApp (name + base64 content)
+        # Normalizar a payload de BrevoMailApp (name + base64 content)
         norm_attachments = []
         for a in attachments or []:
             if a.get("attachment_token"):
@@ -55,13 +52,162 @@ class MailService:
                     "content": a["content"]
                 })
 
-        self.sender = {"email": from_email, "name": "IAToolkit"}
+        # build provider configuration from company.yaml
+        provider, provider_config = self._build_provider_config(company_short_name)
+
+        # define the email sender
+        sender = {
+            "email": provider_config.get("sender_email"),
+            "name": provider_config.get("sender_name"),
+        }
 
-        response = self.mail_app.send_email(
-            sender=self.sender,
-            to=recipient,
-            subject=subject,
-            body=body,
-            attachments=norm_attachments)
+        # select provider and send the email through it
+        if provider == "brevo_mail":
+            response = self.brevo_mail_app.send_email(
+                provider_config=provider_config,
+                sender=sender,
+                to=recipient,
+                subject=subject,
+                body=body,
+                attachments=norm_attachments
+            )
+        elif provider == "smtplib":
+            response = self._send_with_smtplib(
+                provider_config=provider_config,
+                sender=sender,
+                recipient=recipient,
+                subject=subject,
+                body=body,
+                attachments=norm_attachments,
+            )
+            response = None
+        else:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.MAIL_ERROR,
+                f"Unknown mail provider '{provider}'"
+            )
 
         return self.i18n_service.t('services.mail_sent')
+
+    def _build_provider_config(self, company_short_name: str) -> tuple[str, dict]:
+        """
+        Determina el provider activo (brevo_mail / smtplib) y construye
+        el diccionario de configuración a partir de las variables de entorno
+        cuyos nombres están en company.yaml (mail_provider).
+        """
+        # get company mail configuration and provider
+        mail_config = self.config_service.get_configuration(company_short_name, "mail_provider")
+        provider = mail_config.get("provider", "brevo_mail")
+
+        # get mail common parameteres
+        sender_email = mail_config.get("sender_email")
+        sender_name = mail_config.get("sender_name")
+
+        # get parameters depending on provider
+        if provider == "brevo_mail":
+            brevo_cfg = mail_config.get("brevo_mail", {})
+            api_key_env = brevo_cfg.get("brevo_api", "BREVO_API_KEY")
+            return provider, {
+                "api_key": os.getenv(api_key_env),
+                "sender_name": sender_name,
+                "sender_email": sender_email,
+            }
+
+        if provider == "smtplib":
+            smtp_cfg = mail_config.get("smtplib", {})
+            host = os.getenv(smtp_cfg.get("host_env", "SMTP_HOST"))
+            port = os.getenv(smtp_cfg.get("port_env", "SMTP_PORT"))
+            username = os.getenv(smtp_cfg.get("username_env", "SMTP_USERNAME"))
+            password = os.getenv(smtp_cfg.get("password_env", "SMTP_PASSWORD"))
+            use_tls = os.getenv(smtp_cfg.get("use_tls_env", "SMTP_USE_TLS"))
+            use_ssl = os.getenv(smtp_cfg.get("use_ssl_env", "SMTP_USE_SSL"))
+
+            return provider, {
+                "host": host,
+                "port": int(port) if port is not None else None,
+                "username": username,
+                "password": password,
+                "use_tls": str(use_tls).lower() == "true",
+                "use_ssl": str(use_ssl).lower() == "true",
+                "sender_name": sender_name,
+                "sender_email": sender_email,
+            }
+
+        # Fallback simple si el provider no es reconocido
+        raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                                 f"missing mail provider in mail configuration for company '{company_short_name}'")
+
+    def _send_with_smtplib(self,
+                           provider_config: dict,
+                           sender: dict,
+                           recipient: str,
+                           subject: str,
+                           body: str,
+                           attachments: list[dict] | None):
+        """
+        Envía correo usando smtplib, utilizando la configuración normalizada
+        en provider_config.
+        """
+        host = provider_config.get("host")
+        port = provider_config.get("port")
+        username = provider_config.get("username")
+        password = provider_config.get("password")
+        use_tls = provider_config.get("use_tls")
+        use_ssl = provider_config.get("use_ssl")
+
+        if not host or not port:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.MAIL_ERROR,
+                "smtplib configuration is incomplete (host/port missing)"
+            )
+
+        msg = EmailMessage()
+        msg["From"] = f"{sender.get('name', '')} <{sender.get('email')}>"
+        msg["To"] = recipient
+        msg["Subject"] = subject
+        msg.set_content(body, subtype="html")
+
+        # Adjuntos: ya vienen como filename + base64 content
+        for a in attachments or []:
+            filename = a.get("filename")
+            content_b64 = a.get("content")
+            if not filename or not content_b64:
+                continue
+            try:
+                raw = base64.b64decode(content_b64, validate=True)
+            except Exception:
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.MAIL_ERROR,
+                    f"Invalid base64 for attachment '{filename}'"
+                )
+            msg.add_attachment(
+                raw,
+                maintype="application",
+                subtype="octet-stream",
+                filename=filename,
+            )
+
+        if use_ssl:
+            with smtplib.SMTP_SSL(host, port) as server:
+                if username and password:
+                    server.login(username, password)
+                server.send_message(msg)
+        else:
+            with smtplib.SMTP(host, port) as server:
+                if use_tls:
+                    server.starttls()
+                if username and password:
+                    server.login(username, password)
+                server.send_message(msg)
+
+
+    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 invalid")
+        path = TEMP_DIR / token
+        if not path.is_file():
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                               f"attach file not found: {token}")
+        return path.read_bytes()

iatoolkit/services/profile_service.py

@@ -9,9 +9,11 @@ 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
+from iatoolkit.services.language_service import LanguageService
 from iatoolkit.services.user_session_context_service import UserSessionContextService
+from iatoolkit.services.configuration_service import ConfigurationService
 from flask_bcrypt import Bcrypt
-from iatoolkit.infra.mail_app import MailApp
+from iatoolkit.services.mail_service import MailService
 import random
 import re
 import secrets
@@ -26,13 +28,17 @@ class ProfileService:
                  i18n_service: I18nService,
                  profile_repo: ProfileRepo,
                  session_context_service: UserSessionContextService,
+                 config_service: ConfigurationService,
+                 lang_service: LanguageService,
                  dispatcher: Dispatcher,
-                 mail_app: MailApp):
+                 mail_service: MailService):
         self.i18n_service = i18n_service
         self.profile_repo = profile_repo
         self.dispatcher = dispatcher
         self.session_context = session_context_service
-        self.mail_app = mail_app
+        self.config_service = config_service
+        self.lang_service = lang_service
+        self.mail_service = mail_service
         self.bcrypt = Bcrypt()
 
 
@@ -61,11 +67,12 @@ class ProfileService:
 
             # 1. Build the local user profile dictionary here.
             # the user_profile variables are used on the LLM templates also (see in query_main.prompt)
-            user_identifier = user.email             # no longer de ID
+            user_identifier = user.email
             user_profile = {
                 "user_email": user.email,
                 "user_fullname": f'{user.first_name} {user.last_name}',
                 "user_is_local": True,
+                "user_id": user.id,
                 "extras": {}
             }
 
@@ -79,25 +86,6 @@ class ProfileService:
             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):
-        """
-        Public method for views to create a user profile context for an external user.
-        """
-        # 1. Fetch the external user profile via Dispatcher.
-        external_user_profile = self.dispatcher.get_user_info(
-            company_name=company.short_name,
-            user_identifier=user_identifier
-        )
-
-        # 2. Call the session creation helper with external_user_id as user_identifier
-        self.save_user_profile(
-            company=company,
-            user_identifier=user_identifier,
-            user_profile=external_user_profile)
-
-        # 3. make sure the flask session is clean
-        SessionManager.clear()
-
     def save_user_profile(self, company: Company, user_identifier: str, user_profile: dict):
         """
         Private helper: Takes a pre-built profile, saves it to Redis, and sets the Flask cookie.
@@ -107,6 +95,7 @@ class ProfileService:
         user_profile['id'] = user_identifier
         user_profile['company_id'] = company.id
         user_profile['company'] = company.name
+        user_profile['language'] = self.lang_service.get_current_language()
 
         # save user_profile in Redis session
         self.session_context.save_profile_data(company.short_name, user_identifier, user_profile)
@@ -214,24 +203,34 @@ class ProfileService:
             # encrypt the password
             hashed_password = self.bcrypt.generate_password_hash(password).decode('utf-8')
 
+            # account verification can be skiped with this security parameter
+            verified = False
+            cfg = self.config_service.get_configuration(company_short_name, 'parameters')
+            if cfg and not cfg.get('verify_account', True):
+                verified = True
+                message = self.i18n_service.t('flash_messages.signup_success_no_verification')
+
             # create the new user
             new_user = User(email=email,
                             password=hashed_password,
                             first_name=first_name.lower(),
                             last_name=last_name.lower(),
-                            verified=False,
+                            verified=verified,
                             verification_url=verification_url
                             )
 
             # associate new company to user
             new_user.companies.append(company)
 
+            # and create in the database
             self.profile_repo.create_user(new_user)
 
             # send email with verification
-            self.send_verification_email(new_user, company_short_name)
+            if not cfg or cfg.get('verify_account', True):
+                self.send_verification_email(new_user, company_short_name)
+                message = self.i18n_service.t('flash_messages.signup_success')
 
-            return {"message": self.i18n_service.t('flash_messages.signup_success')}
+            return {"message": message}
         except Exception as e:
             return {"error": self.i18n_service.t('errors.general.unexpected_error', error=str(e))}
 
@@ -275,7 +274,7 @@ class ProfileService:
         except Exception as e:
             return {"error": self.i18n_service.t('errors.general.unexpected_error')}
 
-    def forgot_password(self, email: str, reset_url: str):
+    def forgot_password(self, company_short_name: str, email: str, reset_url: str):
         try:
             # Verificar si el usuario existe
             user = self.profile_repo.get_user_by_email(email)
@@ -287,7 +286,7 @@ class ProfileService:
             self.profile_repo.set_temp_code(email, temp_code)
 
             # send email to the user
-            self.send_forgot_password_email(user, reset_url)
+            self.send_forgot_password_email(company_short_name, user, reset_url)
 
             return {"message": self.i18n_service.t('flash_messages.forgot_password_success')}
         except Exception as e:
@@ -388,9 +387,12 @@ class ProfileService:
             </body>
             </html>
             """
-        self.mail_app.send_email(to=new_user.email, subject=subject, body=body)
+        self.mail_service.send_mail(company_short_name=company_short_name,
+                                    recipient=new_user.email,
+                                    subject=subject,
+                                    body=body)
 
-    def send_forgot_password_email(self, user: User, reset_url: str):
+    def send_forgot_password_email(self, company_short_name: str, user: User, reset_url: str):
         # send email to the user
         subject = f"Recuperación de Contraseña "
         body = f"""
@@ -441,5 +443,8 @@ class ProfileService:
                 </html>
                 """
 
-        self.mail_app.send_email(to=user.email, subject=subject, body=body)
-        return {"message": "se envio mail para cambio de clave"}
+        self.mail_service.send_mail(company_short_name=company_short_name,
+                                    recipient=user.email,
+                                    subject=subject,
+                                    body=body)
+        return {"message": self.i18n_service.t('services.mail_change_password') }

iatoolkit/services/{prompt_manager_service.py → prompt_service.py}

@@ -14,6 +14,12 @@ from iatoolkit.common.exceptions import IAToolkitException
 import importlib.resources
 import logging
 
+# iatoolkit system prompts definitions
+_SYSTEM_PROMPTS = [
+    {'name': 'query_main', 'description': 'iatoolkit main prompt'},
+    {'name': 'format_styles', 'description': 'output format styles'},
+    {'name': 'sql_rules', 'description': 'instructions  for SQL queries'}
+]
 
 class PromptService:
     @inject
@@ -25,6 +31,106 @@ class PromptService:
         self.profile_repo = profile_repo
         self.i18n_service = i18n_service
 
+    def sync_company_prompts(self, company_instance, prompts_config: list, categories_config: list):
+        """
+        Synchronizes prompt categories and prompts from YAML config to Database.
+        Strategies:
+        - Categories: Create or Update existing based on name.
+        - Prompts: Create or Update existing based on name. Soft-delete or Delete unused.
+        """
+        try:
+            # 1. Sync Categories
+            category_map = {}
+
+            for i, category_name in enumerate(categories_config):
+                category_obj = PromptCategory(
+                    company_id=company_instance.company.id,
+                    name=category_name,
+                    order=i + 1
+                )
+                # Persist and get back the object with ID
+                persisted_cat = self.llm_query_repo.create_or_update_prompt_category(category_obj)
+                category_map[category_name] = persisted_cat
+
+            # 2. Sync Prompts
+            defined_prompt_names = set()
+
+            for prompt_data in prompts_config:
+                category_name = prompt_data.get('category')
+                if not category_name or category_name not in category_map:
+                    logging.warning(
+                        f"⚠️  Warning: Prompt '{prompt_data['name']}' has an invalid or missing category. Skipping.")
+                    continue
+
+                prompt_name = prompt_data['name']
+                defined_prompt_names.add(prompt_name)
+
+                category_obj = category_map[category_name]
+                filename = f"{prompt_name}.prompt"
+
+                new_prompt = Prompt(
+                    company_id=company_instance.company.id,
+                    name=prompt_name,
+                    description=prompt_data['description'],
+                    order=prompt_data['order'],
+                    category_id=category_obj.id,
+                    active=prompt_data.get('active', True),
+                    is_system_prompt=False,
+                    filename=filename,
+                    custom_fields=prompt_data.get('custom_fields', [])
+                )
+
+                self.llm_query_repo.create_or_update_prompt(new_prompt)
+
+            # 3. Cleanup: Delete prompts present in DB but not in Config
+            existing_prompts = self.llm_query_repo.get_prompts(company_instance.company)
+            for p in existing_prompts:
+                if p.name not in defined_prompt_names:
+                    # Using hard delete to keep consistent with previous "refresh" behavior
+                    self.llm_query_repo.session.delete(p)
+
+            self.llm_query_repo.commit()
+
+        except Exception as e:
+            self.llm_query_repo.rollback()
+            raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR, str(e))
+
+    def register_system_prompts(self):
+        """
+        Synchronizes system prompts defined in Dispatcher/Code to Database.
+        """
+        try:
+            defined_names = set()
+
+            for i, prompt_data in enumerate(_SYSTEM_PROMPTS):
+                prompt_name = prompt_data['name']
+                defined_names.add(prompt_name)
+
+                new_prompt = Prompt(
+                    company_id=None,  # System prompts have no company
+                    name=prompt_name,
+                    description=prompt_data['description'],
+                    order=i + 1,
+                    category_id=None,
+                    active=True,
+                    is_system_prompt=True,
+                    filename=f"{prompt_name}.prompt",
+                    custom_fields=[]
+                )
+                self.llm_query_repo.create_or_update_prompt(new_prompt)
+
+            # Cleanup old system prompts
+            existing_sys_prompts = self.llm_query_repo.get_system_prompts()
+            for p in existing_sys_prompts:
+                if p.name not in defined_names:
+                    self.llm_query_repo.session.delete(p)
+
+            self.llm_query_repo.commit()
+
+        except Exception as e:
+            self.llm_query_repo.rollback()
+            raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR, str(e))
+
     def create_prompt(self,
                       prompt_name: str,
                       description: str,
@@ -35,7 +141,10 @@ class PromptService:
                       is_system_prompt: bool = False,
                       custom_fields: list = []
                       ):
-
+        """
+            Direct creation method (used by sync or direct calls).
+            Validates file existence before creating DB entry.
+        """
         prompt_filename = prompt_name.lower() + '.prompt'
         if is_system_prompt:
             if not importlib.resources.files('iatoolkit.system_prompts').joinpath(prompt_filename).is_file():