letschatty 0.4.342__py3-none-any.whl → 0.4.344__py3-none-any.whl

letschatty/services/chat/chat_service.py

@@ -28,9 +28,10 @@ from ...models.chat.scheduled_messages import ScheduledMessageStatus
 from ...models.utils.types.identifier import StrObjectId
 from ...models.utils.custom_exceptions.custom_exceptions import AssetAlreadyAssigned, MessageNotFoundError, NotFoundError, MessageAlreadyInChat, MetaErrorNotification, ChatAlreadyAssigned, AlreadyCompleted, ErrorToMantainSafety
 from ..factories.messages.central_notification_factory import CentralNotificationFactory
+from ..factories.messages.chatty_message_factory import from_message_draft
 from ...models.messages.chatty_messages.base.message_draft import ChattyContentAudio, MessageDraft
 from ...models.messages.chatty_messages.schema.chatty_content.content_central import CentralNotificationStatus
-from ...models.messages.chatty_messages.schema import ChattyContext
+from ...models.messages.chatty_messages.schema import ChattyContext, ChattyContentText
 from ...models.utils.types.message_types import MessageType
 from .conversation_topics_service import ConversationTopicsService
 import logging
@@ -211,6 +212,43 @@ 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,
+        reason: 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 reason:
+            body = f"{body}. Motivo: {reason}"
+        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)
+        )
+        if message:
+            outgoing_context = ChattyContext(chain_of_thought_id=execution_context.chain_of_thought_id)
+            outgoing_message = from_message_draft(
+                MessageDraft(
+                    type=MessageType.TEXT,
+                    content=ChattyContentText(body=message),
+                    context=outgoing_context,
+                    subtype=MessageSubtype.NONE,
+                    is_incoming_message=False
+                ),
+                sent_by=execution_context.executor.id
+            )
+            ChatService.add_message(chat=chat, message=outgoing_message)
+
     @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:
         """
@@ -266,36 +304,46 @@ 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 : Product) -> SaleAssignedToChat:
+    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:
         """
         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
+            product_id=product.id if product else None,
+            product_ids=assigned_product_ids
         )
         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 {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)
+        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)
         return assigned_asset
 
     @staticmethod
-    def update_sale(chat : Chat, execution_context: ExecutionContext, sale : Sale, product : Product) -> Sale:
+    def update_sale(chat: Chat, execution_context: ExecutionContext, sale: Sale, product_label: str) -> 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.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)
+        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)
         return sale
 
     @staticmethod
-    def delete_sale(chat : Chat, execution_context: ExecutionContext, sale_id : StrObjectId, product : Product) -> SaleAssignedToChat:
+    def delete_sale(chat: Chat, execution_context: ExecutionContext, sale_id: StrObjectId, product_label: str) -> SaleAssignedToChat:
         """
         Logically remove a sale from the chat.
         """
@@ -303,8 +351,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.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)
+            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)
             return assigned_asset_to_remove
         except StopIteration:
             raise NotFoundError(message=f"Sale with id {sale_id} not found in chat {chat.id}")
@@ -873,9 +921,16 @@ 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"Collected customer data: {', '.join(updated_fields)}",
+                body=f"Datos del cliente recopilados: {', '.join(display_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,14 +1,2 @@
 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,22 +1,11 @@
 from __future__ import annotations
-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 typing import TypeVar, Generic, Type, Callable, Protocol, Optional
 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
@@ -55,75 +44,17 @@ 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.
-
-    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
+    """Generic service for handling CRUD operations for any Chatty asset"""
 
     def __init__(self,
-                 collection: AssetCollection[T, P],
+                 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()):
-        """
-        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}")
+        logger.debug(f"AssetService {self.__class__.__name__} initializing for {collection_name}")
         asset_collection = AssetCollection(
             collection=collection_name,
             asset_type=asset_type,
@@ -131,102 +62,13 @@ class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
             create_instance_method=create_instance_method,
             preview_type=preview_type
         )
-        return cls(
+        super().__init__(
+            item_type=asset_type,
+            preview_type=preview_type,
             collection=asset_collection,
-            cache_config=cache_config
+            cache_config=cache_config,
         )
-
-    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)
+        logger.debug(f"AssetService {self.__class__.__name__} initialized for {collection_name}")
 
     def get_preview_type(self) -> Type[P]:
         """Get the preview type from the asset class if it has one"""
@@ -239,22 +81,3 @@ 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/base_container.py

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

letschatty/services/chatty_assets/base_container_with_collection.py

@@ -64,8 +64,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         self.update_previews_thread()
         self.load_from_db_thread(company_id=None)
 
-    # All methods are now async-only for better performance
-    async def insert(self, item: T, execution_context: ExecutionContext) -> T:
+    def insert(self, item: T, execution_context: ExecutionContext) -> T:
         """
         Add an item to the container and insert it into the database collection.
 
@@ -78,12 +77,12 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         """
         logger.debug(f"{self.__class__.__name__} inserting item {item}")
         inserted_item = super().insert(item)
-        await self.collection.insert(inserted_item)
+        self.collection.insert(inserted_item)
         execution_context.set_event_time(inserted_item.created_at)
         self.update_previews_thread()
         return inserted_item
 
-    async def update(self, id: str, new_item: T, execution_context: ExecutionContext) -> T:
+    def update(self, id: str, new_item: T, execution_context: ExecutionContext) -> T:
         """
         Update an item in the container and in the database collection.
 
@@ -106,18 +105,18 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             if id != updated_item.id:
                 logger.error(f"Item id {id} does not match updated item id {updated_item.id}")
                 raise ValueError(f"Item id {id} does not match updated item id {updated_item.id}")
-            await self.collection.update(updated_item)
+            self.collection.update(updated_item)
             execution_context.set_event_time(updated_item.updated_at)
             self.update_preview(updated_item)
             self.update_previews_thread()
             return updated_item
 
         except NotFoundError as e:
-            outdated_item = await self.collection.get_by_id(id)
+            outdated_item = self.collection.get_by_id(id)
             if outdated_item:
                 updated_item = outdated_item.update(new_item)
                 self.items[id] = updated_item
-                await self.collection.update(updated_item)
+                self.collection.update(updated_item)
                 execution_context.set_event_time(updated_item.updated_at)
                 self.update_previews_thread()
                 return updated_item
@@ -126,7 +125,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
                 f"Item with id {id} not found in {self.__class__.__name__} nor in collection DB"
             )
 
-    async def delete(self, id: str, execution_context: ExecutionContext,deletion_type : DeletionType = DeletionType.LOGICAL) -> T:
+    def delete(self, id: str, execution_context: ExecutionContext,deletion_type : DeletionType = DeletionType.LOGICAL) -> T:
         """
         Delete an item from the container and the collection.
 
@@ -143,16 +142,16 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             deleted_item = super().delete(id)
             self.delete_preview(id)
             execution_context.set_event_time(datetime.now(ZoneInfo("UTC")))
-            await self.collection.delete(id, deletion_type)
+            self.collection.delete(id, deletion_type)
             return deleted_item
         except NotFoundError as e:
-            await self.collection.delete(id, deletion_type)
+            self.collection.delete(id, deletion_type)
             self.delete_preview(id)
             self.update_previews_thread()
             execution_context.set_event_time(datetime.now(ZoneInfo("UTC")))
-            return await self.collection.get_by_id(id)
+            return self.collection.get_by_id(id)
 
-    async def get_by_id(self, id: str) -> T:
+    def get_by_id(self, id: str) -> T:
         """
         Get an item from the container.
 
@@ -175,7 +174,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             #     #if they are supposed to be in memory, we raise an error since it shouldn't be in the collection DB
             #     raise NotFoundError(f"Item with id {id} not found in {self.__class__.__name__} nor in collection DB")
             logger.debug(f"{self.__class__.__name__} getting item {id} not found in container, trying to get from collection")
-            item = await self.collection.get_by_id(id)
+            item = self.collection.get_by_id(id)
             if item:
                 if item.deleted_at is not None:
                     return item
@@ -240,7 +239,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             logger.debug(f"Clearing previews cache of {self.__class__.__name__}")
             self.set_preview_items([])
 
-    async def get_all(self, company_id: Optional[StrObjectId]) -> List[T]:
+    def get_all(self, company_id: Optional[StrObjectId]) -> List[T]:
         # Get items from memory
         logger.debug(f"{self.__class__.__name__} getting all items from memory and collection")
         memory_items = super().get_all(company_id=company_id)
@@ -248,7 +247,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         memory_ids = [ObjectId(item.id) for item in memory_items]
         # Build the query for collection items
         query = {"deleted_at": None, "_id": {"$nin": memory_ids}}
-        collection_items = await self.collection.get_docs(query=query, company_id=company_id)
+        collection_items = self.collection.get_docs(query=query, company_id=company_id)
         all_items = memory_items + collection_items
         return sorted(all_items, key=lambda x: x.created_at, reverse=True)
 
@@ -262,8 +261,6 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
     def update_previews_thread(self):
         """We start a thread to update the previews cache so it doesn't block the main thread"""
         # self.update_previews_cache()
-        if not self.cache_config.keep_previews_always_in_memory:
-            return
         thread = threading.Thread(target=self.update_previews_cache)
         thread.start()
 
@@ -278,13 +275,13 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         self.set_preview_items(collection_items)
         return collection_items
 
-    async def get_by_query(self, query: dict, company_id: Optional[StrObjectId]) -> List[T]:
+    def get_by_query(self, query: dict, company_id: Optional[StrObjectId]) -> List[T]:
         logger.debug(f"{self.__class__.__name__} getting items by query {query} from collection")
-        return await self.collection.get_docs(query=query, company_id=company_id)
+        return self.collection.get_docs(query=query, company_id=company_id)
 
-    async def get_deleted(self, company_id: Optional[StrObjectId]) -> List[T]:
+    def get_deleted(self, company_id: Optional[StrObjectId]) -> List[T]:
         logger.debug(f"{self.__class__.__name__} getting deleted items from collection")
-        return await self.collection.get_docs(query={"deleted_at": {"$ne": None}}, company_id=company_id)
+        return self.collection.get_docs(query={"deleted_at": {"$ne": None}}, company_id=company_id)
 
     def load_from_db_thread(self, company_id: Optional[StrObjectId]):
         """We start a thread to load the items from the database so it doesn't block the main thread"""
@@ -295,27 +292,21 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         thread.start()
 
     def load_from_db(self, company_id: Optional[StrObjectId]):
-        """Pass company_id=None to load all items from the database. Uses sync client for background loading."""
+        """Pass company_id=None to load all items from the database."""
         logger.debug(f"{self.__class__.__name__} loading items from collection")
-        # Background loading uses sync client (less critical, runs in thread)
-        query: Dict[str, Any] = {"deleted_at": None}
-        if company_id:
-            query["company_id"] = company_id
-        docs = list(self.collection.collection.find(filter=query))
-        # Create instances once and reuse
-        loaded_items = [self.collection.create_instance(doc) for doc in docs]
-        self.items = {item.id: item for item in loaded_items}
-
-    async def restore(self, id: str, execution_context: ExecutionContext) -> T:
+        # self.items = {item.id: item for item in self.collection.get_docs(query={}, company_id=company_id)}
+        self.items = {item.id: item for item in self.collection.get_docs(query={"deleted_at": None}, company_id=company_id)}
+
+    def restore(self, id: str, execution_context: ExecutionContext) -> T:
         logger.debug(f"{self.__class__.__name__} restoring item {id} with execution context {execution_context}")
         if id in self.items:
             raise ValueError(f"Item with id {id} already exists in {self.__class__.__name__}")
-        restored_item = await self.collection.get_by_id(id)
+        restored_item = self.collection.get_by_id(id)
         if restored_item is None:
             raise NotFoundError(f"Item with id {id} not found in collection DB")
         restored_item.deleted_at = None
         restored_item.update_now()
         execution_context.set_event_time(restored_item.updated_at)
         self.items[id] = restored_item
-        await self.collection.update(restored_item)
-        return restored_item
+        self.collection.update(restored_item)
+        return restored_item

letschatty/services/continuous_conversation_service/continuous_conversation_helper.py

@@ -269,15 +269,4 @@ class ContinuousConversationHelper:
         central_notif_content = ChattyContentCentral(body=body, status=CentralNotificationStatus.WARNING, calls_to_action=[cta.value for cta in cc.calls_to_action])
         central_notif = CentralNotificationFactory.continuous_conversation_status(cc=cc, content=central_notif_content)
         ChatService.add_central_notification(central_notification=central_notif, chat=chat)
-        return cc
-
-    @staticmethod
-    def handle_failed_template_cc(chat: Chat, cc: ContinuousConversation, error_details: str) -> ContinuousConversation:
-        """This is for the handling of a failed template CC"""
-        cc.set_status(status=ContinuousConversationStatus.FAILED)
-        body=f"Continuous conversation failed to be sent: {error_details}"
-        logger.debug(f"{body} | CC status: {cc.status} | CC id: {cc.id} | chat id: {chat.identifier}")
-        central_notif_content = ChattyContentCentral(body=body, status=CentralNotificationStatus.ERROR, calls_to_action=[cta.value for cta in cc.calls_to_action])
-        central_notif = CentralNotificationFactory.continuous_conversation_status(cc=cc, content=central_notif_content)
-        ChatService.add_central_notification(central_notification=central_notif, chat=chat)
         return cc