Add order page with real API calls

services/orders/app/repositories/order_repository.py

@@ -5,7 +5,7 @@
 Order-related repositories for Orders Service
 """
 
-from datetime import datetime, date
+from datetime import datetime, date, timedelta
 from decimal import Decimal
 from typing import List, Optional, Dict, Any
 from uuid import UUID
@@ -98,12 +98,86 @@ class CustomerRepository(BaseRepository[Customer, dict, dict]):
                         error=str(e))
             raise
 
+    async def count_created_since(
+        self,
+        db: AsyncSession,
+        tenant_id: UUID,
+        since_date: datetime
+    ) -> int:
+        """Count customers created since a specific date"""
+        try:
+            query = select(func.count()).select_from(Customer).where(
+                and_(
+                    Customer.tenant_id == tenant_id,
+                    Customer.created_at >= since_date
+                )
+            )
+            result = await db.execute(query)
+            return result.scalar()
+        except Exception as e:
+            logger.error("Error counting customers created since date",
+                        tenant_id=str(tenant_id),
+                        since_date=str(since_date),
+                        error=str(e))
+            raise
+
 
 class OrderRepository(BaseRepository[CustomerOrder, OrderCreate, OrderUpdate]):
     """Repository for customer order operations"""
-    
+
     def __init__(self):
         super().__init__(CustomerOrder)
+
+    async def get_multi(
+        self,
+        db: AsyncSession,
+        tenant_id: Optional[UUID] = None,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,
+        order_desc: bool = False
+    ) -> List[CustomerOrder]:
+        """Get multiple orders with eager loading of items and customer"""
+        try:
+            query = select(self.model).options(
+                selectinload(CustomerOrder.items),
+                selectinload(CustomerOrder.customer)
+            )
+
+            # Apply tenant filter
+            if tenant_id:
+                query = query.where(self.model.tenant_id == tenant_id)
+
+            # Apply additional filters
+            if filters:
+                for key, value in filters.items():
+                    if hasattr(self.model, key) and value is not None:
+                        field = getattr(self.model, key)
+                        if isinstance(value, list):
+                            query = query.where(field.in_(value))
+                        else:
+                            query = query.where(field == value)
+
+            # Apply ordering
+            if order_by and hasattr(self.model, order_by):
+                order_column = getattr(self.model, order_by)
+                if order_desc:
+                    query = query.order_by(order_column.desc())
+                else:
+                    query = query.order_by(order_column)
+            else:
+                # Default ordering by order_date desc
+                query = query.order_by(CustomerOrder.order_date.desc())
+
+            # Apply pagination
+            query = query.offset(skip).limit(limit)
+
+            result = await db.execute(query)
+            return result.scalars().all()
+        except Exception as e:
+            logger.error("Error getting multiple orders", error=str(e))
+            raise
     
     async def get_with_items(
         self,