publishing order messages

Author: lordlabakdas

api/order_api.py

@@ -1,4 +1,5 @@
 import logging
+import uuid
 
 from fastapi import APIRouter, Depends
 
@@ -12,19 +13,36 @@
 order_apis = APIRouter(prefix="/order", tags=["order"])
 
 
+def serialize_for_json(obj):
+    """Recursively serialize objects for JSON"""
+    if isinstance(obj, uuid.UUID):
+        return str(obj)
+    elif isinstance(obj, list):
+        return [serialize_for_json(item) for item in obj]
+    elif isinstance(obj, dict):
+        return {key: serialize_for_json(value) for key, value in obj.items()}
+    elif hasattr(obj, "isoformat"):  # datetime objects
+        return obj.isoformat()
+    else:
+        return obj
+
+
 @order_apis.post("/create-order", response_model=Order)
 async def create_order(order: Order, current_user: User = Depends(auth_required)):
     logger.info(f"Creating order for user {current_user.id}")
-    # import pdb; pdb.set_trace()
-    # order_service = OrderService()
-    # order_service.create_order(order, current_user)
-    import pdb
 
-    pdb.set_trace()
-    return publisher.publish_message(
+    order_service = OrderService()
+    order_service.create_order(order, current_user)
+
+    order_dict = serialize_for_json(order.dict())
+    order_dict["user_id"] = str(current_user.id)
+    order_dict["order_date"] = order.order_date.isoformat()
+    logger.info(f"Order dict: {order_dict}")
+
+    publisher.publish_message(
         queue_name="order_queue",
         routing_key="order_queue",
         event="order_created",
-        order="Order placed",
+        **order_dict,
     )
-    # return order
+    return order

api/validators/order_validation.py

@@ -9,8 +9,4 @@ class Order(BaseModel):
     items: List[UUID]
     total_price: float
     status: str
-    created_at: datetime
-    updated_at: datetime
-    order_id: UUID = Field(default_factory=uuid4)
     order_date: datetime = Field(default_factory=datetime.utcnow)
-    user_id: UUID

engine/publisher.py

@@ -17,6 +17,7 @@ def publish_message(event: str, routing_key: str, queue_name: str, **kwargs):
         # Create message payload
         message = {"event": event, **kwargs}
         # Publish message
+
         channel.basic_publish(
             exchange="",
             routing_key=routing_key,

models/entity/orders_entity.py

@@ -1,19 +1,19 @@
 from datetime import datetime
 from typing import Dict, List, Optional
 from uuid import UUID, uuid4
-from sqlmodel import Field, SQLModel
+from sqlalchemy import ARRAY, JSON, Column
+from sqlmodel import Field, SQLModel, table
 
 
-class Order(SQLModel):
+class Order(SQLModel, table=True):
     id: Optional[UUID] = Field(default_factory=uuid4, primary_key=True)
     user_id: UUID = Field(foreign_key="user.id")
     total_price: float = Field(default=0.0)
     status: str = Field(default="pending")
     created_at: datetime = Field(default_factory=datetime.utcnow)
     updated_at: datetime = Field(default_factory=datetime.utcnow)
-    items: List[UUID] = Field(default_factory=list)
+    items: List[str] = Field(
+        sa_column=Field(default_factory=list, sa_column_kwargs={"type_": ARRAY(str)})
+    )
     order_id: UUID = Field(default_factory=uuid4)
     order_date: datetime = Field(default_factory=datetime.utcnow)
-
-    class Config:
-        orm_mode = True

models/service/orders_service.py

@@ -1,26 +1,42 @@
-from typing import List
+import json
+import logging
 from uuid import UUID
 
 from api.validators.order_validation import Order
 from models.db import db_session
 from models.entity.orders_entity import Order as OrderEntity
 
+logger = logging.getLogger(__name__)
+
+
+class UUIDEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, UUID):
+            return str(obj)
+        return super().default(obj)
+
 
 class OrderService:
     def __init__(self):
         pass
 
     def create_order(self, order: Order, current_user: str):
-        order_entity = OrderEntity(
-            order_id=order.order_id,
-            order_date=order.order_date,
-            user_id=current_user.id,
-            items=order.items,
-            total_price=order.total_price,
-            status=order.status,
-        )
-        db_session.add(order_entity)
-        db_session.commit()
+        try:
+            order_entity = OrderEntity(
+                order_date=order.order_date,
+                user_id=current_user.id,
+                items=json.loads(json.dumps(order.items, cls=UUIDEncoder))
+                if order.items
+                else [],
+                total_price=order.total_price,
+                status=order.status,
+            )
+            db_session.add(order_entity)
+            db_session.commit()
+        except Exception as e:
+            logger.error(f"Error creating order: {e}")
+            db_session.rollback()
+            raise e
 
     def get_order_by_id(self, order_id: UUID) -> Order:
         order = (