letschatty 0.4.349__py3-none-any.whl → 0.4.351__py3-none-any.whl

letschatty/services/chat/chat_service.py

@@ -211,25 +211,6 @@ class ChatService:
         ChatService.add_central_notification_from_text(chat=chat, body=f"Agente de IA {chatty_ai_agent.name} actualizado en el chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.CHATTY_AI_AGENT_UPDATED)
         return chat.chatty_ai_agent
 
-    @staticmethod
-    def escalate_chatty_ai_agent(chat: Chat, execution_context: ExecutionContext, message: Optional[str] = None) -> None:
-        """
-        Mark the chat's AI agent as requiring human intervention and add a central notification.
-        """
-        if chat.chatty_ai_agent and not chat.chatty_ai_agent.requires_human_intervention:
-            chat.chatty_ai_agent.requires_human_intervention = True
-            execution_context.set_event_time(datetime.now(tz=ZoneInfo("UTC")))
-        body = "El chat fue escalado a un agente humano"
-        if message:
-            body = f"{body}. Motivo: {message}"
-        ChatService.add_central_notification_from_text(
-            chat=chat,
-            body=body,
-            subtype=MessageSubtype.CHATTY_AI_AGENT_NOTIFICATION,
-            content_status=CentralNotificationStatus.WARNING,
-            context=ChattyContext(chain_of_thought_id=execution_context.chain_of_thought_id)
-        )
-
     @staticmethod
     def add_workflow_link(chat : Chat, link : LinkItem, flow:FlowPreview, execution_context: ExecutionContext, description: str, last_incoming_message_id: Optional[str] = None, next_call: Optional[datetime] = None) -> FlowStateAssignedToChat:
         """
@@ -285,46 +266,36 @@ class ChatService:
         return next((state for state in chat.flow_states if state.is_smart_follow_up), None)
 
     @staticmethod
-    def create_sale(
-        chat: Chat,
-        execution_context: ExecutionContext,
-        sale: Sale,
-        product: Optional[Product],
-        product_ids: Optional[List[StrObjectId]] = None,
-        product_label: Optional[str] = None
-    ) -> SaleAssignedToChat:
+    def create_sale(chat : Chat, execution_context: ExecutionContext, sale : Sale, product : Product) -> SaleAssignedToChat:
         """
         Add a sale to the chat.
         """
         if next((sale for sale in chat.client.sales if sale.asset_id == sale.id), None) is not None:
             raise AssetAlreadyAssigned(f"Sale with id {sale.id} already assigned to chat {chat.id}")
-        label = product_label or (product.name if product else "multiples productos")
-        assigned_product_ids = product_ids or ([product.id] if product else [])
         assigned_asset = SaleAssignedToChat(
             asset_type=ChatAssetType.SALE,
             asset_id=sale.id,
             assigned_at=sale.created_at,
             assigned_by=execution_context.executor.id,
-            product_id=product.id if product else None,
-            product_ids=assigned_product_ids
+            product_id=product.id
         )
         execution_context.set_event_time(assigned_asset.assigned_at)
         bisect.insort(chat.client.sales, assigned_asset)
-        ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta de {label}", description=f"Venta de {label} creada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_ADDED))
-        ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {label} agregada al chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_ADDED)
+        ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta de {product.name}", description=f"Venta de {product.name} creada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_ADDED))
+        ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product.name} agregada al chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_ADDED)
         return assigned_asset
 
     @staticmethod
-    def update_sale(chat: Chat, execution_context: ExecutionContext, sale: Sale, product_label: str) -> Sale:
+    def update_sale(chat : Chat, execution_context: ExecutionContext, sale : Sale, product : Product) -> Sale:
         """
         Update a sale for the chat.
         """
-        ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta actualizada de {product_label}", description=f"Venta de {product_label} actualizada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_UPDATED))
-        ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product_label} actualizada en el chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_UPDATED)
+        ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta actualizada de {product.name}", description=f"Venta de {product.name} actualizada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_UPDATED))
+        ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product.name} actualizada en el chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_UPDATED)
         return sale
 
     @staticmethod
-    def delete_sale(chat: Chat, execution_context: ExecutionContext, sale_id: StrObjectId, product_label: str) -> SaleAssignedToChat:
+    def delete_sale(chat : Chat, execution_context: ExecutionContext, sale_id : StrObjectId, product : Product) -> SaleAssignedToChat:
         """
         Logically remove a sale from the chat.
         """
@@ -332,8 +303,8 @@ class ChatService:
             assigned_asset_to_remove = next(sale for sale in chat.client.sales if sale.asset_id == sale_id)
             chat.client.sales.remove(assigned_asset_to_remove)
             execution_context.set_event_time(datetime.now(tz=ZoneInfo("UTC")))
-            ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta eliminada de {product_label}", description=f"Venta de {product_label} eliminada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_DELETED))
-            ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product_label} eliminada del chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_DELETED)
+            ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta eliminada de {product.name}", description=f"Venta de {product.name} eliminada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_DELETED))
+            ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product.name} eliminada del chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_DELETED)
             return assigned_asset_to_remove
         except StopIteration:
             raise NotFoundError(message=f"Sale with id {sale_id} not found in chat {chat.id}")
@@ -902,16 +873,9 @@ class ChatService:
             execution_context.set_event_time(datetime.now(tz=ZoneInfo("UTC")))
             logger.info(f"Updated collected data for chat {chat.id}: {', '.join(updated_fields)}")
 
-            field_label_map = {
-                "name": "nombre",
-                "email": "email",
-                "phone": "telefono",
-                "document_id": "dni",
-            }
-            display_fields = [field_label_map.get(field, field) for field in updated_fields]
             ChatService.add_central_notification_from_text(
                 chat=chat,
-                body=f"Datos del cliente recopilados: {', '.join(display_fields)}",
+                body=f"Collected customer data: {', '.join(updated_fields)}",
                 subtype=MessageSubtype.CLIENT_INFO_UPDATED,
                 context=ChattyContext(chain_of_thought_id=execution_context.chain_of_thought_id)
             )

letschatty/services/chatty_assets/__init__.py

@@ -1,2 +1,14 @@
 from .base_container import ChattyAssetBaseContainer
 from .base_container_with_collection import ChattyAssetContainerWithCollection
+from .assets_collections import AssetsCollections
+from .services import (
+    ProductService,
+    TagService,
+    UserService,
+    ChatService,
+    SourceService,
+    FlowService,
+    SaleService,
+    ContactPointService,
+    AiAgentService
+)

letschatty/services/chatty_assets/asset_service.py

@@ -1,11 +1,22 @@
 from __future__ import annotations
-from typing import TypeVar, Generic, Type, Callable, Protocol, Optional
+from typing import TypeVar, Generic, Type, Callable, Protocol, Optional, ClassVar, TYPE_CHECKING, List
+
+from bson import ObjectId
+from letschatty.models.utils.types import StrObjectId
 from .base_container_with_collection import ChattyAssetCollectionInterface, ChattyAssetContainerWithCollection, CacheConfig
 from ...models.base_models import ChattyAssetModel
 from ...models.base_models.chatty_asset_model import ChattyAssetPreview
 from ...models.data_base.mongo_connection import MongoConnection
 import logging
 import os
+
+if TYPE_CHECKING:
+    from ...models.analytics.events.base import EventType
+    from ...models.company.empresa import EmpresaModel
+    from ...models.execution.execution import ExecutionContext
+    from ...models.company.assets.company_assets import CompanyAssetType
+    from ...models.utils.types.deletion_type import DeletionType
+
 logger = logging.getLogger("AssetService")
 
 # Protocol for assets that specify their preview type
@@ -44,17 +55,75 @@ class AssetCollection(Generic[T, P], ChattyAssetCollectionInterface[T, P]):
             raise ValueError(f"Data must be a dictionary, got {type(data)}: {data}")
         return self._create_instance_method(data)
 
+
 class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
-    """Generic service for handling CRUD operations for any Chatty asset"""
+    """
+    Generic service for handling CRUD operations for any Chatty asset.
+
+    Supports optional automatic event handling for API implementations.
+    Set these class attributes to enable events:
+    - asset_type_enum: CompanyAssetType (e.g., CompanyAssetType.PRODUCTS)
+    - event_type_created: EventType (e.g., EventType.PRODUCT_CREATED)
+    - event_type_updated: EventType (e.g., EventType.PRODUCT_UPDATED)
+    - event_type_deleted: EventType (e.g., EventType.PRODUCT_DELETED)
+    """
+
+    # Optional: Set these in subclasses to enable automatic event handling
+    asset_type_enum: ClassVar[Optional['CompanyAssetType']] = None
+    event_type_created: ClassVar[Optional['EventType']] = None
+    event_type_updated: ClassVar[Optional['EventType']] = None
+    event_type_deleted: ClassVar[Optional['EventType']] = None
+
+    collection: AssetCollection[T, P]  # Type annotation for better type checking
 
     def __init__(self,
-                 collection_name: str,
-                 asset_type: Type[T],
-                 connection: MongoConnection,
-                 create_instance_method: Callable[[dict], T],
-                 preview_type: Optional[Type[P]] = None,
+                 collection: AssetCollection[T, P],
                  cache_config: CacheConfig = CacheConfig.default()):
-        logger.debug(f"AssetService {self.__class__.__name__} initializing for {collection_name}")
+        """
+        Initialize AssetService with a pre-configured collection.
+
+        The item_type and preview_type are automatically extracted from the collection,
+        eliminating redundancy and simplifying the API.
+
+        Args:
+            collection: Pre-configured AssetCollection subclass
+            cache_config: Cache configuration
+        """
+        logger.debug(f"AssetService {self.__class__.__name__} initializing with collection")
+        super().__init__(
+            item_type=collection.type,
+            preview_type=collection.preview_type,
+            collection=collection,
+            cache_config=cache_config,
+        )
+        logger.debug(f"AssetService {self.__class__.__name__} initialized")
+
+    @classmethod
+    def from_config(cls,
+                    collection_name: str,
+                    asset_type: Type[T],
+                    connection: MongoConnection,
+                    create_instance_method: Callable[[dict], T],
+                    preview_type: Optional[Type[P]] = None,
+                    cache_config: CacheConfig = CacheConfig.default()) -> 'AssetService[T, P]':
+        """
+        Create an AssetService using the legacy configuration pattern.
+
+        This class method is provided for backward compatibility.
+        New code should use pre-configured AssetCollection subclasses.
+
+        Args:
+            collection_name: MongoDB collection name
+            asset_type: The asset model type
+            connection: MongoDB connection
+            create_instance_method: Factory method to create asset instances
+            preview_type: Optional preview type
+            cache_config: Cache configuration
+
+        Returns:
+            AssetService instance
+        """
+        logger.debug(f"AssetService creating from config for {collection_name}")
         asset_collection = AssetCollection(
             collection=collection_name,
             asset_type=asset_type,
@@ -62,13 +131,102 @@ class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
             create_instance_method=create_instance_method,
             preview_type=preview_type
         )
-        super().__init__(
-            item_type=asset_type,
-            preview_type=preview_type,
+        return cls(
             collection=asset_collection,
-            cache_config=cache_config,
+            cache_config=cache_config
         )
-        logger.debug(f"AssetService {self.__class__.__name__} initialized for {collection_name}")
+
+    def _should_handle_events(self) -> bool:
+        """Check if this service should handle events automatically"""
+        return (self.asset_type_enum is not None and
+                self.event_type_created is not None and
+                self.event_type_updated is not None and
+                self.event_type_deleted is not None)
+
+    def _queue_event(self, item: T, event_type: 'EventType', execution_context: 'ExecutionContext', company_info: 'EmpresaModel'):
+        """Queue an event for this asset if event handling is enabled"""
+        if not self._should_handle_events() or not self.asset_type_enum:
+            return
+
+        try:
+            from ...services.factories.analytics.events_factory import EventFactory
+            from ...services.events import events_manager
+
+            # Type guard - company_id should exist on ChattyAssetModel
+            if not hasattr(item, 'company_id'):
+                logger.warning(f"Asset {type(item).__name__} missing company_id, skipping event")
+                return
+
+            events = EventFactory.asset_events(
+                company_id=item.company_id,  # type: ignore[attr-defined]
+                executor_id=execution_context.executor.id,
+                asset=item,
+                asset_type=self.asset_type_enum,
+                event_type=event_type,
+                time=execution_context.time,
+                trace_id=execution_context.trace_id,
+                executor_type=execution_context.executor.type,
+                company_info=company_info
+            )
+            events_manager.queue_events(events)
+        except ImportError:
+            # Events not available (microservice context) - skip
+            pass
+
+    # All methods are now async-only for better performance
+    async def insert(self, item: T, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None) -> T:
+        """Insert with automatic event handling if configured"""
+        result = await super().insert(item, execution_context)
+        if company_info and self._should_handle_events() and self.event_type_created:
+            self._queue_event(result, self.event_type_created, execution_context, company_info)
+        return result
+
+    async def update(self, id: str, new_item: T, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None) -> T:
+        """Update with automatic event handling if configured"""
+        result = await super().update(id, new_item, execution_context)
+        if company_info and self._should_handle_events() and self.event_type_updated:
+            self._queue_event(result, self.event_type_updated, execution_context, company_info)
+        return result
+
+    async def delete(self, id: str, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None, deletion_type: Optional['DeletionType'] = None) -> T:
+        """Delete with automatic event handling if configured"""
+        from ...models.utils.types.deletion_type import DeletionType as DT
+        result = await super().delete(id, execution_context, deletion_type or DT.LOGICAL)
+        if company_info and self._should_handle_events() and self.event_type_deleted:
+            self._queue_event(result, self.event_type_deleted, execution_context, company_info)
+        return result
+
+    async def restore(self, id: str, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None) -> T:
+        """Restore with automatic event handling if configured"""
+        result = await super().restore(id, execution_context)
+        if company_info and self._should_handle_events() and self.event_type_updated:
+            self._queue_event(result, self.event_type_updated, execution_context, company_info)
+        return result
+
+    # Generic convenience methods
+    async def create_asset(self, data: dict, execution_context: 'ExecutionContext', company_info: 'EmpresaModel') -> T:
+        """
+        Generic create method - creates instance from dict and inserts with events.
+        Can be called as create_asset or aliased to create_product/create_tag/etc.
+        """
+        data["company_id"] = execution_context.company_id
+        item = self.collection.create_instance(data)
+        return await self.insert(item, execution_context, company_info)
+
+    async def update_asset(self, id: str, data: dict, execution_context: 'ExecutionContext', company_info: 'EmpresaModel') -> T:
+        """
+        Generic update method - creates instance from dict and updates with events.
+        Can be called as update_asset or aliased to update_product/update_tag/etc.
+        """
+        new_item = self.collection.create_instance(data)
+        return await self.update(id, new_item, execution_context, company_info)
+
+    async def delete_asset(self, id: str, execution_context: 'ExecutionContext', company_info: 'EmpresaModel') -> T:
+        """
+        Generic delete method - deletes with events.
+        Can be called as delete_asset or aliased to delete_product/delete_tag/etc.
+        """
+        return await self.delete(id, execution_context, company_info)
 
     def get_preview_type(self) -> Type[P]:
         """Get the preview type from the asset class if it has one"""
@@ -81,3 +239,22 @@ class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
         preview_type = self.get_preview_type()
         return super().get_preview_by_id(id, company_id, preview_type)
 
+    # Additional async read methods (passthrough to base class)
+    async def get_by_id(self, id: str) -> T:
+        """Get by ID"""
+        return await super().get_by_id(id)
+
+    async def get_all(self, company_id: str) -> List[T]:
+        """Get all for company"""
+        return await super().get_all(company_id)
+
+    async def get_by_query(self, query: dict, company_id: Optional[str]) -> List[T]:
+        """Get by query"""
+        return await super().get_by_query(query, company_id)
+
+    async def get_item_dumped(self, id: str) -> dict:
+        """Get item by ID and return as JSON serialized dict for frontend"""
+        from ...models.utils.types.serializer_type import SerializerType
+        item = await self.get_by_id(id)
+        return item.model_dump_json(serializer=SerializerType.FRONTEND)
+

letschatty/services/chatty_assets/assets_collections.py

@@ -0,0 +1,137 @@
+"""
+Read-only Assets Collections Container
+
+This module provides a singleton container class that gives microservices
+read-only access to asset data using pre-configured AssetCollection subclasses.
+Perfect for services that only need to read asset data without CRUD operations.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import logging
+
+# Import base components
+from ...models.data_base.mongo_connection import MongoConnection
+from ...models.base_models.singleton import SingletonMeta
+
+# Import pre-configured collection subclasses
+from .collections import (
+    ProductCollection,
+    TagCollection,
+    UserCollection,
+    ChatCollection,
+    SourceCollection,
+    FlowCollection,
+    SaleCollection,
+    ContactPointCollection,
+    AiAgentCollection,
+    FilterCriteriaCollection,
+    AiComponentCollection
+)
+
+# Import asset models for type hints
+from ...models.company.assets.product import Product
+from ...models.company.assets.tag import Tag
+from ...models.company.assets.users.user import User
+from ...models.chat.chat import Chat
+from ...models.analytics.sources import SourceBase
+from ...models.company.assets.flow import FlowPreview
+from ...models.company.assets.sale import Sale
+from ...models.company.assets.contact_point import ContactPoint
+from ...models.company.assets.ai_agents_v2.chatty_ai_agent import ChattyAIAgent
+from ...models.company.assets.filter_criteria import FilterCriteria
+
+if TYPE_CHECKING:
+    pass
+
+logger = logging.getLogger("AssetsCollections")
+
+
+class AssetsCollections(metaclass=SingletonMeta):
+    """
+    Read-only singleton container for accessing asset collections across microservices.
+
+    This class provides simple read access to various asset types without the overhead
+    of the full AssetService (no caching, no events, no write operations).
+
+    Usage:
+        assets = AssetsCollections(connection)
+        product = assets.get_product_by_id(product_id)
+        tag = assets.get_tag_by_id(tag_id)
+    """
+
+    def __init__(self, connection: MongoConnection):
+        """
+        Initialize all asset collections using pre-configured collection subclasses.
+
+        Args:
+            connection: MongoConnection instance to use for database access
+        """
+        logger.debug("Initializing AssetsCollections")
+
+        # Initialize all collections using pre-configured subclasses
+        # Each collection subclass already knows its collection name, asset type,
+        # preview type, and create_instance_method
+        self.products = ProductCollection(connection)
+        self.tags = TagCollection(connection)
+        self.users = UserCollection(connection)
+        self.chats = ChatCollection(connection)
+        self.sources = SourceCollection(connection)
+        self.flows = FlowCollection(connection)
+        self.sales = SaleCollection(connection)
+        self.contact_points = ContactPointCollection(connection)
+        self.ai_agents = AiAgentCollection(connection)
+        self.filter_criterias = FilterCriteriaCollection(connection)
+        self.ai_components = AiComponentCollection(connection)
+
+        logger.debug("AssetsCollections initialized successfully")
+
+    # Convenience getter methods for easy access
+
+    async def get_product_by_id(self, id: str) -> Product:
+        """Get a product by ID."""
+        return await self.products.get_by_id(id)
+
+    async def get_tag_by_id(self, id: str) -> Tag:
+        """Get a tag by ID."""
+        return await self.tags.get_by_id(id)
+
+    async def get_user_by_id(self, id: str) -> User:
+        """Get a user by ID."""
+        return await self.users.get_by_id(id)
+
+    async def get_chat_by_id(self, id: str) -> Chat:
+        """Get a chat by ID."""
+        return await self.chats.get_by_id(id)
+
+    async def get_source_by_id(self, id: str) -> SourceBase:
+        """Get a source by ID."""
+        return await self.sources.get_by_id(id)
+
+    async def get_flow_by_id(self, id: str) -> FlowPreview:
+        """Get a flow by ID."""
+        return await self.flows.get_by_id(id)
+
+    async def get_sale_by_id(self, id: str) -> Sale:
+        """Get a sale by ID."""
+        return await self.sales.get_by_id(id)
+
+    async def get_contact_point_by_id(self, id: str) -> ContactPoint:
+        """Get a contact point by ID."""
+        return await self.contact_points.get_by_id(id)
+
+    async def get_ai_agent_by_id(self, id: str) -> ChattyAIAgent:
+        """Get an AI agent by ID."""
+        return await self.ai_agents.get_by_id(id)
+
+    async   def get_filter_criteria_by_id(self, id: str) -> FilterCriteria:
+        """Get a filter criteria by ID."""
+        return await self.filter_criterias.get_by_id(id)
+
+    async def get_filter_criterias_by_ids(self, ids: list[str]) -> list[FilterCriteria]:
+        """Get multiple filter criterias by their IDs in a single query."""
+        return await self.filter_criterias.get_by_ids(ids=ids)
+
+    async def get_ai_components_by_ids(self, ids: list[str]) -> list[Any]:
+        """Get multiple AI components by their IDs in a single query."""
+        return await self.ai_components.get_by_ids(ids=ids)
+

letschatty/services/chatty_assets/base_container.py

@@ -123,8 +123,9 @@ class ChattyAssetBaseContainer(Generic[T, P], ABC):
         else:
             return list(self.items.values())
 
-    def get_all_dict_id_item(self, company_id:Optional[StrObjectId]) -> Dict[StrObjectId, T]:
-        return {item.id: item for item in self.get_all(company_id)}
+    async def get_all_dict_id_item(self, company_id:Optional[StrObjectId]) -> Dict[StrObjectId, T]:
+        items = await self.get_all(company_id)
+        return {item.id: item for item in items}
 
     def get_all_previews(self, company_id:Optional[StrObjectId]) -> List[P]:
         logger.debug(f"Getting all previews for {self.__class__.__name__}")