New alert service

services/tenant/app/services/__init__.py

@@ -4,11 +4,8 @@ Business logic services for tenant operations
 """
 
 from .tenant_service import TenantService, EnhancedTenantService
-from .messaging import publish_tenant_created, publish_member_added
 
 __all__ = [
     "TenantService",
-    "EnhancedTenantService", 
-    "publish_tenant_created",
-    "publish_member_added"
+    "EnhancedTenantService"
 ]

services/tenant/app/services/messaging.py

@@ -1,74 +0,0 @@
-# services/tenant/app/services/messaging.py
-"""
-Tenant service messaging for event publishing
-"""
-from shared.messaging.rabbitmq import RabbitMQClient
-from app.core.config import settings
-import structlog
-from datetime import datetime
-from typing import Dict, Any
-
-logger = structlog.get_logger()
-
-# Single global instance
-data_publisher = RabbitMQClient(settings.RABBITMQ_URL, "data-service")
-
-async def publish_tenant_created(tenant_id: str, owner_id: str, tenant_name: str):
-    """Publish tenant created event"""
-    try:
-        await data_publisher.publish_event(
-            "tenant.created",
-            {
-                "tenant_id": tenant_id,
-                "owner_id": owner_id,
-                "tenant_name": tenant_name,
-                "timestamp": datetime.utcnow().isoformat()
-            }
-        )
-    except Exception as e:
-        logger.error(f"Failed to publish tenant.created event: {e}")
-
-async def publish_member_added(tenant_id: str, user_id: str, role: str):
-    """Publish member added event"""
-    try:
-        await data_publisher.publish_event(
-            "tenant.member.added",
-            {
-                "tenant_id": tenant_id,
-                "user_id": user_id,
-                "role": role,
-                "timestamp": datetime.utcnow().isoformat()
-            }
-        )
-    except Exception as e:
-        logger.error(f"Failed to publish tenant.member.added event: {e}")
-        
-async def publish_tenant_deleted_event(tenant_id: str, deletion_stats: Dict[str, Any]):
-    """Publish tenant deletion event to message queue"""
-    try:
-        await data_publisher.publish_event(
-            exchange="tenant_events",
-            routing_key="tenant.deleted",
-            message={
-                "event_type": "tenant_deleted",
-                "tenant_id": tenant_id,
-                "timestamp": datetime.utcnow().isoformat(),
-                "deletion_stats": deletion_stats
-            }
-        )
-    except Exception as e:
-        logger.error("Failed to publish tenant deletion event", error=str(e))
-
-async def publish_tenant_deleted(tenant_id: str, tenant_name: str):
-    """Publish tenant deleted event (simple version)"""
-    try:
-        await data_publisher.publish_event(
-            "tenant.deleted",
-            {
-                "tenant_id": tenant_id,
-                "tenant_name": tenant_name,
-                "timestamp": datetime.utcnow().isoformat()
-            }
-        )
-    except Exception as e:
-        logger.error(f"Failed to publish tenant.deleted event: {e}")

services/tenant/app/services/tenant_service.py

@@ -15,7 +15,6 @@ from app.schemas.tenants import (
     BakeryRegistration, TenantResponse, TenantAccessResponse, 
     TenantUpdate, TenantMemberResponse
 )
-from app.services.messaging import publish_tenant_created, publish_member_added
 from shared.database.exceptions import DatabaseError, ValidationError, DuplicateRecordError
 from shared.database.base import create_database_manager
 from shared.database.unit_of_work import UnitOfWork
@@ -27,8 +26,9 @@ logger = structlog.get_logger()
 class EnhancedTenantService:
     """Enhanced tenant management business logic using repository pattern with dependency injection"""
     
-    def __init__(self, database_manager=None):
+    def __init__(self, database_manager=None, event_publisher=None):
         self.database_manager = database_manager or create_database_manager()
+        self.event_publisher = event_publisher
     
     async def _init_repositories(self, session):
         """Initialize repositories with session"""
@@ -165,11 +165,21 @@ class EnhancedTenantService:
             # Commit the transaction
             await uow.commit()
             
-            # Publish event
-            try:
-                await publish_tenant_created(str(tenant.id), owner_id, bakery_data.name)
-            except Exception as e:
-                logger.warning("Failed to publish tenant created event", error=str(e))
+            # Publish tenant created event
+            if self.event_publisher:
+                try:
+                    await self.event_publisher.publish_business_event(
+                        event_type="tenant.created",
+                        tenant_id=str(tenant.id),
+                        data={
+                            "tenant_id": str(tenant.id),
+                            "owner_id": owner_id,
+                            "name": bakery_data.name,
+                            "created_at": datetime.now(timezone.utc).isoformat()
+                        }
+                    )
+                except Exception as e:
+                    logger.warning("Failed to publish tenant created event", error=str(e))
 
             # Automatically create location-context with city information
             # This is non-blocking - failure won't prevent tenant creation
@@ -557,11 +567,22 @@ class EnhancedTenantService:
                 
                 member = await self.member_repo.create_membership(membership_data)
                 
-                # Publish event
-                try:
-                    await publish_member_added(tenant_id, user_id, role)
-                except Exception as e:
-                    logger.warning("Failed to publish member added event", error=str(e))
+                # Publish member added event
+                if self.event_publisher:
+                    try:
+                        await self.event_publisher.publish_business_event(
+                            event_type="tenant.member.added",
+                            tenant_id=tenant_id,
+                            data={
+                                "tenant_id": tenant_id,
+                                "user_id": user_id,
+                                "role": role,
+                                "invited_by": invited_by,
+                                "added_at": datetime.now(timezone.utc).isoformat()
+                            }
+                        )
+                    except Exception as e:
+                        logger.warning("Failed to publish member added event", error=str(e))
                 
                 logger.info("Team member added successfully",
                            tenant_id=tenant_id,
@@ -1015,10 +1036,29 @@ class EnhancedTenantService:
                         detail=f"Failed to delete tenant: {str(e)}"
                     )
 
-                # Publish deletion event for other services
+                # Publish deletion event for other services using unified messaging
                 try:
-                    from app.services.messaging import publish_tenant_deleted
-                    await publish_tenant_deleted(tenant_id, tenant.name)
+                    from shared.messaging import initialize_service_publisher, EVENT_TYPES
+                    from app.core.config import settings
+
+                    # Create a temporary publisher to send the event using the unified helper
+                    temp_rabbitmq_client, temp_publisher = await initialize_service_publisher("tenant-service", settings.RABBITMQ_URL)
+                    if temp_publisher:
+                        try:
+                            await temp_publisher.publish_business_event(
+                                event_type=EVENT_TYPES.TENANT.TENANT_DELETED,
+                                tenant_id=tenant_id,
+                                data={
+                                    "tenant_id": tenant_id,
+                                    "tenant_name": tenant.name,
+                                    "deleted_at": datetime.now(timezone.utc).isoformat()
+                                }
+                            )
+                        finally:
+                            if temp_rabbitmq_client:
+                                await temp_rabbitmq_client.disconnect()
+                    else:
+                        logger.warning("Could not connect to RabbitMQ to publish tenant deletion event")
                 except Exception as e:
                     logger.warning("Failed to publish tenant deletion event",
                                  tenant_id=tenant_id,