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

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():