iatoolkit 0.3.1__py3-none-any.whl

services/profile_service.py

@@ -0,0 +1,376 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Producto: IAToolkit
+# Todos los derechos reservados.
+# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
+
+from injector import inject
+from repositories.profile_repo import ProfileRepo
+from repositories.models import User, Company, ApiKey
+from flask_bcrypt import check_password_hash
+from common.session_manager import SessionManager
+from flask_bcrypt import Bcrypt
+from infra.mail_app import MailApp
+import random
+import logging
+import re
+import secrets
+import string
+from datetime import datetime, timezone
+from services.user_session_context_service import UserSessionContextService
+from services.query_service import QueryService
+
+
+class ProfileService:
+    @inject
+    def __init__(self,
+                 profile_repo: ProfileRepo,
+                 session_context_service: UserSessionContextService,
+                 query_service: QueryService,
+                 mail_app: MailApp):
+        self.profile_repo = profile_repo
+        self.session_context = session_context_service
+        self.query_service = query_service
+        self.mail_app = mail_app
+        self.bcrypt = Bcrypt()
+
+
+    def login(self, company_short_name: str, email: str, password: str) -> dict:
+        try:
+            # check if exits
+            user = self.profile_repo.get_user_by_email(email)
+            if not user:
+                return {"error": "Usuario no encontrado"}
+
+            # check the encrypted password
+            if not check_password_hash(user.password, password):
+                return {"error": "Contraseña inválida"}
+
+            company = self.get_company_by_short_name(company_short_name)
+            if not company:
+                return {"error": "Empresa no encontrada"}
+
+            # check that user belongs to  company
+            if company not in user.companies:
+                return {"error": "Usuario no esta autorizado para esta empresa"}
+
+            if not user.verified:
+                return {"error": "Tu cuenta no ha sido verificada. Por favor, revisa tu correo."}
+
+            # clear history save user data into session manager
+            self.set_user_session(user=user, company=company)
+
+            # initialize company context
+            self.query_service.llm_init_context(
+                company_short_name=company_short_name,
+                local_user_id=user.id
+            )
+
+            return {"message": "Login exitoso"}
+        except Exception as e:
+            logging.exception(f"login error: {str(e)}")
+            return {"error": str(e)}
+
+    def set_user_session(self, user: User, company: Company):
+        SessionManager.set('user_id', user.id)
+        SessionManager.set('company_id', company.id)
+        SessionManager.set('company_short_name', company.short_name)
+
+        # save user data into session manager
+        user_data = {
+            "id": user.id,
+            "email": user.email,
+            "first_name": user.first_name,
+            "last_name": user.last_name,
+            "super_user": user.super_user,
+            "company_id": company.id,
+            "company": company.name,
+            "company_short_name": company.short_name,
+            "company_logo": company.logo_file
+        }
+        SessionManager.set('user', user_data)
+
+        # save time session was activated (in timestamp format)
+        SessionManager.set('last_activity', datetime.now(timezone.utc).timestamp())
+
+
+    def signup(self,
+               company_short_name: str,
+               email: str,
+               first_name: str,
+               last_name: str,
+               rut: str,
+               password: str,
+               confirm_password: str,
+               verification_url: str) -> dict:
+        try:
+
+            # get company info
+            company = self.get_company_by_short_name(company_short_name)
+            if not company:
+                return {"error": f"la empresa {company_short_name} no existe"}
+
+            # normalize  format's
+            rut = rut.lower().replace(" ", "")
+            email = email.lower()
+
+            # check if user exists
+            existing_user = self.profile_repo.get_user_by_email(email)
+            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."}
+
+                if rut != existing_user.rut:
+                    return {"error": "El RUT ingresado no corresponde al email existente."}
+
+                # check if register
+                if company in existing_user.companies:
+                    return {"error": "Usuario ya registrado en esta empresa"}
+                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"}
+
+            # add the new user
+            if password != confirm_password:
+                return {"error": "Las contraseñas no coinciden. Por favor, inténtalo de nuevo."}
+
+            is_valid, message = self.validate_password(password)
+            if not is_valid:
+                return {"error": message}
+
+            # encrypt the password
+            hashed_password = self.bcrypt.generate_password_hash(password).decode('utf-8')
+
+            # create the new user
+            new_user = User(email=email,
+                            rut=rut,
+                            password=hashed_password,
+                            first_name=first_name.lower(),
+                            last_name=last_name.lower(),
+                            verified=False,
+                            verification_url=verification_url
+                            )
+
+            # associate new company to user
+            new_user.companies.append(company)
+
+            self.profile_repo.create_user(new_user)
+
+            # 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."}
+        except Exception as e:
+            return {"error": str(e)}
+
+    def update_user(self, email: str, **kwargs) -> User:
+        return self.profile_repo.update_user(email, **kwargs)
+
+    def verify_account(self, email: str):
+        try:
+            # check if user exist
+            user = self.profile_repo.get_user_by_email(email)
+            if not user:
+                return {"error": "El usuario no existe."}
+
+            # activate the user account
+            self.profile_repo.verify_user(email)
+            return {"message": "Tu cuenta ha sido verificada exitosamente. Ahora puedes iniciar sesión."}
+
+        except Exception as e:
+            return {"error": str(e)}
+
+    def change_password(self,
+                         email: str,
+                         temp_code: str,
+                         new_password: str,
+                         confirm_password: str):
+        try:
+            if new_password != confirm_password:
+                return {"error": "Las contraseñas no coinciden. Por favor, inténtalo nuevamente."}
+
+            # 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."}
+
+            # 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"}
+        except Exception as e:
+            return {"error": str(e)}
+
+    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."}
+
+            # Gen a temporary code and store in the repositories
+            temp_code = ''.join(random.choices(string.ascii_letters + string.digits, k=6)).upper()
+            self.profile_repo.set_temp_code(email, temp_code)
+
+            # send email to the user
+            self.send_forgot_password_email(user, reset_url)
+
+            return {"message": "se envio mail para cambio de clave"}
+        except Exception as e:
+            return {"error": str(e)}
+
+    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
+        """
+        if len(password) < 8:
+            return False, "La contraseña debe tener al menos 8 caracteres."
+
+        if not any(char.isupper() for char in password):
+            return False, "La contraseña debe tener al menos una letra mayúscula."
+
+        if not any(char.islower() for char in password):
+            return False, "La contraseña debe tener al menos una letra minúscula."
+
+        if not any(char.isdigit() for char in password):
+            return False, "La contraseña debe tener al menos un número."
+
+        if not re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
+            return False, "La contraseña debe tener al menos un carácter especial."
+
+        return True, "La contraseña es válida."
+
+    def get_companies(self):
+        return self.profile_repo.get_companies()
+
+    def get_company_by_short_name(self, short_name: str) -> Company:
+        return self.profile_repo.get_company_by_short_name(short_name)
+
+    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"}
+
+        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)
+        self.profile_repo.create_api_key(api_key)
+        return {"message": f"La nueva clave de API para {company_short_name} es: {key}"}
+
+
+    def send_verification_email(self, new_user: User, company_short_name):
+        # send verification account email
+        subject = f"Verificación de Cuenta - {company_short_name}"
+        body = f"""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8">
+                <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                <title>Verificación de Cuenta - {company_short_name}</title>
+            </head>
+            <body style="font-family: Arial, sans-serif; background-color: #f4f4f4; margin: 0; padding: 0;">
+                <table role="presentation" width="100%" bgcolor="#f4f4f4" cellpadding="0" cellspacing="0" border="0">
+                    <tr>
+                        <td align="center">
+                            <table role="presentation" width="600" bgcolor="#ffffff" cellpadding="20" cellspacing="0" border="0" style="border-radius: 8px; box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1);">
+                                
+                                <tr>
+                                    <td style="text-align: left; font-size: 16px; color: #333;">
+                                        <p>Hola <strong>{new_user.first_name}</strong>,</p>
+                                        <p>¡Bienvenido a <strong>{company_short_name}</strong>! Estamos encantados de tenerte con nosotros.</p>
+                                        <p>Para comenzar, verifica tu cuenta haciendo clic en el siguiente botón:</p>
+                                        <p style="text-align: center; margin: 20px 0;">
+                                            <a href="{new_user.verification_url}"
+                                               style="background-color: #007bff; color: #ffffff; text-decoration: none; padding: 12px 24px; border-radius: 5px; font-size: 16px; display: inline-block;">
+                                                Verificar Cuenta
+                                            </a>
+                                        </p>
+                                        <p>Si no puedes hacer clic en el botón, copia y pega el siguiente enlace en tu navegador:</p>
+                                        <p style="word-break: break-word; color: #007bff;">
+                                            <a href="{new_user.verification_url}"
+                                               style="color: #007bff;">
+                                                {new_user.verification_url}
+                                            </a>
+                                        </p>
+                                        <p>Si no creaste una cuenta en {company_short_name}, simplemente ignora este correo.</p>
+                                        <p>¡Gracias por unirte a nuestra comunidad!</p>
+                                        <p style="margin-top: 20px;">Saludos,<br><strong>El equipo de {company_short_name}</strong></p>
+                                    </td>
+                                </tr>
+                            </table>
+                            <p style="font-size: 12px; color: #666; margin-top: 10px;">
+                                Este es un correo automático, por favor no respondas a este mensaje.
+                            </p>
+                        </td>
+                    </tr>
+                </table>
+            </body>
+            </html>
+            """
+        self.mail_app.send_email(to=new_user.email, subject=subject, body=body)
+
+    def send_forgot_password_email(self, user: User, reset_url: str):
+        # send email to the user
+        subject = f"Recuperación de Contraseña "
+        body = f"""
+                <!DOCTYPE html>
+                <html>
+                <head>
+                    <meta charset="UTF-8">
+                    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                    <title>Restablecer Contraseña </title>
+                </head>
+                <body style="font-family: Arial, sans-serif; background-color: #f4f4f4; margin: 0; padding: 0;">
+                    <table role="presentation" width="100%" bgcolor="#f4f4f4" cellpadding="0" cellspacing="0" border="0">
+                        <tr>
+                            <td align="center">
+                                <table role="presentation" width="600" bgcolor="#ffffff" cellpadding="20" cellspacing="0" border="0" style="border-radius: 8px; box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1);">
+            
+                                    <tr>
+                                        <td style="text-align: left; font-size: 16px; color: #333;">
+                                            <p>Hola <strong>{user.first_name}</strong>,</p>
+                                            <p>Hemos recibido una solicitud para restablecer tu contraseña. </p>
+                                            <p>Utiliza el siguiente botón para ingresar tu código temporal y cambiar tu contraseña:</p>
+                                            <p style="text-align: center; margin: 20px 0;">
+                                                <a href="{reset_url}"
+                                                   style="background-color: #007bff; color: #ffffff; text-decoration: none; padding: 12px 24px; border-radius: 5px; font-size: 16px; display: inline-block;">
+                                                    Restablecer Contraseña
+                                                </a>
+                                            </p>
+                                            <p><strong>Tu código temporal es:</strong></p>
+                                            <p style="font-size: 20px; font-weight: bold; text-align: center; background-color: #f8f9fa; padding: 10px; border-radius: 5px; border: 1px solid #ccc;">
+                                                {user.temp_code}
+                                            </p>
+                                            <p>Si el botón no funciona, también puedes copiar y pegar el siguiente enlace en tu navegador:</p>
+                                            <p style="word-break: break-word; color: #007bff;">
+                                                <a href="{reset_url}" style="color: #007bff;">{reset_url}</a>
+                                            </p>
+                                            <p>Si no solicitaste este cambio, ignora este correo. Tu cuenta permanecerá segura.</p>
+                                            <p style="margin-top: 20px;">Saludos,<br><strong>El equipo de TI</strong></p>
+                                        </td>
+                                    </tr>
+                                </table>
+                                <p style="font-size: 12px; color: #666; margin-top: 10px;">
+                                    Este es un correo automático, por favor no respondas a este mensaje.
+                                </p>
+                            </td>
+                        </tr>
+                    </table>
+                </body>
+                </html>
+                """
+
+        self.mail_app.send_email(to=user.email, subject=subject, body=body)
+        return {"message": "se envio mail para cambio de clave"}

services/prompt_manager_service.py

@@ -0,0 +1,180 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Producto: IAToolkit
+# Todos los derechos reservados.
+# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
+
+from injector import inject
+from repositories.llm_query_repo import LLMQueryRepo
+import logging
+from repositories.profile_repo import ProfileRepo
+from collections import defaultdict
+from repositories.models import Prompt, PromptCategory, Company
+import os
+from common.exceptions import IAToolkitException
+
+
+class PromptService:
+    @inject
+    def __init__(self, llm_query_repo: LLMQueryRepo, profile_repo: ProfileRepo):
+        self.llm_query_repo = llm_query_repo
+        self.profile_repo = profile_repo
+
+    def create_prompt(self,
+                      prompt_name: str,
+                      description: str,
+                      order: int,
+                      company: Company = None,
+                      category: PromptCategory = None,
+                      active: bool = True,
+                      is_system_prompt: bool = False,
+                      params: dict = {}
+                      ):
+
+        prompt_filename = prompt_name.lower() + '.prompt'
+        if is_system_prompt:
+            template_dir = 'prompts'
+        else:
+            template_dir = f'companies/{company.short_name}/prompts'
+
+        # Guardar el filepath como una ruta relativa
+        relative_prompt_path = os.path.join(template_dir, prompt_filename)
+
+        # Validar la existencia del archivo usando la ruta absoluta
+        absolute_prompt_path = os.path.join(os.getcwd(), relative_prompt_path)
+        if not os.path.exists(absolute_prompt_path):
+            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
+                               f'No existe el archivo de prompt: {absolute_prompt_path}')
+
+        prompt = Prompt(
+                company_id=company.id if company else None,
+                name=prompt_name,
+                description=description,
+                order=order,
+                category_id=category.id if category and not is_system_prompt else None,
+                active=active,
+                filepath=relative_prompt_path,
+                is_system_prompt=is_system_prompt,
+                parameters=params
+            )
+
+        try:
+            self.llm_query_repo.create_or_update_prompt(prompt)
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR,
+                               f'error creating prompt "{prompt_name}": {str(e)}')
+
+    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"No se encontró el prompt '{prompt_name}' para la empresa '{company.short_name}'")
+
+            absolute_filepath = os.path.join(execution_dir, user_prompt.filepath)
+            if not os.path.exists(absolute_filepath):
+                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                   f"El archivo para el prompt '{prompt_name}' no existe: {absolute_filepath}")
+
+            try:
+                with open(absolute_filepath, 'r', encoding='utf-8') as f:
+                    user_prompt_content = f.read()
+            except Exception as e:
+                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                   f"Error leyendo el archivo de prompt '{prompt_name}' en {absolute_filepath}: {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(
+                f"Error al obtener el contenido del prompt para la empresa '{company.short_name}' y prompt '{prompt_name}': {e}")
+            raise IAToolkitException(IAToolkitException.ErrorType.PROMPT_ERROR,
+                               f'Error al obtener el contenido del prompt "{prompt_name}" para la empresa {company.short_name}: {str(e)}')
+
+    def get_system_prompt(self):
+        try:
+            system_prompt_content = []
+
+            # get the filepaths for all system prompts
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            src_dir = os.path.dirname(current_dir)  # ../src
+            system_prompt_dir = os.path.join(src_dir, "prompts")
+
+            # Obtener, ordenar y leer los system prompts
+            system_prompts = self.llm_query_repo.get_system_prompts()
+
+            for prompt in system_prompts:
+                # Construir la ruta absoluta para leer el archivo
+                absolute_filepath = os.path.join(system_prompt_dir, prompt.filepath)
+                if not os.path.exists(absolute_filepath):
+                    logging.warning(f"El archivo para el prompt de sistema no existe: {absolute_filepath}")
+                    continue
+                try:
+                    with open(absolute_filepath, 'r', encoding='utf-8') as f:
+                        system_prompt_content.append(f.read())
+                except Exception as e:
+                    raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                       f"Error leyendo el archivo de prompt del sistema {absolute_filepath}: {e}")
+
+            # Unir todo el contenido en un solo string
+            return "\n".join(system_prompt_content)
+
+        except IAToolkitException:
+            raise
+        except Exception as e:
+            logging.exception(
+                f"Error al obtener el contenido del prompt de sistema: {e}")
+            raise IAToolkitException(IAToolkitException.ErrorType.PROMPT_ERROR,
+                               f'Error al obtener el contenido de los prompts de sistema": {str(e)}')
+
+    def get_user_prompts(self, company_short_name: 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}'}
+
+            # get all the prompts
+            all_prompts = self.llm_query_repo.get_prompts(company)
+
+            # Agrupar prompts por categoría
+            prompts_by_category = defaultdict(list)
+            for prompt in all_prompts:
+                if prompt.active:
+                    if prompt.category:
+                        cat_key = (prompt.category.order, prompt.category.name)
+                        prompts_by_category[cat_key].append(prompt)
+
+            # Ordenar los prompts dentro de cada categoría
+            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'
+            sorted_categories = sorted(prompts_by_category.items(), key=lambda item: item[0][0])
+
+            for (cat_order, cat_name), prompts in sorted_categories:
+                categorized_prompts.append({
+                    'category_name': cat_name,
+                    'category_order': cat_order,
+                    'prompts': [
+                        {'prompt': p.name, 'description': p.description, 'order': p.order}
+                        for p in prompts
+                    ]
+                })
+
+            return {'message': categorized_prompts}
+
+        except Exception as e:
+            logging.error(f"Error en get_prompts: {e}")
+            return {'error': str(e)}
+