letschatty 0.4.280__py3-none-any.whl → 0.4.343__py3-none-any.whl

letschatty/models/company/assets/launch/subscription.py

@@ -0,0 +1,63 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+from letschatty.models.utils.types.identifier import StrObjectId
+from datetime import datetime
+from enum import StrEnum
+
+
+class LaunchSubscriptionStatus(StrEnum):
+    """
+    Status of a user's subscription to a launch.
+    Note: Pre-qualification is tracked separately in ChattyAIAgentInChat.pre_qualify_status
+    """
+    SUBSCRIBED = "subscribed"          # Successfully subscribed
+    UNSUBSCRIBED = "unsubscribed"      # User unsubscribed
+    ATTENDED = "attended"              # User attended the launch
+    MISSED = "missed"                  # User missed the launch
+
+
+class LaunchSubscription(BaseModel):
+    """
+    Tracks a chat's subscription to a launch.
+    Embedded within the Launch model.
+    """
+    chat_id: StrObjectId = Field(description="ID of the subscribed chat")
+    launch_id: StrObjectId = Field(description="ID of the associated launch")
+    status: LaunchSubscriptionStatus = Field(
+        default=LaunchSubscriptionStatus.SUBSCRIBED,
+        description="Current status of the subscription"
+    )
+    subscribed_at: datetime = Field(description="Timestamp when the user subscribed")
+
+    # Tracking (optional)
+    personal_access_link: Optional[str] = Field(
+        default=None,
+        description="Unique link for tracking user access to the launch (if tracking enabled)"
+    )
+
+    # Communications tracking
+    communications_sent: List[str] = Field(
+        default_factory=list,
+        description="List of IDs of communications already sent to this specific subscriber"
+    )
+
+    # Welcome kit tracking
+    welcome_kit_sent: bool = Field(
+        default=False,
+        description="True if the welcome kit has been sent to this subscriber"
+    )
+    welcome_kit_sent_at: Optional[datetime] = Field(
+        default=None,
+        description="Timestamp when the welcome kit was sent"
+    )
+
+    # Status timestamps
+    attended_at: Optional[datetime] = Field(
+        default=None,
+        description="Timestamp when the user attended the launch"
+    )
+    unsubscribed_at: Optional[datetime] = Field(
+        default=None,
+        description="Timestamp when the user unsubscribed"
+    )
+

letschatty/models/company/assets/sale.py

@@ -5,7 +5,7 @@ from ...utils.types.identifier import StrObjectId
 
 class Sale(CompanyAssetModel):
     chat_id: StrObjectId
-    product_id: StrObjectId
+    product_id: Optional[StrObjectId] = Field(default=None)
     quantity: int
     total_amount: float
     currency: str
@@ -16,7 +16,7 @@ class Sale(CompanyAssetModel):
     creator_id: StrObjectId
 
 class SaleRequest(BaseModel):
-    product_id: StrObjectId
+    product_id: Optional[StrObjectId] = Field(default=None)
     quantity: int
     creator_id: StrObjectId
     total_amount: float
@@ -36,4 +36,4 @@ class SaleRequest(BaseModel):
             "paid_amount": 100,
             "installments": 1,
             "details": {}
-        }
+        }

letschatty/models/company/assets/users/user.py

@@ -65,6 +65,7 @@ class UserPreview(ChattyAssetPreview):
     roles: List[UserRole]
     user_type : UserType
     email : Optional[str] = Field(default=None)
+    auto_assign_chats: bool = Field(default=False)
 
     @classmethod
     def not_found(cls, id: StrObjectId, company_id: StrObjectId) -> 'UserPreview':
@@ -80,6 +81,7 @@ class UserPreview(ChattyAssetPreview):
             photo_url="https://files-chatty.s3.us-east-1.amazonaws.com/Disen%CC%83o+sin+ti%CC%81tulo.png",
             roles=[],
             user_type=UserType.HUMAN,
+            auto_assign_chats=False
         )
 
     @classmethod
@@ -92,6 +94,7 @@ class UserPreview(ChattyAssetPreview):
         projection["email"] = 1
         projection["user_type"] = 1
         projection["api_key_expires_at"] = 1
+        projection["auto_assign_chats"] = 1
         return projection
 
     @classmethod
@@ -107,7 +110,8 @@ class UserPreview(ChattyAssetPreview):
             roles=asset.roles,
             user_type=asset.user_type,
             email=asset.email,
-            updated_at=asset.updated_at
+            updated_at=asset.updated_at,
+            auto_assign_chats=asset.auto_assign_chats
         )
 
 class User(CompanyAssetModel):

letschatty/models/company/company_messaging_settgins.py

@@ -13,4 +13,5 @@ class MessagingSettings(BaseModel):
     """Messaging settings for the company"""
     good_quality_score_definition: Optional[str] = Field(default=None, description="The definition of a good quality score")
     products_info_level : ProductsInfoLevel = Field(default=ProductsInfoLevel.NAME, description="Whether to include all products info in the prompt or just the name / description")
-    ai_god_mode : Optional[ChattyAIMode] = Field(default=None, description="The mode of the ai god - null if not active")
+    ai_god_mode : Optional[ChattyAIMode] = Field(default=None, description="The mode of the ai god - null if not active")
+    tagger_instructions: Optional[str] = Field(default=None, description="The instructions for the tagger when using the tagger ai agent")

letschatty/models/company/form_field.py

@@ -1,30 +1,88 @@
-from pydantic import BaseModel, Field
-from typing import Optional, Any
+from pydantic import BaseModel, Field, field_validator, ConfigDict
+from typing import Optional, Any, ClassVar, List
+from letschatty.models.base_models.chatty_asset_model import CompanyAssetModel, ChattyAssetPreview
+import re
 
 
-class FormField(BaseModel):
+class FormFieldPreview(ChattyAssetPreview):
+    """Preview model for FormField - used in list views"""
+    field_key: str = Field(description="Unique key identifier for the field")
+    is_system_field: bool = Field(default=False, description="True if this is a system/standard field")
+    question_example: Optional[str] = Field(default=None, description="Example question for AI")
+    description: Optional[str] = Field(default=None, description="Description of the field")
+
+
+class FormField(CompanyAssetModel):
     """
-    Simple configuration for data collection fields.
+    Company asset for data collection fields.
     AI handles all validation - no regex or type constraints.
+
+    System fields (is_system_field=True) are standard fields that map directly
+    to Client model properties (name, email, phone, document_id, external_id).
+
+    When a system field is customized, a document is created in this same collection
+    with is_system_field=True and the same field_key as the base system field.
+    The field_key serves as the unique identifier for system field customizations.
+
+    field_key is FROZEN after creation - it cannot be changed.
     """
-    field_name: str = Field(description="Unique identifier for the field (e.g., 'email', 'budget')")
+    name: str = Field(description="Display name of the field (e.g., 'Email', 'Budget')")
+    field_key: str = Field(description="Unique key identifier for the field (e.g., 'email', 'budget'). Only letters, numbers, and underscores allowed. Frozen after creation.")
     description: str = Field(
+        default="",
         description="Description of what information this field aims to collect"
     )
     question_example: Optional[str] = Field(
         default=None,
         description="Example of how AI should ask for this information"
     )
-    required: bool = Field(
+    is_system_field: bool = Field(
         default=False,
-        description="Whether this field is required"
+        description="True if this is a system/standard field (cannot be deleted)"
     )
 
+    @field_validator('field_key', mode='before')
+    @classmethod
+    def normalize_field_key(cls, v: str) -> str:
+        """
+        Normalize field_key to only contain lowercase letters, numbers, and underscores.
+        - Converts to lowercase
+        - Replaces spaces and hyphens with underscores
+        - Removes any other special characters
+        - Strips leading/trailing whitespace
+        """
+        if not v:
+            raise ValueError("field_key cannot be empty")
+
+        # Convert to lowercase and strip whitespace
+        normalized = v.lower().strip()
+
+        # Replace spaces and hyphens with underscores
+        normalized = normalized.replace(' ', '_').replace('-', '_')
+
+        # Remove any character that's not a letter, number, or underscore
+        normalized = re.sub(r'[^a-z0-9_]', '', normalized)
+
+        # Remove consecutive underscores
+        normalized = re.sub(r'_+', '_', normalized)
+
+        # Remove leading/trailing underscores
+        normalized = normalized.strip('_')
+
+        if not normalized:
+            raise ValueError("field_key must contain at least one letter or number")
+
+        return normalized
+
+    # Preview class for API responses
+    preview_class: ClassVar[type[FormFieldPreview]] = FormFieldPreview
+
     @classmethod
     def example_email(cls) -> dict:
         """Example email field"""
         return {
-            "field_name": "email",
+            "name": "Email",
+            "field_key": "email",
             "description": "Customer's email address for communication",
             "question_example": "Could you share your email so I can send you more information?",
             "required": True
@@ -34,10 +92,115 @@ class FormField(BaseModel):
     def example_budget(cls) -> dict:
         """Example budget field"""
         return {
-            "field_name": "budget",
+            "name": "Budget",
+            "field_key": "budget",
             "description": "Customer's budget allocation for the project",
-            "question_example": "What's your budget range for this project?",
-            "required": False
+            "question_example": "What's your budget range for this project?"
+        }
+
+
+class SystemFormFields:
+    """
+    Standard system fields available for all companies.
+    These map directly to Client model properties.
+
+    field_key is the unique identifier for system fields.
+    """
+
+    # System field keys (used as identifiers)
+    SYSTEM_KEYS = ["name", "email", "phone", "document_id", "external_id"]
+
+    @classmethod
+    def get_all(cls) -> List[dict]:
+        """Get all system form fields as dicts (for API responses)"""
+        return [
+            cls.name_field(),
+            cls.email_field(),
+            cls.phone_field(),
+            cls.document_id_field(),
+            cls.external_id_field(),
+        ]
+
+    @classmethod
+    def get_all_keys(cls) -> List[str]:
+        """Get all system field keys"""
+        return cls.SYSTEM_KEYS
+
+    @classmethod
+    def is_system_field_key(cls, field_key: str) -> bool:
+        """Check if a field_key belongs to a system field"""
+        return field_key in cls.SYSTEM_KEYS
+
+    @classmethod
+    def get_by_key(cls, field_key: str) -> Optional[dict]:
+        """Get a system field by its field_key"""
+        fields_map = {
+            "name": cls.name_field(),
+            "email": cls.email_field(),
+            "phone": cls.phone_field(),
+            "document_id": cls.document_id_field(),
+            "external_id": cls.external_id_field(),
+        }
+        return fields_map.get(field_key)
+
+    @classmethod
+    def name_field(cls) -> dict:
+        """Standard name field"""
+        return {
+            "field_key": "name",
+            "name": "Nombre",
+            "description": "Nombre del cliente",
+            "question_example": "¿Cuál es tu nombre?",
+            "is_system_field": True,
+            "deleted_at": None
+        }
+
+    @classmethod
+    def email_field(cls) -> dict:
+        """Standard email field"""
+        return {
+            "field_key": "email",
+            "name": "Email",
+            "description": "Dirección de correo electrónico del cliente",
+            "question_example": "¿Podrías compartirme tu email para enviarte más información?",
+            "is_system_field": True,
+            "deleted_at": None
+        }
+
+    @classmethod
+    def phone_field(cls) -> dict:
+        """Standard phone field"""
+        return {
+            "field_key": "phone",
+            "name": "Teléfono",
+            "description": "Número de teléfono del cliente",
+            "question_example": "¿Cuál es tu número de teléfono?",
+            "is_system_field": True,
+            "deleted_at": None
+        }
+
+    @classmethod
+    def document_id_field(cls) -> dict:
+        """Standard document ID field (DNI/ID)"""
+        return {
+            "field_key": "document_id",
+            "name": "DNI / Documento",
+            "description": "Número de documento de identidad del cliente",
+            "question_example": "¿Cuál es tu número de DNI o documento?",
+            "is_system_field": True,
+            "deleted_at": None
+        }
+
+    @classmethod
+    def external_id_field(cls) -> dict:
+        """Standard external/CRM ID field"""
+        return {
+            "field_key": "external_id",
+            "name": "ID Externo / CRM",
+            "description": "Identificador externo del cliente en CRM u otro sistema",
+            "question_example": "¿Tienes un número de cliente o código de referencia?",
+            "is_system_field": True,
+            "deleted_at": None
         }
 
 
@@ -49,7 +212,11 @@ class CollectedData(BaseModel):
     name: Optional[str] = Field(default=None, description="Customer's name")
     email: Optional[str] = Field(default=None, description="Customer's email address")
     phone: Optional[str] = Field(default=None, description="Customer's phone number")
-    document_id: Optional[str] = Field(default=None, description="Customer's DNI/ID number")
+    document_id: Optional[str] = Field(
+        default=None,
+        alias="dni",
+        description="Customer's DNI/ID number"
+    )
 
     # Generic key-value store for any other collected fields
     additional_fields: dict[str, Any] = Field(
@@ -57,6 +224,9 @@ class CollectedData(BaseModel):
         description="Additional collected fields as key-value pairs"
     )
 
+    model_config = ConfigDict(
+        populate_by_name=True
+    )
 
     @classmethod
     def example(cls) -> dict:

letschatty/models/data_base/collection_interface.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, Dict, List, Generic, TypeVar, Type, Optional,
 from bson.objectid import ObjectId
 from pymongo.collection import Collection
 from pymongo.database import Database
-from motor.motor_asyncio import AsyncIOMotorDatabase, AsyncIOMotorCollection
 
 from letschatty.models.chat.chat import Chat
 from ...models.base_models.chatty_asset_model import ChattyAssetModel, CompanyAssetModel, ChattyAssetPreview
@@ -27,116 +26,58 @@ P = TypeVar('P', bound=ChattyAssetPreview)
 class ChattyAssetCollectionInterface(Generic[T, P], ABC):
     def __init__(self, database: str, collection: str, connection: MongoConnection, type: Type[T], preview_type: Optional[Type[P]] = None):
         logger.info(f"Initializing collection {collection} in database {database}")
-        # Sync database and collection (existing)
         self.db: Database = connection.client[database]
         self.collection: Collection = connection.client[database][collection]
-
-        # NEW: Async database and collection
-        # Store connection reference to ensure we use current event loop
-        self._connection = connection
-        self._database_name = database
-        self._collection_name = collection
-        self._async_db: Optional[AsyncIOMotorDatabase] = None
-        self._async_collection: Optional[AsyncIOMotorCollection] = None
-
         self.type = type
         self.preview_type = preview_type
-
-    @property
-    def async_db(self) -> AsyncIOMotorDatabase:
-        """Get async database, ensuring it uses the current event loop"""
-        # Always ensure connection's async client is using current loop (for Lambda compatibility)
-        self._connection._ensure_async_client_loop()
-        # Recreate database reference to ensure it uses the current client
-        self._async_db = self._connection.async_client[self._database_name]
-        return self._async_db
-
-    @property
-    def async_collection(self) -> AsyncIOMotorCollection:
-        """Get async collection, ensuring it uses the current event loop"""
-        # Always ensure connection's async client is using current loop (for Lambda compatibility)
-        self._connection._ensure_async_client_loop()
-        # Recreate collection reference to ensure it uses the current client
-        self._async_collection = self._connection.async_client[self._database_name][self._collection_name]
-        return self._async_collection
     @abstractmethod
     def create_instance(self, data: dict) -> T:
         """Factory method to create instance from data"""
         pass
 
-    # All methods are now async-only for better performance
-    async def insert(self, asset: T) -> StrObjectId:
-        """Async insert operation"""
+    def insert(self, asset: T) -> StrObjectId:
         if not isinstance(asset, self.type):
             raise ValueError(f"Asset must be of type {self.type.__name__}")
         document = asset.model_dump_json(serializer=SerializerType.DATABASE)
         logger.debug(f"Inserting document: {document}")
-        result = await self.async_collection.insert_one(document)
+        result = self.collection.insert_one(document)
         if not result.inserted_id:
             raise Exception("Failed to insert document")
         logger.debug(f"Inserted document with id {result.inserted_id}")
         return result.inserted_id
 
-    async def update(self, asset: T) -> StrObjectId:
-        """Async update operation"""
+    def update(self, asset: T) -> StrObjectId:
         logger.debug(f"Updating document with id {asset.id}")
         if not isinstance(asset, self.type):
             raise ValueError(f"Asset must be of type {self.type.__name__}")
         asset.update_now()
         document = asset.model_dump_json(serializer=SerializerType.DATABASE)
-        document.pop('_id', None)
-        result = await self.async_collection.update_one(
-            {"_id": ObjectId(asset.id)},
-            {"$set": document}
-        )
+        document.pop('_id', None)  # Still needed
+        result = self.collection.update_one({"_id": ObjectId(asset.id)}, {"$set": document})
         if result.matched_count == 0:
             raise NotFoundError(f"No document found with id {asset.id}")
         if result.modified_count == 0:
             logger.debug(f"No changes were made to the document with id {asset.id} probably because the values were the same")
         return asset.id
 
-    async def get_by_id(self, doc_id: str) -> T:
-        """Get by ID operation"""
-        logger.debug(f"Getting document with id {doc_id} from collection {self.async_collection.name}")
-        doc = await self.async_collection.find_one({"_id": ObjectId(doc_id)})
+    def get_by_id(self, doc_id: str) -> T:
+        logger.debug(f"Getting document with id {doc_id} from collection {self.collection.name} and db {self.db.name}")
+        doc = self.collection.find_one({"_id": ObjectId(doc_id)})
+
         if doc:
             return self.create_instance(doc)
         else:
-            raise NotFoundError(f"No document found with id {doc_id} in collection")
+            raise NotFoundError(f"No document found with id {doc_id} in db collection {self.collection.name} and db {self.db.name}")
 
-    async def get_docs(self, company_id: Optional[StrObjectId], query={}, limit=0) -> List[T]:
-        """Get multiple documents operation"""
-        logger.debug(f"Getting documents from collection with company_id {company_id} and query {query}")
+    def get_docs(self, company_id:Optional[StrObjectId], query = {}, limit = 0) -> List[T]:
+        logger.debug(f"Getting documents from collection {self.collection.name} with company_id {company_id} and query {query}")
         if company_id:
-            query = query.copy()
+            query = query.copy()  # Create a copy to avoid modifying the original
             query["company_id"] = company_id
-        cursor = self.async_collection.find(filter=query)
-        if limit:
-            cursor = cursor.limit(limit)
-        docs = await cursor.to_list(length=limit if limit > 0 else None)
-        logger.debug(f"Found {len(docs)} documents")
+        docs = list(self.collection.find(filter=query).limit(limit))
+        logger.debug(f"Found {len(docs)} documents in collection {self.collection.name}")
         return [self.create_instance(doc) for doc in docs]
 
-    async def delete(self, doc_id: str, deletion_type: DeletionType = DeletionType.LOGICAL) -> StrObjectId:
-        """Delete operation"""
-        logger.debug(f"Deleting document with id {doc_id} - deletion type: {deletion_type}")
-        if deletion_type == DeletionType.LOGICAL:
-            result = await self.async_collection.update_one(
-                {"_id": ObjectId(doc_id)},
-                {"$set": {"deleted_at": datetime.now(ZoneInfo("UTC")), "updated_at": datetime.now(ZoneInfo("UTC"))}}
-            )
-            if result.modified_count == 0:
-                raise NotFoundError(f"No document found with id {doc_id}")
-            return doc_id
-        elif deletion_type == DeletionType.PHYSICAL:
-            result = await self.async_collection.delete_one({"_id": ObjectId(doc_id)})
-            if result.deleted_count == 0:
-                raise NotFoundError(f"No document found with id {doc_id}")
-            return doc_id
-        else:
-            raise ValueError(f"Invalid deletion type: {deletion_type}")
-
-    # Additional methods - keeping these sync as they're less critical
     def get_preview_docs(self, projection = {}, all=True) -> List[P]:
         """We get the previews of all the documents in the collection for all companies"""
         if not self.preview_type:
@@ -157,31 +98,18 @@ class ChattyAssetCollectionInterface(Generic[T, P], ABC):
         docs = self.collection.find(query)
         return [self.create_instance(doc) for doc in docs]
 
-    async def get_by_ids(self, ids: List[StrObjectId]) -> List[T]:
-            """
-            Get multiple assets by their IDs in a single query.
-
-            Args:
-                ids: List of asset IDs
-
-            Returns:
-                List of assets objects
-            """
-            if not ids:
-                return []
-
-            # Convert string IDs to ObjectIds
-            object_ids = [ObjectId(id) for id in ids]
-
-            # Query for all filter criteria with matching IDs
-            query = {
-                "_id": {"$in": object_ids},
-                "deleted_at": None
-            }
-
-            # Use the sync collection directly (inherited from ChattyAssetCollectionInterface)
-            docs = await self.async_collection.find(query).to_list(length=None)
-
-            # Create FilterCriteria instances
-            return [self.create_instance(doc) for doc in docs]
+    def delete(self, doc_id: str, deletion_type : DeletionType = DeletionType.LOGICAL) -> StrObjectId:
+        logger.debug(f"Deleting document with id {doc_id} - deletion type: {deletion_type}")
+        if deletion_type == DeletionType.LOGICAL:
+            result = self.collection.update_one({"_id": ObjectId(doc_id)}, {"$set": {"deleted_at": datetime.now(ZoneInfo("UTC")), "updated_at": datetime.now(ZoneInfo("UTC"))}})
+            if result.modified_count == 0:
+                raise NotFoundError(f"No document found with id {doc_id}")
+            return doc_id
+        elif deletion_type == DeletionType.PHYSICAL:
+            result = self.collection.delete_one({"_id": ObjectId(doc_id)})
+            if result.deleted_count == 0:
+                raise NotFoundError(f"No document found with id {doc_id}")
+            return doc_id
+        else:
+            raise ValueError(f"Invalid deletion type: {deletion_type}")