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

iatoolkit/services/profile_service.py

@@ -9,15 +9,18 @@ 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.dispatcher_service import Dispatcher
+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
 import string
 import logging
-from iatoolkit.services.dispatcher_service import Dispatcher
+from typing import List, Dict
 
 
 class ProfileService:
@@ -26,16 +29,19 @@ 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()
 
-
     def login(self, company_short_name: str, email: str, password: str) -> dict:
         try:
             # check if user exists
@@ -59,13 +65,17 @@ class ProfileService:
                 return {'success': False,
                         "message": self.i18n_service.t('errors.services.account_not_verified')}
 
+            user_role = self.profile_repo.get_user_role_in_company(company.id, user.id)
+
             # 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,
+                "user_role": user_role,
                 "extras": {}
             }
 
@@ -79,25 +89,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 +98,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 +206,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 +277,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 +289,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:
@@ -321,19 +323,44 @@ class ProfileService:
     def get_company_by_short_name(self, short_name: str) -> Company:
         return self.profile_repo.get_company_by_short_name(short_name)
 
+    def get_company_users(self, company_short_name: str) -> List[Dict]:
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            return []
+
+        # get the company users from the repo
+        company_users =  self.profile_repo.get_company_users_with_details(company_short_name)
+
+        users_data = []
+        for user, role, last_access in company_users:
+            users_data.append({
+                "first_name": user.first_name,
+                "last_name": user.last_name,
+                "email": user.email,
+                "created": user.created_at,
+                "verified": user.verified,
+                "role": role or "user",
+                "last_access": last_access
+            })
+
+        return users_data
+
     def get_active_api_key_entry(self, api_key_value: str) -> ApiKey | None:
         return self.profile_repo.get_active_api_key_entry(api_key_value)
 
-    def new_api_key(self, company_short_name: str):
+    def new_api_key(self, company_short_name: str, key_name: str):
         company = self.get_company_by_short_name(company_short_name)
         if not company:
             return {"error": self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
+        if not key_name:
+            return {"error": self.i18n_service.t('errors.auth.api_key_name_required')}
+
         length = 40     # lenght of the api key
         alphabet = string.ascii_letters + string.digits
         key = ''.join(secrets.choice(alphabet) for i in range(length))
 
-        api_key = ApiKey(key=key, company_id=company.id)
+        api_key = ApiKey(key=key, company_id=company.id, key_name=key_name)
         self.profile_repo.create_api_key(api_key)
         return {"api-key": key}
 
@@ -388,9 +415,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 +471,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}

@@ -4,27 +4,144 @@
 # IAToolkit is open source software.
 
 from injector import inject
+from iatoolkit.common.interfaces.asset_storage import AssetRepository, AssetType
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from collections import defaultdict
 from iatoolkit.repositories.models import Prompt, PromptCategory, Company
-import os
 from iatoolkit.common.exceptions import IAToolkitException
 import importlib.resources
 import logging
+import os
 
+# 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
     def __init__(self,
+                 asset_repo: AssetRepository,
                  llm_query_repo: LLMQueryRepo,
                  profile_repo: ProfileRepo,
                  i18n_service: I18nService):
+        self.asset_repo = asset_repo
         self.llm_query_repo = llm_query_repo
         self.profile_repo = profile_repo
         self.i18n_service = i18n_service
 
+    def sync_company_prompts(self, company_short_name: str, 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.
+        """
+        if not prompts_config:
+            return
+
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
+                                     f'Company {company_short_name} not found')
+
+        try:
+            # 1. Sync Categories
+            category_map = {}
+
+            for i, category_name in enumerate(categories_config):
+                category_obj = PromptCategory(
+                    company_id=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.id,
+                    name=prompt_name,
+                    description=prompt_data.get('description'),
+                    order=prompt_data.get('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)
+            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,19 +152,19 @@ 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():
                 raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
                                 f'missing system prompt file: {prompt_filename}')
         else:
-            template_dir = f'companies/{company.short_name}/prompts'
-
-            relative_prompt_path = os.path.join(template_dir, prompt_filename)
-            if not os.path.exists(relative_prompt_path):
+            if not self.asset_repo.exists(company.short_name, AssetType.PROMPT, prompt_filename):
                 raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
-                               f'missing prompt file: {relative_prompt_path}')
+                               f'missing prompt file: {prompt_filename} in prompts/')
 
         if custom_fields:
             for f in custom_fields:
@@ -79,33 +196,28 @@ class PromptService:
 
     def get_prompt_content(self, company: Company, prompt_name: str):
         try:
-            user_prompt_content = []
-            execution_dir = os.getcwd()
-
             # get the user prompt
             user_prompt = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
             if not user_prompt:
                 raise IAToolkitException(IAToolkitException.ErrorType.DOCUMENT_NOT_FOUND,
                                    f"prompt not found '{prompt_name}' for company '{company.short_name}'")
 
-            prompt_file = f'companies/{company.short_name}/prompts/{user_prompt.filename}'
-            absolute_filepath = os.path.join(execution_dir, prompt_file)
-            if not os.path.exists(absolute_filepath):
-                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
-                                   f"prompt file '{prompt_name}' does not exist: {absolute_filepath}")
-
             try:
-                with open(absolute_filepath, 'r', encoding='utf-8') as f:
-                    user_prompt_content = f.read()
+                user_prompt_content = self.asset_repo.read_text(
+                    company.short_name,
+                    AssetType.PROMPT,
+                    user_prompt.filename
+                )
+            except FileNotFoundError:
+                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                         f"prompt file '{user_prompt.filename}' does not exist for company '{company.short_name}'")
             except Exception as e:
                 raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
-                                   f"error while reading prompt: '{prompt_name}' in this pathname {absolute_filepath}: {e}")
+                                         f"error while reading prompt: '{prompt_name}': {e}")
 
             return user_prompt_content
 
         except IAToolkitException:
-            # Vuelve a lanzar las IAToolkitException que ya hemos manejado
-            # para que no sean capturadas por el siguiente bloque.
             raise
         except Exception as e:
             logging.exception(
@@ -151,7 +263,7 @@ class PromptService:
             # get all the prompts
             all_prompts = self.llm_query_repo.get_prompts(company)
 
-            # Agrupar prompts por categoría
+            # group by category
             prompts_by_category = defaultdict(list)
             for prompt in all_prompts:
                 if prompt.active:
@@ -159,14 +271,13 @@ class PromptService:
                         cat_key = (prompt.category.order, prompt.category.name)
                         prompts_by_category[cat_key].append(prompt)
 
-            # Ordenar los prompts dentro de cada categoría
+            # sort each category by order
             for cat_key in prompts_by_category:
                 prompts_by_category[cat_key].sort(key=lambda p: p.order)
 
-            # Crear la estructura de respuesta final, ordenada por la categoría
             categorized_prompts = []
 
-            # Ordenar las categorías por su 'order'
+            # sort categories by order
             sorted_categories = sorted(prompts_by_category.items(), key=lambda item: item[0][0])
 
             for (cat_order, cat_name), prompts in sorted_categories: