appointment new changes based on new table format

app/auth/auth.py

@@ -58,12 +58,13 @@ async def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(s
     
     # Extract user information from token
     customer_id = payload.get("sub")
-
+    merchant_id = payload.get("merchant_id")
     
      
     return {
         "sub": customer_id,
-        "payload": payload
+        "payload": payload,
+        "merchant_id": merchant_id
     }
  
  

app/models/appointment.py

@@ -1,5 +1,10 @@
+from decimal import Decimal
+from sqlalchemy.dialects.postgresql import UUID as pgUUID
+import uuid
+from geoalchemy2 import Geography
+from sqlalchemy import func
 from pydantic import BaseModel, Field
-from datetime import datetime, date
+from datetime import datetime, date, time
 from typing import List, Dict, Optional, Any
 import enum  
 import sqlalchemy
@@ -29,158 +34,310 @@ class PaymentMode(str, enum.Enum):
 
 
 # Model for associate assigned to the appointment
-class AssociateDetails(BaseModel):
-    associate_id: str = Field(..., example="STAFF1")
-    name: str = Field(..., example="John Doe")
-
-class Guestdetails(BaseModel):
-    guest_id:str = Field(...,description="guest id")
-    first_name: str =Field(..., description="first name")
-    last_name: str = Field(..., description="Last name")
-
-class Petdetails(BaseModel):
-    pet_id:str = Field(...,description="pet id")
-    pet_name: str = Field(..., description="pet name")
-
-
-# Model for services booked in the appointment
-class ServiceDetails(BaseModel):
-    service_id: str = Field(..., example="SERV1")
-    name: str = Field(..., example="Hair Cut")
-    price: float = Field(..., ge=0, example=500.00)
-    duration: str = Field(..., example="30 minutes")
-    quantity: int = Field(..., ge=1, example=1)  # Quantity must be at least 1
+# class AssociateDetails(BaseModel):
+#     associate_id: str = Field(..., example="STAFF1")
+#     name: str = Field(..., example="John Doe")
+
+# class Guestdetails(BaseModel):
+#     guest_id:str = Field(...,description="guest id")
+#     first_name: str =Field(..., description="first name")
+#     last_name: str = Field(..., description="Last name")
+
+# class Petdetails(BaseModel):
+#     pet_id:str = Field(...,description="pet id")
+#     pet_name: str = Field(..., description="pet name")
+
+
+# # Model for services booked in the appointment
+# class ServiceDetails(BaseModel):
+#     service_id: str = Field(..., example="SERV1")
+#     name: str = Field(..., example="Hair Cut")
+#     price: float = Field(..., ge=0, example=500.00)
+#     duration: str = Field(..., example="30 minutes")
+#     quantity: int = Field(..., ge=1, example=1)  # Quantity must be at least 1
  
 
 
 # Model for Appointment
-class Appointment(BaseModel):
+# class Appointment(BaseModel):
+#     appointment_id: Optional[str] = None
+#     merchant_id: str = Field(..., description="Merchant ID is required")  # ✅ Mandatory
+#     merchant_name: str = Field(..., description="Merchant name is required")  # ✅ Mandatory
+#     city: str = Field(..., description="City is required")  # ✅ Mandatory
+#     merchant_address: Dict[str, Any] = Field(..., description="Merchant address is required")  # ✅ Mandatory
+#     location_id: str
+#     customer_id: Optional[str] = Field(None, description="Customer ID is optional")  # ✅ Optional
+#     appointment_date: Optional[date] = Field(None, description="Appointment date (YYYY-MM-DD)")
+#     appointment_time: str = Field(..., pattern=r"^\d{2}:\d{2}$", description="Appointment time in HH:MM format")
+#     associates: List[AssociateDetails]  # ✅ Using `AssociateDetails` model
+#     guest: Optional[List[Guestdetails]] = Field(None, description="Guest details")
+#     pet: Optional[List[Petdetails]] = Field(None, description="Pet details")
+#     status: AppointmentStatus  # ✅ Using Enum
+#     services: List[ServiceDetails]  # ✅ Using `ServiceDetails` model
+#     notes: Optional[str] = None
+#     total_amount: float = Field(..., gt=0, description="Total amount must be positive")  # ✅ Mandatory
+#     discount: float = Field(default=0.0, ge=0, description="Discount cannot be negative")
+#     payment_mode: PaymentMode = Field(..., description="Payment mode must be ONLINE or OFFLINE")
+#     payment_status: PaymentStatus = PaymentStatus.PENDING  # ✅ Default to "pending"
+#     payment_id: Optional[str] = None
+#     cleared_amount: float = Field(default=0.0, ge=0, description="Cleared amount must be non-negative")
+#     order_id: Optional[str] = Field(None, description="Order ID is required if payment mode is ONLINE")
+#     business_url: Optional[str] = Field(None, description="Business URL")
+#     merchant_category: Optional[str] = Field(None, description="Merchant category")
+
+#     class Config:
+#         json_encoders = {
+#             datetime: lambda v: v.strftime('%Y-%m-%d %H:%M:%S'),
+#             date: lambda v: v.strftime('%Y-%m-%d')
+#         }
+#         json_schema_extra = {
+#             "example": {
+#                 "merchant_id": "MERCHANT123",
+#                 "merchant_name": "Elegant Salon",
+#                 "city": "Mumbai",
+#                 "merchant_address": {
+#                     "line1": "12 High Street",
+#                     "area": "Andheri East",
+#                     "city": "Mumbai",
+#                     "state": "MH",
+#                     "zip_code": "400093"
+#                 },
+#                 "location_id": "LOC001",
+#                 "customer_id": "CUST567",
+#                 "appointment_date": "2025-02-25",
+#                 "appointment_time": "14:30",
+#                 "associates": [
+#                     {
+#                         "associate_id": "STAFF101",
+#                         "name": "John Doe"
+#                     }
+#                 ],
+#                 "guest": [
+#                     {
+#                         "guest_id":"FGYY01",
+#                         "first_name":"John",
+#                         "last_name":"Doe"
+#                     }
+#                 ],
+#                 "pet":[
+#                     {
+#                         "pet_id":"GHUU01",
+#                         "pet_name":"Buddy"
+#                     }
+#                 ],   
+#                 "status": "confirmed",  
+#                 "services": [
+#                     {
+#                         "service_id": "SERV001",
+#                         "name": "Haircut",
+#                         "price": 50.0,
+#                         "quantity": 1,
+#                         "duration": "30 minutes"
+#                     }
+#                 ],
+#                 "notes": "Customer prefers short haircut",
+#                 "total_amount": 50.0,
+#                 "discount": 5.0,
+#                 "payment_mode": "online",   
+#                 "payment_status": "paid",   
+#                 "payment_id": "pay_789xyz",
+#                 "cleared_amount": 45.0,
+#                 "order_id": "order_789xyz",
+#                 "business_url":"johnson-gomez-and-fleming",
+#                 "merchant_category": "spa"
+ 
+#             }
+#         }
+
+class GeoCoordinates(BaseModel):
+    type: str = Field(..., example="Point")
+    coordinates: List[float] = Field(..., min_items=2, max_items=2)
+
+class MerchantAddress(BaseModel):
+    street: str
+    postcode: str
+    state: str
+    location: GeoCoordinates
+    area: Optional[str] = None
+
+
+class ServiceCreate(BaseModel):
+    service_id: str
+    name: str
+    duration: str  # Example: "50 minutes"
+    price: Decimal
+    quantity: int
+    associate_name: str
+    associate_id: str
+
+
+class AppointmentCreateRequest(BaseModel):
+    merchant_id: Optional[str] = None 
+    customer_id: Optional[str] = None
     appointment_id: Optional[str] = None
-    merchant_id: str = Field(..., description="Merchant ID is required")  # ✅ Mandatory
-    merchant_name: str = Field(..., description="Merchant name is required")  # ✅ Mandatory
-    city: str = Field(..., description="City is required")  # ✅ Mandatory
-    merchant_address: Dict[str, Any] = Field(..., description="Merchant address is required")  # ✅ Mandatory
+    merchant_name: str
+    merchant_address: MerchantAddress
+
+    city: str
     location_id: str
-    customer_id: Optional[str] = Field(None, description="Customer ID is optional")  # ✅ Optional
-    appointment_date: Optional[date] = Field(None, description="Appointment date (YYYY-MM-DD)")
-    appointment_time: str = Field(..., pattern=r"^\d{2}:\d{2}$", description="Appointment time in HH:MM format")
-    associates: List[AssociateDetails]  # ✅ Using `AssociateDetails` model
-    guest: Optional[List[Guestdetails]] = Field(None, description="Guest details")
-    pet: Optional[List[Petdetails]] = Field(None, description="Pet details")
-    status: AppointmentStatus  # ✅ Using Enum
-    services: List[ServiceDetails]  # ✅ Using `ServiceDetails` model
-    notes: Optional[str] = None
-    total_amount: float = Field(..., gt=0, description="Total amount must be positive")  # ✅ Mandatory
-    discount: float = Field(default=0.0, ge=0, description="Discount cannot be negative")
-    payment_mode: PaymentMode = Field(..., description="Payment mode must be ONLINE or OFFLINE")
-    payment_status: PaymentStatus = PaymentStatus.PENDING  # ✅ Default to "pending"
+
+    appointment_date: date
+    appointment_time: str  # HH:MM format
+
+    services: List[ServiceCreate]
+
+    status: str
+    notes: Optional[str] = ""
+
+    total_amount: Decimal
+    discount: Decimal
+    cleared_amount: Decimal
+
+    payment_mode: str
+    payment_status: str
     payment_id: Optional[str] = None
-    cleared_amount: float = Field(default=0.0, ge=0, description="Cleared amount must be non-negative")
-    order_id: Optional[str] = Field(None, description="Order ID is required if payment mode is ONLINE")
-    business_url: Optional[str] = Field(None, description="Business URL")
-    merchant_category: Optional[str] = Field(None, description="Merchant category")
+    order_id: Optional[str] = None
 
-    class Config:
-        json_encoders = {
-            datetime: lambda v: v.strftime('%Y-%m-%d %H:%M:%S'),
-            date: lambda v: v.strftime('%Y-%m-%d')
-        }
-        json_schema_extra = {
-            "example": {
-                "merchant_id": "MERCHANT123",
-                "merchant_name": "Elegant Salon",
-                "city": "Mumbai",
-                "merchant_address": {
-                    "line1": "12 High Street",
-                    "area": "Andheri East",
-                    "city": "Mumbai",
-                    "state": "MH",
-                    "zip_code": "400093"
-                },
-                "location_id": "LOC001",
-                "customer_id": "CUST567",
-                "appointment_date": "2025-02-25",
-                "appointment_time": "14:30",
-                "associates": [
-                    {
-                        "associate_id": "STAFF101",
-                        "name": "John Doe"
-                    }
-                ],
-                "guest": [
-                    {
-                        "guest_id":"FGYY01",
-                        "first_name":"John",
-                        "last_name":"Doe"
-                    }
-                ],
-                "pet":[
-                    {
-                        "pet_id":"GHUU01",
-                        "pet_name":"Buddy"
-                    }
-                ],   
-                "status": "confirmed",  
-                "services": [
-                    {
-                        "service_id": "SERV001",
-                        "name": "Haircut",
-                        "price": 50.0,
-                        "quantity": 1,
-                        "duration": "30 minutes"
-                    }
-                ],
-                "notes": "Customer prefers short haircut",
-                "total_amount": 50.0,
-                "discount": 5.0,
-                "payment_mode": "online",   
-                "payment_status": "paid",   
-                "payment_id": "pay_789xyz",
-                "cleared_amount": 45.0,
-                "order_id": "order_789xyz",
-                "business_url":"johnson-gomez-and-fleming",
-                "merchant_category": "spa"
- 
-            }
-        }
 
 
+class AppointmentModel(BaseModel):
+    appointment_id: str
+    customer_id: str
+
+    merchant_id: str
+    merchant_name: str
 
-# SQLAlchemy Table Definition for Appointments
-appointment_table = sqlalchemy.Table(
-    "appointments",
+    city: Optional[str] = None
+    location_id: Optional[str] = None
+
+    # Address Snapshot
+    address_street: Optional[str] = None
+    address_area: Optional[str] = None
+    address_in_tcode: Optional[str] = None
+    address_state: Optional[str] = None
+
+    # Geo location (GeoJSON format)
+    geo_location: Optional[Dict[str, Any]] = None
+
+    appointment_date: date
+    appointment_time: time
+
+    status: str
+
+    total_amount: Decimal
+    discount_amount: Optional[Decimal] = Decimal("0.00")
+    cleared_amount: Decimal
+
+    payment_status: Optional[str] = None
+    payment_mode: Optional[str] = None
+
+    notes: Optional[str] = None
+
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        orm_mode = True
+
+# NEW UPDATED SCHEMA - REPLACES `appointment_table`
+in_appointments_table = sqlalchemy.Table(
+    "in_appointments",
     metadata,
-    sqlalchemy.Column("appointment_id", sqlalchemy.String, primary_key=True),
+    sqlalchemy.Column("appointment_id", pgUUID, primary_key=True,),
+
+    sqlalchemy.Column("customer_id", pgUUID, nullable=False),
+
+    sqlalchemy.Column("merchant_id", pgUUID, nullable=False),
     sqlalchemy.Column("merchant_name", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("city", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("merchant_address", sqlalchemy.JSON, nullable=False),
-    sqlalchemy.Column("merchant_id", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("location_id", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("customer_id", sqlalchemy.String, nullable=False),
+
+    sqlalchemy.Column("city", sqlalchemy.String, nullable=True),
+    sqlalchemy.Column("location_id", sqlalchemy.String, nullable=True),
+
+    # Address Snapshot Columns
+    sqlalchemy.Column("address_street", sqlalchemy.String, nullable=True),
+    sqlalchemy.Column("address_area", sqlalchemy.String, nullable=True),
+    sqlalchemy.Column("address_in_tcode", sqlalchemy.String, nullable=True),
+    sqlalchemy.Column("address_state", sqlalchemy.String, nullable=True),
+
+    # Geo Location (PostGIS Geography Point)
+    sqlalchemy.Column("geo_location", Geography(geometry_type="POINT", srid=4326), nullable=True),
+
     sqlalchemy.Column("appointment_date", sqlalchemy.Date, nullable=False),
-    sqlalchemy.Column("appointment_time", sqlalchemy.String(20), nullable=False),  # HH:MM format
-    sqlalchemy.Column("associates", sqlalchemy.JSON, nullable=False),  # JSON array
-    sqlalchemy.Column("guest", sqlalchemy.JSON, nullable=False),  # JSON array
-    sqlalchemy.Column("pet", sqlalchemy.JSON, nullable=False),  # JSON array
-    sqlalchemy.Column("status", sqlalchemy.Enum(AppointmentStatus, native_enum=False, values_callable=lambda enum: [e.value for e in enum]), nullable=False),
-    sqlalchemy.Column("services", sqlalchemy.JSON, nullable=False),  # JSON array
+    sqlalchemy.Column("appointment_time", sqlalchemy.Time, nullable=False),
+
+    sqlalchemy.Column("status", sqlalchemy.String, nullable=False),
+
+    sqlalchemy.Column("total_amount", sqlalchemy.Numeric(12, 2), nullable=False),
+    sqlalchemy.Column("discount_amount", sqlalchemy.Numeric(12, 2), nullable=True, default=0),
+    sqlalchemy.Column("cleared_amount", sqlalchemy.Numeric(12, 2), nullable=False),
+
+    sqlalchemy.Column("payment_status", sqlalchemy.String, nullable=True),
+    sqlalchemy.Column("payment_mode", sqlalchemy.String, nullable=True),
+
     sqlalchemy.Column("notes", sqlalchemy.Text, nullable=True),
-    sqlalchemy.Column("total_amount", sqlalchemy.Numeric(10, 2), nullable=False),  # Numeric with 2 decimal places
-    sqlalchemy.Column("discount", sqlalchemy.Numeric(10, 2), nullable=True, default=0.0),  # Default discount is 0.0
-    sqlalchemy.Column("payment_mode", sqlalchemy.Enum(PaymentMode, native_enum=False, values_callable=lambda enum: [e.value for e in enum]), nullable=False),
-    sqlalchemy.Column("payment_status", sqlalchemy.Enum(PaymentStatus, native_enum=False, values_callable=lambda enum: [e.value for e in enum]), default=PaymentStatus.PENDING.value, nullable=False),
-    #sqlalchemy.Column("payment_status", sqlalchemy.Enum(PaymentStatus), nullable=False, default="pending"),
-    sqlalchemy.Column("payment_id", sqlalchemy.String, nullable=True),  # ✅ Added payment_id column
-    sqlalchemy.Column("cleared_amount", sqlalchemy.Numeric(10, 2), nullable=False, default=0.0),
-    sqlalchemy.Column("order_id", sqlalchemy.String, nullable=True),  # ✅ Added order_id column
-    #sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), nullable=False),
-    #sqlalchemy.Column("modified_at", sqlalchemy.DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc), nullable=False),
-    sqlalchemy.Column("cancel_reason", sqlalchemy.String, nullable=True),  # ✅ Added cancel_reason column
-    sqlalchemy.Column("business_url", sqlalchemy.String, nullable=True),
-    sqlalchemy.Column("merchant_category", sqlalchemy.String, nullable=True)
+    sqlalchemy.Column("reason", sqlalchemy.Text, nullable=True),
+
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True),
+                      server_default=func.now(), nullable=False),
+
+    sqlalchemy.Column("updated_at", sqlalchemy.DateTime(timezone=True),
+                      server_default=func.now(),
+                      onupdate=func.now(), nullable=False)
+
+)
+
+in_appointment_services_table = sqlalchemy.Table(
+    "in_appointment_services",
+    metadata,
+    sqlalchemy.Column("appointment_service_id", pgUUID, primary_key=True, default=uuid.uuid4),
+    sqlalchemy.Column("appointment_id", pgUUID, nullable=False),
+    sqlalchemy.Column("service_id", pgUUID, nullable=False),
+    sqlalchemy.Column("service_name", sqlalchemy.String, nullable=False),
+    sqlalchemy.Column("duration_minutes", sqlalchemy.String, nullable=False),  # e.g., "50 minutes"
+    sqlalchemy.Column("unit_price", sqlalchemy.Numeric(12, 2), nullable=False),
+    sqlalchemy.Column("quantity", sqlalchemy.Integer, nullable=False),
+    sqlalchemy.Column("line_total", sqlalchemy.Numeric(12, 2), nullable=False),
+    sqlalchemy.Column("associate_name", sqlalchemy.String, nullable=False),
+    sqlalchemy.Column("associate_id", pgUUID, nullable=False),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), server_default=func.now(), nullable=False),
 )
 
 
+# SQLAlchemy Table Definition for Appointments
+# appointment_table = sqlalchemy.Table(
+#     "appointments",
+#     metadata,
+#     sqlalchemy.Column("appointment_id", sqlalchemy.String, primary_key=True),
+#     sqlalchemy.Column("merchant_name", sqlalchemy.String, nullable=False),
+#     sqlalchemy.Column("city", sqlalchemy.String, nullable=False),
+#     sqlalchemy.Column("merchant_address", sqlalchemy.JSON, nullable=False),
+#     sqlalchemy.Column("merchant_id", sqlalchemy.String, nullable=False),
+#     sqlalchemy.Column("location_id", sqlalchemy.String, nullable=False),
+#     sqlalchemy.Column("customer_id", sqlalchemy.String, nullable=False),
+#     sqlalchemy.Column("appointment_date", sqlalchemy.Date, nullable=False),
+#     sqlalchemy.Column("appointment_time", sqlalchemy.String(20), nullable=False),  # HH:MM format
+#     sqlalchemy.Column("associates", sqlalchemy.JSON, nullable=False),  # JSON array
+#     sqlalchemy.Column("guest", sqlalchemy.JSON, nullable=False),  # JSON array
+#     sqlalchemy.Column("pet", sqlalchemy.JSON, nullable=False),  # JSON array
+#     sqlalchemy.Column("status", sqlalchemy.Enum(AppointmentStatus, native_enum=False, values_callable=lambda enum: [e.value for e in enum]), nullable=False),
+#     sqlalchemy.Column("services", sqlalchemy.JSON, nullable=False),  # JSON array
+#     sqlalchemy.Column("notes", sqlalchemy.Text, nullable=True),
+#     sqlalchemy.Column("total_amount", sqlalchemy.Numeric(10, 2), nullable=False),  # Numeric with 2 decimal places
+#     sqlalchemy.Column("discount", sqlalchemy.Numeric(10, 2), nullable=True, default=0.0),  # Default discount is 0.0
+#     sqlalchemy.Column("payment_mode", sqlalchemy.Enum(PaymentMode, native_enum=False, values_callable=lambda enum: [e.value for e in enum]), nullable=False),
+#     sqlalchemy.Column("payment_status", sqlalchemy.Enum(PaymentStatus, native_enum=False, values_callable=lambda enum: [e.value for e in enum]), default=PaymentStatus.PENDING.value, nullable=False),
+#     #sqlalchemy.Column("payment_status", sqlalchemy.Enum(PaymentStatus), nullable=False, default="pending"),
+#     sqlalchemy.Column("payment_id", sqlalchemy.String, nullable=True),  # ✅ Added payment_id column
+#     sqlalchemy.Column("cleared_amount", sqlalchemy.Numeric(10, 2), nullable=False, default=0.0),
+#     sqlalchemy.Column("order_id", sqlalchemy.String, nullable=True),  # ✅ Added order_id column
+#     #sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), nullable=False),
+#     #sqlalchemy.Column("modified_at", sqlalchemy.DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc), nullable=False),
+#     sqlalchemy.Column("cancel_reason", sqlalchemy.String, nullable=True),  # ✅ Added cancel_reason column
+#     sqlalchemy.Column("business_url", sqlalchemy.String, nullable=True),
+#     sqlalchemy.Column("merchant_category", sqlalchemy.String, nullable=True)
+# )
+
+
 # Response Model for Appointments
 class AppointmentResponse(BaseModel):
     appointment_id: str
@@ -193,21 +350,13 @@ class AppointmentResponse(BaseModel):
     appointment_date: str
     appointment_time: str
     status: str
-    associates: List[Dict[str, Any]]
-    guest:  List[Dict[str, Any]]
-    pet:  List[Dict[str, Any]]
     services: List[Dict[str, Any]]
     notes: Optional[str]
     total_amount: float
     discount: float
     payment_mode: str
     payment_status: str
-    payment_id: Optional[str]  # ✅ Included payment_id
     cleared_amount: float
-    order_id: Optional[str] = None  # ✅ Included order as optional with default
-    cancel_reason: Optional[str]  # ✅ Included cancel_reason
-    business_url: Optional[str]
-    merchant_category: Optional[str]
 
 
 

app/repositories/appointment.py

@@ -1,9 +1,11 @@
 from typing import Tuple, Optional, List, Dict, Union
-from app.models.appointment import appointment_table, Appointment
+from app.models.appointment import AppointmentModel, AppointmentCreateRequest, in_appointments_table, in_appointment_services_table
 from app.core.sql_config import database
 from app.utils.performance_metrics import monitor_db_operation
 from app.utils.database import (
     serialize_appointment,
+    to_in_appointments_db,
+    to_in_appointments_services_db,
     validate_query_result,
     validate_existing_appointment,
 )
@@ -16,30 +18,52 @@ from sqlalchemy import func, insert
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-async def create_appointment(appointment: Appointment):
-    """Creates an appointment, handling both online and offline payments."""
+async def create_appointment(appointment: AppointmentCreateRequest):
+    """Creates an appointment with services in a single safe transaction."""
+
     try:
-        # Convert appointment object to dictionary before inserting into DB
-        appointment_data = appointment.dict()
+  
+        # Extract services
+        appointment_services = appointment.services
+
+        # Convert appointment to DB payload
+        appointment_data = to_in_appointments_db(appointment)
+
+        logger.info(f"📌 Appointment Insert Data: {appointment_data}")
+
+        # Begin transaction
+        async with database.transaction():
+
+            # Insert Appointment (Parent)
+            await database.execute(insert(in_appointments_table).values(**appointment_data))
+            logger.info(f"🟢 Appointment inserted: {appointment.appointment_id}")
 
-        logger.info(f"🛠️ Pre-insert status: {appointment_data['status']} (Type: {type(appointment_data['status'])})")
-        logger.info(f"📌 Creating appointment: {appointment_data}")
+            # Prepare & Insert Service Line Items (Child)
+            service_rows = to_in_appointments_services_db(
+                appointment_services,
+                appointment.appointment_id
+            )
 
-        # ✅ Insert into DB correctly
-        result = await database.execute(insert(appointment_table).values(**appointment_data))
+            if service_rows:
+                if len(service_rows) == 1:
+                    logger.info("🟡 Inserting one service row...")
+                    await database.execute(insert(in_appointment_services_table).values(service_rows[0]))
+                else:
+                    logger.info(f"🟡 Bulk inserting {len(service_rows)} service rows...")
+                    await database.execute_many(insert(in_appointment_services_table), service_rows)
 
-        logger.info(f"✅ Appointment stored in DB: {appointment.appointment_id}")
+            logger.info(f"✅ Appointment created successfully: {appointment.appointment_id}")
 
         return {
+            "success": True,
             "appointment_id": appointment.appointment_id,
-            "appointment_details": appointment.dict(exclude_none=True),
+            "message": "Appointment created successfully"
         }
 
-    except HTTPException as e:
-        logger.error(f"❌ HTTP error: {e.detail}")
-        raise e
+    except HTTPException:
+        raise
     except Exception as e:
-        logger.error(f"❌ Unexpected error while creating appointment: {str(e)}")
+        logger.error(f"❌ Unexpected error in create_appointment: {str(e)}")
         raise HTTPException(status_code=500, detail="Failed to create appointment")
 
 
@@ -61,8 +85,8 @@ async def update_appointment(appointment_id: str, update_data: dict):
         validate_existing_appointment(existing_appointment)
         
         query = (
-            appointment_table.update()
-            .where(appointment_table.c.appointment_id == appointment_id)
+            in_appointments_table.update()
+            .where(in_appointments_table.c.appointment_id == appointment_id)
             .values(**update_data)
         )
 
@@ -91,11 +115,11 @@ async def get_appointment_by_id(appointment_id: str):
         dict: The serialized appointment details.
     """
     try:
-        query = appointment_table.select().where(appointment_table.c.appointment_id == appointment_id)
+        query = in_appointments_table.select().where(in_appointments_table.c.appointment_id == appointment_id)
         
         logger.info(f"Fetching appointment: {query}")
 
-        async with monitor_db_operation("SELECT", "appointment"):
+        async with monitor_db_operation("SELECT", "in_appointments_table"):
             result = await database.fetch_one(query)
 
         validate_query_result(result, "Appointment not found.")
@@ -118,9 +142,9 @@ async def get_appointments_by_customer(customer_id: str):
         list: List of serialized appointments.
     """
     try:
-        query = appointment_table.select().where(appointment_table.c.customer_id == customer_id)
-        
-        async with monitor_db_operation("SELECT", "appointment"):
+        query = in_appointments_table.select().where(in_appointments_table.c.customer_id == customer_id)
+
+        async with monitor_db_operation("SELECT", "in_appointments_table"):
             results = await database.fetch_all(query)
 
         if not results:
@@ -146,7 +170,7 @@ async def get_appointments_by_merchant(merchant_id: str):
         list: List of serialized appointments.
     """
     try:
-        query = appointment_table.select().where(appointment_table.c.merchant_id == merchant_id)
+        query = in_appointments_table.select().where(in_appointments_table.c.merchant_id == merchant_id)
         results = await database.fetch_all(query)
 
         if not results:
@@ -173,12 +197,12 @@ async def get_appointments_with_filters(filters: dict):
     """
     try:
         # Build secure query using SQLAlchemy query builder
-        query = appointment_table.select()
+        query = in_appointments_table.select()
         
         # Apply filters safely using SQLAlchemy's where clauses
         for key, value in filters.items():
-            if value and hasattr(appointment_table.c, key):
-                query = query.where(getattr(appointment_table.c, key) == value)
+            if value and hasattr(in_appointments_table.c, key):
+                query = query.where(getattr(in_appointments_table.c, key) == value)
         
         results = await database.fetch_all(query)
 
@@ -218,8 +242,8 @@ async def cancel_appointment(appointment_id: str, update_data: dict):
             raise HTTPException(status_code=400, detail="Cannot cancel a completed appointment.")
 
         query = (
-            appointment_table.update()
-            .where(appointment_table.c.appointment_id == appointment_id)
+            in_appointments_table.update()
+            .where(in_appointments_table.c.appointment_id == appointment_id)
             .values(**update_data)
         )
 
@@ -255,36 +279,80 @@ async def fetch_appointments_from_db(
         logger.info(f"Fetching appointments for customer ID {customer_id} with status {status}")
 
         # Base query for total count
-        count_query = select(func.count()).select_from(appointment_table).where(
-            appointment_table.c.customer_id == customer_id
+        count_query = select(func.count()).select_from(in_appointments_table).where(
+            in_appointments_table.c.customer_id == customer_id
         )
 
         if status:
-            count_query = count_query.where(appointment_table.c.status.in_(status))
+            count_query = count_query.where(in_appointments_table.c.status.in_(status))
 
         total_count_row = await database.fetch_one(count_query)
         total_count = total_count_row[0] if total_count_row else 0
 
 
         # ✅ Always initialize query first
+        # Main Query: JOIN appointment_services
         query = (
-            select(appointment_table)
-            .where(appointment_table.c.customer_id == customer_id)
-            .order_by(appointment_table.c.appointment_date.desc())
+            select(
+                in_appointments_table,
+                in_appointment_services_table.c.service_id,
+                in_appointment_services_table.c.service_name,
+                in_appointment_services_table.c.duration_minutes,
+                in_appointment_services_table.c.unit_price,
+                in_appointment_services_table.c.quantity,
+                in_appointment_services_table.c.line_total,
+                in_appointment_services_table.c.associate_id,
+                in_appointment_services_table.c.associate_name,
+            )
+            .join(
+                in_appointment_services_table,
+                in_appointments_table.c.appointment_id == in_appointment_services_table.c.appointment_id,
+                isouter=True
+            )
+            .where(in_appointments_table.c.customer_id == customer_id)
+            .order_by(
+                in_appointments_table.c.appointment_date.desc(),
+                in_appointments_table.c.appointment_time.desc(),
+            )
             .limit(limit)
             .offset(offset)
         )
 
-
         # ✅ Apply status filter correctly
         if status:
-            query = query.where(appointment_table.c.status.in_(status))
+            query = query.where(in_appointments_table.c.status.in_(status))
 
         appointments = await database.fetch_all(query)
 
-        appointments_dicts = [dict(appointment) for appointment in appointments]
+        
+        # Group by appointment_id
+        appointments_map = {}
+
+        for row in appointments:
+            row = dict(row)
+            aid = row["appointment_id"]
+
+            if aid not in appointments_map:
+                base = {k: row[k] for k in in_appointments_table.columns.keys()}
+                base["services"] = []
+                appointments_map[aid] = base
+
+            if row.get("service_id"):
+                appointments_map[aid]["services"].append(
+                    {
+                        "service_id": row["service_id"],
+                        "service_name": row["service_name"],
+                        "duration": row["duration_minutes"],
+                        "unit_price": float(row["unit_price"]),
+                        "quantity": row["quantity"],
+                        "line_total": float(row["line_total"]),
+                        "associate_id": row["associate_id"],
+                        "associate_name": row["associate_name"],
+                    }
+                )
+
+        return list(appointments_map.values()), total_count
 
-        return appointments_dicts, total_count
 
     except Exception as e:
         logger.error(f"Database error in fetch_appointments_from_db: {str(e)}")

app/routers/appointment.py

@@ -6,7 +6,7 @@ from app.services.appointment import (
     cancel_appointment_service,
     get_appointments_by_customer_id
 )
-from app.models.appointment import Appointment, AppointmentListResponse
+from app.models.appointment import AppointmentCreateRequest, AppointmentListResponse
 from app.services.order import OrderController
 from app.auth import get_current_user
 
@@ -22,7 +22,7 @@ router = APIRouter()
 logger = logging.getLogger(__name__)
 
 @router.post("/appointment")
-async def create_appointment(appointment: Appointment, current_user: dict = Depends(get_current_user)):
+async def create_appointment(appointment: AppointmentCreateRequest, current_user: dict = Depends(get_current_user)):
     """
     API endpoint to create a new appointment and generate a Razorpay order.
 
@@ -36,11 +36,14 @@ async def create_appointment(appointment: Appointment, current_user: dict = Depe
     try:
         # Extract customer_id from current_user token
         customer_id = current_user.get("sub")
+        merchant_id = current_user.get("merchant_id")
+
         if not customer_id:
             raise HTTPException(status_code=401, detail="Invalid token: missing customer ID")
         
         # Set the customer_id in the appointment object
         appointment.customer_id = customer_id
+        appointment.merchant_id = merchant_id if appointment.merchant_id is None else appointment.merchant_id
         
         logger.info(f"Creating a new appointment for customer: {customer_id}")
         return await create_new_appointment(appointment)

app/services/appointment.py

@@ -13,9 +13,11 @@ from app.repositories.appointment import (
 )
 from app.repositories.payment import get_order_by_id
 from app.repositories.cache import invalidate_appointment_cache
-from app.models.appointment import Appointment, AppointmentStatus, PaymentMode, AppointmentListResponse, PaginationMeta, AppointmentResponse, PaymentStatus
+from app.models.appointment import AppointmentCreateRequest, AppointmentStatus, PaymentMode, AppointmentListResponse, PaginationMeta, AppointmentResponse, PaymentStatus
 import string, random
 
+from app.utils.json_utils import format_geo_location
+
 # Initialize logger
 logger = getLogger(__name__)
 
@@ -70,7 +72,7 @@ def generate_appointment_id(business_name: str, city: str, customer_id: str, app
 
 
 
-async def create_new_appointment(appointment: Appointment):
+async def create_new_appointment(appointment: AppointmentCreateRequest):
     """Creates an appointment, handling both online and offline payments."""
     try:
         # ✅ Generate unique appointment ID   
@@ -78,7 +80,6 @@ async def create_new_appointment(appointment: Appointment):
         appointment.appointment_id = generate_appointment_id(appointment.merchant_name, appointment.city, 
                                                              appointment.customer_id, appointment.appointment_date.strftime("%y%m%d"))
 
-        now = datetime.now(timezone.utc)
 
         # ✅ Ensure appointment_date is valid
         if isinstance(appointment.appointment_date, str):
@@ -110,22 +111,32 @@ async def create_new_appointment(appointment: Appointment):
             logger.error("❌ Missing `payment_mode` in request")
             raise HTTPException(status_code=400, detail="Missing payment mode")
 
-        appointment.payment_mode = str(appointment.payment_mode.value).lower()
+        appointment.payment_mode = str(appointment.payment_mode).lower()
+
+        # Online Payments:
+        # When payment_mode is ONLINE, ensure a valid order_id is present.
+        # The Razorpay order is validated before marking the payment as PAID.
+        #
+        # Offline Payments:
+        # When payment_mode is OFFLINE, the default payment status remains PENDING.
+        #
+        # Note: Payment gateway integration will be enabled once finalized.
+        # The below logic will be uncommented when Razorpay is fully configured.
+
 
-        # ✅ Handle online payments
-        if appointment.payment_mode == PaymentMode.ONLINE:
-            if not appointment.order_id:
-                logger.error("❌ Missing order_id for online payment")
-                raise HTTPException(status_code=400, detail="Missing Razorpay Order ID")
+        # if appointment.payment_mode == PaymentMode.ONLINE:
+        #     if not appointment.order_id:
+        #         logger.error("❌ Missing order_id for online payment")
+        #         raise HTTPException(status_code=400, detail="Missing Razorpay Order ID")
 
-            try:
-                razorpay_order = await validate_razorpay_order(appointment.order_id)
-                appointment.payment_status = PaymentStatus.PAID
-            except Exception as e:
-                logger.error(f"❌ Razorpay order validation failed: {str(e)}")
-                raise HTTPException(status_code=400, detail="Invalid or expired Razorpay Order ID")
-        else:
-            appointment.payment_status = PaymentStatus.PENDING 
+        #     try:
+        #         razorpay_order = await validate_razorpay_order(appointment.order_id)
+        #         appointment.payment_status = PaymentStatus.PAID
+        #     except Exception as e:
+        #         logger.error(f"❌ Razorpay order validation failed: {str(e)}")
+        #         raise HTTPException(status_code=400, detail="Invalid or expired Razorpay Order ID")
+        # else:
+        #     appointment.payment_status = PaymentStatus.PENDING 
 
 
         # ✅ Create appointment in DB
@@ -290,7 +301,7 @@ async def cancel_appointment_service(appointment_id: str, cancel_reason: str, cu
     # Update appointment status and add cancellation details
     update_data = {
         "status":  AppointmentStatus.CANCELED.value,
-        "cancel_reason": cancel_reason,
+        "reason": cancel_reason,
         #"modified_at": datetime.now(timezone.utc),
     }
 
@@ -353,44 +364,60 @@ async def get_appointments_by_customer_id(
             status=status_list
         )
         
-
         formatted_appointments = [
             AppointmentResponse(
                 appointment_id=str(appointment.get("appointment_id", "")),
                 merchant_id=str(appointment.get("merchant_id", "")),
-                city=appointment.get("city", ""),
                 customer_id=str(appointment.get("customer_id", "")),
+
                 merchant_name=appointment.get("merchant_name", "Unknown"),
-                merchant_address=appointment.get("merchant_address", "Unknown"),
-                location_id=str(appointment.get("location_id", "")),
+                
+                # Reconstruct merchant address into nested object
+                merchant_address={
+                    "street": appointment.get("address_street"),
+                    "area": appointment.get("address_area"),
+                    "postcode": appointment.get("address_in_tcode"),
+                    "state": appointment.get("address_state"),
+                     "location": format_geo_location(appointment.get("geo_location"))
+                },
 
-                # Ensure date fields are strings
+                city=appointment.get("city", ""),
+                location_id=str(appointment.get("location_id", "")),
                 appointment_date=(
                     appointment["appointment_date"].strftime("%Y-%m-%d")
                     if appointment.get("appointment_date") else ""
                 ),
                 appointment_time=str(appointment.get("appointment_time", "")),
 
-                status=appointment.get("status", "unknown").lower(),
-                associates=appointment.get("associates", []) or [],
-                guest=appointment.get("guest",[]) or [],
-                pet = appointment.get("pet",[]) or [],
-                services=appointment.get("services", []) or [],
+                status=str(appointment.get("status", "unknown")).lower(),
                 notes=appointment.get("notes", ""),
+
                 total_amount=float(appointment.get("total_amount", 0.0)),
-                discount=float(appointment.get("discount", 0.0)),
-                payment_mode=appointment.get("payment_mode", "unknown").lower(),
-                payment_status=appointment.get("payment_status", "Pending"),
-                payment_id=str(appointment.get("payment_id", "")) if appointment.get("payment_id") else None,
-                cleared_amount=float(appointment.get("cleared_amount", 0.0)),                
-                order_id=str(appointment.get("order_id", "")) if appointment.get("order_id") else None,
-                cancel_reason=appointment.get("cancel_reason", ""),
-                business_url=str(appointment.get("business_url","")),
-                merchant_category=str(appointment.get("merchant_category",""))
-            )
-            for appointment in appointments
+                discount=float(appointment.get("discount_amount", 0.0)),
+                cleared_amount=float(appointment.get("cleared_amount", 0.0)),
+
+                payment_mode=str(appointment.get("payment_mode", "unknown")).lower(),
+                payment_status=str(appointment.get("payment_status", "pending")).lower(),
+
+                created_at=str(appointment.get("created_at", "")),
+                updated_at=str(appointment.get("updated_at", "")),
+                services=[
+                    {
+                        "service_id": service.get("service_id"),
+                        "service_name": service.get("service_name"),
+                        "duration": service.get("duration"),
+                        "unit_price": float(service.get("unit_price", 0)),
+                        "quantity": service.get("quantity"),
+                        "line_total": float(service.get("line_total", 0)),
+                        "associate_id": service.get("associate_id"),
+                        "associate_name": service.get("associate_name"),
+                    }
+                    for service in appointment.get("services", [])
+                ]
+            ) for appointment in appointments
         ]
 
+
         response_data = AppointmentListResponse(
             customer_id=customer_id,
             appointments=formatted_appointments,

app/utils/database.py

@@ -1,7 +1,10 @@
 from datetime import datetime, timezone
+import uuid
 from sqlalchemy.sql import text
 from fastapi import HTTPException
 
+from app.models.appointment import AppointmentCreateRequest
+
 def build_filter_query(filters: dict):
     """
     Builds a dynamic SQL filter query based on the provided filter parameters.
@@ -60,34 +63,54 @@ def serialize_appointment(appointment):
     if appointment is None:
         return None
 
-    print("in seralize appointment", appointment)
-
     return {
-        "appointment_id": appointment["appointment_id"],
-        "merchant_id": appointment["merchant_id"],
+        "appointment_id": str(appointment["appointment_id"]),
+        "customer_id": str(appointment["customer_id"]),
+        "merchant_id": str(appointment["merchant_id"]),
         "merchant_name": appointment["merchant_name"],
+
         "city": appointment["city"],
-        "merchant_address": appointment["merchant_address"],
         "location_id": appointment["location_id"],
-        "customer_id": appointment["customer_id"],
-        "appointment_date": appointment["appointment_date"].isoformat() if appointment["appointment_date"] is not None else None,
-        "appointment_time": appointment["appointment_time"].isoformat() if hasattr(appointment["appointment_time"], 'isoformat') else str(appointment["appointment_time"]),
-        "associates": appointment["associates"],
-        "guest":appointment["guest"],
-        "pet":appointment["pet"],
+
+        "merchant_address": {
+            "street": appointment["address_street"],
+            "area": appointment["address_area"],
+            "postcode": appointment["address_in_tcode"],
+            "state": appointment["address_state"]
+        },
+
+        "appointment_date": (
+            appointment["appointment_date"].isoformat()
+            if appointment["appointment_date"] else None
+        ),
+
+        "appointment_time": (
+            appointment["appointment_time"].isoformat()
+            if hasattr(appointment["appointment_time"], "isoformat")
+            else str(appointment["appointment_time"])
+        ),
+
         "status": appointment["status"],
-        "services": appointment["services"],
         "notes": appointment["notes"],
+
         "total_amount": float(appointment["total_amount"]) if appointment["total_amount"] else 0.0,
-        "discount": float(appointment["discount"]) if appointment["discount"] else 0.0,
+        "discount_amount": float(appointment["discount_amount"]) if appointment["discount_amount"] else 0.0,
+        "cleared_amount": float(appointment["cleared_amount"]) if appointment["cleared_amount"] else 0.0,
+
         "payment_mode": appointment["payment_mode"],
         "payment_status": appointment["payment_status"],
-        "payment_id": appointment["payment_id"],
-        "cleared_amount": float(appointment["cleared_amount"]) if appointment["cleared_amount"] else 0.0,
-        "order_id": appointment["order_id"],
-        "cancel_reason": appointment["cancel_reason"],
+
+        "created_at": (
+            appointment["created_at"].isoformat()
+            if appointment["created_at"] else None
+        ),
+        "updated_at": (
+            appointment["updated_at"].isoformat()
+            if appointment["updated_at"] else None
+        ),
     }
 
+
 def validate_existing_appointment(appointment):
     """
     Validates the existing appointment's status for operations.
@@ -114,4 +137,55 @@ def calculate_appointment_duration(services):
     Returns:
         int: Total duration in minutes.
     """
-    return sum(service.get("duration", 0) for service in services)
+    return sum(service.get("duration", 0) for service in services)
+
+def to_in_appointments_db(appointment: AppointmentCreateRequest):
+    return {
+        "appointment_id": appointment.appointment_id,
+        "customer_id": appointment.customer_id,  # You will update later when customer is added
+        "merchant_id": appointment.merchant_id,
+        "merchant_name": appointment.merchant_name,
+        "city": appointment.city,
+        "location_id": appointment.location_id,
+
+        # Extracted from merchant_address
+        "address_street": appointment.merchant_address.street,
+        "address_area": appointment.merchant_address.area,
+        "address_in_tcode": appointment.merchant_address.postcode,
+        "address_state": appointment.merchant_address.state,
+        "geo_location": (
+            f"POINT({appointment.merchant_address.location.coordinates[0]} "
+            f"{appointment.merchant_address.location.coordinates[1]})"
+            if appointment.merchant_address.location else None
+        ),
+
+        "appointment_date": appointment.appointment_date,
+        "appointment_time": appointment.appointment_time,
+
+        "status": appointment.status,
+        "total_amount": appointment.total_amount,
+        "discount_amount": appointment.discount,
+        "cleared_amount": appointment.cleared_amount,
+
+        "payment_status": appointment.payment_status,
+        "payment_mode": appointment.payment_mode,
+
+        "notes": appointment.notes,
+    }
+
+def to_in_appointments_services_db(appointment_services, appointment_id):
+    services_data = []
+    for service in appointment_services:
+        services_data.append({
+            "appointment_service_id":uuid.uuid4(),
+            "appointment_id": appointment_id,
+            "service_id": service.service_id,
+            "service_name": service.name,
+            "duration_minutes": service.duration,
+            "unit_price": service.price,
+            "quantity": service.quantity,
+            "line_total": service.price * service.quantity,
+            "associate_id": service.associate_id,
+            "associate_name": service.associate_name,
+        })
+    return services_data

app/utils/json_utils.py

@@ -4,6 +4,8 @@ Falls back to standard json if orjson is not available.
 """
 import logging
 from typing import Any, Union
+from geoalchemy2.shape import to_shape
+
 
 logger = logging.getLogger(__name__)
 
@@ -98,4 +100,17 @@ async def async_fast_loads(json_str: Union[str, bytes]) -> Any:
 
 async def async_fast_dumps_bytes(obj: Any) -> bytes:
     """Async wrapper for fast_dumps_bytes."""
-    return fast_dumps_bytes(obj)
+    return fast_dumps_bytes(obj)
+
+
+
+def format_geo_location(wkb_element):
+    if not wkb_element:
+        return None
+
+    point = to_shape(wkb_element)  # Convert WKB → Shapely object
+
+    return {
+        "type": "Point",
+        "coordinates": [point.x, point.y]
+    }

requirements.txt

@@ -10,4 +10,5 @@ python-jose[cryptography]==3.3.0
 passlib[bcrypt]==1.7.4
 razorpay==1.4.2
 orjson==3.11.3
-python-dotenv==1.0.0
+python-dotenv==1.0.0
+GeoAlchemy2==0.18.1