141 lines
5.4 KiB
Python
141 lines
5.4 KiB
Python
"""
|
|
Orders Service - Tenant Data Deletion
|
|
Handles deletion of all order-related data for a tenant
|
|
"""
|
|
from typing import Dict
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import select, delete, func
|
|
import structlog
|
|
|
|
from shared.services.tenant_deletion import BaseTenantDataDeletionService, TenantDataDeletionResult
|
|
from app.models.order import CustomerOrder, OrderItem, OrderStatusHistory
|
|
from app.models.customer import Customer, CustomerContact
|
|
|
|
logger = structlog.get_logger()
|
|
|
|
|
|
class OrdersTenantDeletionService(BaseTenantDataDeletionService):
|
|
"""Service for deleting all orders-related data for a tenant"""
|
|
|
|
def __init__(self, db_session: AsyncSession):
|
|
super().__init__("orders-service")
|
|
self.db = db_session
|
|
|
|
async def get_tenant_data_preview(self, tenant_id: str) -> Dict[str, int]:
|
|
"""Get counts of what would be deleted"""
|
|
|
|
try:
|
|
preview = {}
|
|
|
|
# Count orders
|
|
order_count = await self.db.scalar(
|
|
select(func.count(CustomerOrder.id)).where(CustomerOrder.tenant_id == tenant_id)
|
|
)
|
|
preview["orders"] = order_count or 0
|
|
|
|
# Count order items (will be deleted via CASCADE)
|
|
order_item_count = await self.db.scalar(
|
|
select(func.count(OrderItem.id))
|
|
.join(CustomerOrder)
|
|
.where(CustomerOrder.tenant_id == tenant_id)
|
|
)
|
|
preview["order_items"] = order_item_count or 0
|
|
|
|
# Count order status history (will be deleted via CASCADE)
|
|
status_history_count = await self.db.scalar(
|
|
select(func.count(OrderStatusHistory.id))
|
|
.join(CustomerOrder)
|
|
.where(CustomerOrder.tenant_id == tenant_id)
|
|
)
|
|
preview["order_status_history"] = status_history_count or 0
|
|
|
|
# Count customers
|
|
customer_count = await self.db.scalar(
|
|
select(func.count(Customer.id)).where(Customer.tenant_id == tenant_id)
|
|
)
|
|
preview["customers"] = customer_count or 0
|
|
|
|
# Count customer contacts (will be deleted via CASCADE)
|
|
contact_count = await self.db.scalar(
|
|
select(func.count(CustomerContact.id))
|
|
.join(Customer)
|
|
.where(Customer.tenant_id == tenant_id)
|
|
)
|
|
preview["customer_contacts"] = contact_count or 0
|
|
|
|
return preview
|
|
|
|
except Exception as e:
|
|
logger.error("Error getting deletion preview",
|
|
tenant_id=tenant_id,
|
|
error=str(e))
|
|
return {}
|
|
|
|
async def delete_tenant_data(self, tenant_id: str) -> TenantDataDeletionResult:
|
|
"""Delete all data for a tenant"""
|
|
|
|
result = TenantDataDeletionResult(tenant_id, self.service_name)
|
|
|
|
try:
|
|
# Get preview before deletion for reporting
|
|
preview = await self.get_tenant_data_preview(tenant_id)
|
|
|
|
# Delete customers (CASCADE will delete customer_contacts)
|
|
try:
|
|
customer_delete = await self.db.execute(
|
|
delete(Customer).where(Customer.tenant_id == tenant_id)
|
|
)
|
|
deleted_customers = customer_delete.rowcount
|
|
result.add_deleted_items("customers", deleted_customers)
|
|
|
|
# Customer contacts are deleted via CASCADE
|
|
result.add_deleted_items("customer_contacts", preview.get("customer_contacts", 0))
|
|
|
|
logger.info("Deleted customers for tenant",
|
|
tenant_id=tenant_id,
|
|
count=deleted_customers)
|
|
|
|
except Exception as e:
|
|
logger.error("Error deleting customers",
|
|
tenant_id=tenant_id,
|
|
error=str(e))
|
|
result.add_error(f"Customer deletion: {str(e)}")
|
|
|
|
# Delete orders (CASCADE will delete order_items and order_status_history)
|
|
try:
|
|
order_delete = await self.db.execute(
|
|
delete(CustomerOrder).where(CustomerOrder.tenant_id == tenant_id)
|
|
)
|
|
deleted_orders = order_delete.rowcount
|
|
result.add_deleted_items("orders", deleted_orders)
|
|
|
|
# Order items and status history are deleted via CASCADE
|
|
result.add_deleted_items("order_items", preview.get("order_items", 0))
|
|
result.add_deleted_items("order_status_history", preview.get("order_status_history", 0))
|
|
|
|
logger.info("Deleted orders for tenant",
|
|
tenant_id=tenant_id,
|
|
count=deleted_orders)
|
|
|
|
except Exception as e:
|
|
logger.error("Error deleting orders",
|
|
tenant_id=tenant_id,
|
|
error=str(e))
|
|
result.add_error(f"Order deletion: {str(e)}")
|
|
|
|
# Commit all deletions
|
|
await self.db.commit()
|
|
|
|
logger.info("Tenant data deletion completed",
|
|
tenant_id=tenant_id,
|
|
deleted_counts=result.deleted_counts)
|
|
|
|
except Exception as e:
|
|
logger.error("Fatal error during tenant data deletion",
|
|
tenant_id=tenant_id,
|
|
error=str(e))
|
|
await self.db.rollback()
|
|
result.add_error(f"Fatal error: {str(e)}")
|
|
|
|
return result
|