Refactor appointment service and model; add error handling for fetching appointments and update cancelation logic

app/models/appointment.py

@@ -71,7 +71,7 @@ class Appointment(BaseModel):
             datetime: lambda v: v.strftime('%Y-%m-%d %H:%M:%S'),
             date: lambda v: v.strftime('%Y-%m-%d')
         }
-        schema_extra = {
+        json_schema_extra = {
             "example": {
                 "merchant_id": "MERCHANT123",
                 "merchant_name": "Merchant Name",
@@ -116,13 +116,12 @@ appointment_table = sqlalchemy.Table(
     metadata,
     sqlalchemy.Column("appointment_id", sqlalchemy.String, primary_key=True),
     sqlalchemy.Column("merchant_name", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("merchant_address", sqlalchemy.JSON, nullable=False),  # JSON array
     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("staffs", sqlalchemy.JSON, nullable=True),  # JSON array
+    sqlalchemy.Column("staffs", sqlalchemy.JSON, nullable=False),  # JSON array
     sqlalchemy.Column("status", sqlalchemy.Enum(AppointmentStatus), nullable=False),
     sqlalchemy.Column("services", sqlalchemy.JSON, nullable=False),  # JSON array
     sqlalchemy.Column("notes", sqlalchemy.Text, nullable=True),
@@ -135,7 +134,7 @@ appointment_table = sqlalchemy.Table(
     sqlalchemy.Column("order_id", sqlalchemy.String, nullable=True),  # ✅ Added order_id column
     sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), default=datetime.utcnow, nullable=False),
     sqlalchemy.Column("modified_at", sqlalchemy.DateTime(timezone=True), default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False),
-    sqlalchemy.Column("cancel_reason", sqlalchemy.String, nullable=True)  # ✅ Added cancel_reason column
+    #sqlalchemy.Column("cancel_reason", sqlalchemy.String, nullable=True)  # ✅ Added cancel_reason column
 )
 
 
@@ -159,6 +158,7 @@ class AppointmentResponse(BaseModel):
     cleared_amount: float
     created_at: str
     modified_at: str
+    cancel_reason: Optional[str]  # ✅ Included cancel_reason
 
 
 # Model for Pagination Metadata

app/repositories/appointment.py

@@ -11,6 +11,7 @@ from fastapi import HTTPException
 from sqlalchemy.sql import select
 import logging
 from sqlalchemy import func, insert
+import json
 
 from app.models.appointment import appointment_table, Appointment
 
@@ -280,8 +281,20 @@ async def fetch_appointments_from_db(
 
         logger.info(f"Fetching appointments from DB: {query}")
 
-        appointments = await database.fetch_all(query)
-        return [dict(appointment) for appointment in appointments], total_count
+        try:
+            appointments = await database.fetch_all(query)
+            logger.info(f"Appointments fetched: {appointments}")
+
+            appointments_dicts = [dict(appointment) for appointment in appointments]
+
+            logger.info(f"Retrieved appointments for customer ID {customer_id}: {appointments_dicts}")
+
+
+        except Exception as e:
+            logger.error(f"Database error in fetch_appointments_from_db: {str(e)}")
+            raise HTTPException(status_code=500, detail="Failed to fetch appointments from database.")
+
+        return appointments_dicts, total_count
 
     except Exception as e:
         logger.error(f"Database error in fetch_appointments_from_db: {str(e)}")

app/services/appointment.py

@@ -201,7 +201,7 @@ async def cancel_appointment_service(appointment_id: str, cancel_reason: str):
 
 
     # Ensure the appointment is not already canceled
-    if existing_appointment["status"] == "canceled":
+    if existing_appointment["status"] == AppointmentStatus.CANCELED.value:
         raise HTTPException(status_code=400, detail="Appointment is already canceled")
 
     # Ensure the appointment is not in the past
@@ -227,8 +227,11 @@ async def cancel_appointment_service(appointment_id: str, cancel_reason: str):
     await cancel_appointment(appointment_id, update_data)
     logger.info(f"Appointment canceled successfully: {appointment_id}")
     
-    # Post message for wallet refund
-    # Post message for email notification
+    # Implement wallet refund logic here
+    #await post_wallet_refund_message(appointment_id)
+
+    # Implement email notification logic here
+    #await send_notification(appointment_id)
 
     return {"message": "Appointment canceled successfully", "appointment_id": appointment_id}
 
@@ -266,12 +269,16 @@ async def get_appointments_by_customer_id(
         }
         status_list = status_mapping.get(status.lower()) if status else None
 
+
         appointments, total_count = await fetch_appointments_from_db(
             customer_id=customer_id,
             limit=limit,
             offset=offset,
             status=status_list
         )
+        
+
+        logger.info(f"Retrieved {len(appointments)} appointments for customer ID {customer_id}")
 
         formatted_appointments = [
             AppointmentResponse(
@@ -306,6 +313,7 @@ async def get_appointments_by_customer_id(
                     appointment["modified_at"].strftime("%Y-%m-%d %H:%M:%S")
                     if appointment.get("modified_at") else ""
                 ),
+                cancel_reason=appointment.get("cancel_reason", ""),
             )
             for appointment in appointments
         ]

tests/unit/test_appointment.py

@@ -0,0 +1,179 @@
+import pytest
+from unittest.mock import AsyncMock, patch
+from fastapi import HTTPException
+from datetime import datetime, timezone, date, time
+from uuid import uuid4
+from app.services.appointment import (
+    create_new_appointment,
+    reschedule_appointment,
+    cancel_appointment_service,
+    get_appointment_details,
+    get_appointments_by_customer_id,
+)
+from app.models.appointment import Appointment, AppointmentStatus, PaymentMode, PaymentStatus
+from app.repositories.appointment import (
+    create_appointment,
+    update_appointment,
+    cancel_appointment,
+    get_appointment_by_id,
+    get_order_by_id,
+    fetch_appointments_from_db,
+)
+
+# Mock data
+MOCK_APPOINTMENT_ID = str(uuid4())
+MOCK_CUSTOMER_ID = str(uuid4())
+MOCK_MERCHANT_ID = str(uuid4())
+MOCK_ORDER_ID = "order_123"
+
+# Test data
+TEST_APPOINTMENT = Appointment(
+    appointment_id=MOCK_APPOINTMENT_ID,
+    customer_id=MOCK_CUSTOMER_ID,
+    merchant_id=MOCK_MERCHANT_ID,
+    appointment_date="2023-12-25",
+    appointment_time="10:00",
+    payment_mode=PaymentMode.ONLINE,
+    order_id=MOCK_ORDER_ID,
+)
+
+# Mock functions
+@pytest.fixture
+def mock_create_appointment():
+    with patch("app.repositories.appointment.create_appointment", new_callable=AsyncMock) as mock:
+        yield mock
+
+@pytest.fixture
+def mock_get_order_by_id():
+    with patch("app.repositories.appointment.get_order_by_id", new_callable=AsyncMock) as mock:
+        mock.return_value = {"status": "pending"}
+        yield mock
+
+@pytest.fixture
+def mock_get_appointment_by_id():
+    with patch("app.repositories.appointment.get_appointment_by_id", new_callable=AsyncMock) as mock:
+        yield mock
+
+@pytest.fixture
+def mock_update_appointment():
+    with patch("app.repositories.appointment.update_appointment", new_callable=AsyncMock) as mock:
+        yield mock
+
+@pytest.fixture
+def mock_cancel_appointment():
+    with patch("app.repositories.appointment.cancel_appointment", new_callable=AsyncMock) as mock:
+        yield mock
+
+@pytest.fixture
+def mock_fetch_appointments_from_db():
+    with patch("app.repositories.appointment.fetch_appointments_from_db", new_callable=AsyncMock) as mock:
+        yield mock
+
+# Tests
+@pytest.mark.asyncio
+async def test_create_new_appointment_success(mock_create_appointment, mock_get_order_by_id):
+    result = await create_new_appointment(TEST_APPOINTMENT)
+    assert result["appointment_id"] == MOCK_APPOINTMENT_ID
+    mock_create_appointment.assert_called_once()
+    mock_get_order_by_id.assert_called_once_with(MOCK_ORDER_ID)
+
+@pytest.mark.asyncio
+async def test_create_new_appointment_invalid_order(mock_get_order_by_id):
+    mock_get_order_by_id.return_value = None
+    with pytest.raises(HTTPException) as exc_info:
+        await create_new_appointment(TEST_APPOINTMENT)
+    assert exc_info.value.status_code == 400
+    assert "Invalid Razorpay Order ID" in str(exc_info.value.detail)
+
+@pytest.mark.asyncio
+async def test_reschedule_appointment_success(mock_get_appointment_by_id, mock_update_appointment):
+    mock_get_appointment_by_id.return_value = {
+        "appointment_id": MOCK_APPOINTMENT_ID,
+        "status": AppointmentStatus.CONFIRMED.value,
+        "appointment_date": "2023-12-25",
+        "appointment_time": "10:00:00",
+    }
+    result = await reschedule_appointment(MOCK_APPOINTMENT_ID, "2023-12-26", "11:00:00")
+    assert result["message"] == "Appointment rescheduled successfully"
+    mock_update_appointment.assert_called_once()
+
+@pytest.mark.asyncio
+async def test_reschedule_appointment_past_date(mock_get_appointment_by_id):
+    mock_get_appointment_by_id.return_value = {
+        "appointment_id": MOCK_APPOINTMENT_ID,
+        "status": AppointmentStatus.CONFIRMED.value,
+        "appointment_date": "2023-12-25",
+        "appointment_time": "10:00:00",
+    }
+    with pytest.raises(HTTPException) as exc_info:
+        await reschedule_appointment(MOCK_APPOINTMENT_ID, "2023-12-24", "11:00:00")
+    assert exc_info.value.status_code == 400
+    assert "Cannot reschedule to a past time" in str(exc_info.value.detail)
+
+@pytest.mark.asyncio
+async def test_cancel_appointment_service_success(mock_get_appointment_by_id, mock_cancel_appointment):
+    mock_get_appointment_by_id.return_value = {
+        "appointment_id": MOCK_APPOINTMENT_ID,
+        "status": AppointmentStatus.CONFIRMED.value,
+        "appointment_date": "2023-12-25",
+        "appointment_time": "10:00:00",
+    }
+    result = await cancel_appointment_service(MOCK_APPOINTMENT_ID, "change_of_plans")
+    assert result["message"] == "Appointment canceled successfully"
+    mock_cancel_appointment.assert_called_once()
+
+@pytest.mark.asyncio
+async def test_cancel_appointment_service_already_canceled(mock_get_appointment_by_id):
+    mock_get_appointment_by_id.return_value = {
+        "appointment_id": MOCK_APPOINTMENT_ID,
+        "status": AppointmentStatus.CANCELED.value,
+        "appointment_date": "2023-12-25",
+        "appointment_time": "10:00:00",
+    }
+    with pytest.raises(HTTPException) as exc_info:
+        await cancel_appointment_service(MOCK_APPOINTMENT_ID, "change_of_plans")
+    assert exc_info.value.status_code == 400
+    assert "Appointment is already canceled" in str(exc_info.value.detail)
+
+@pytest.mark.asyncio
+async def test_get_appointment_details_success(mock_get_appointment_by_id):
+    mock_get_appointment_by_id.return_value = {
+        "appointment_id": MOCK_APPOINTMENT_ID,
+        "status": AppointmentStatus.CONFIRMED.value,
+        "appointment_date": "2023-12-25",
+        "appointment_time": "10:00:00",
+    }
+    result = await get_appointment_details(MOCK_APPOINTMENT_ID)
+    assert result["appointment_id"] == MOCK_APPOINTMENT_ID
+
+@pytest.mark.asyncio
+async def test_get_appointments_by_customer_id_success(mock_fetch_appointments_from_db):
+    mock_fetch_appointments_from_db.return_value = (
+        [
+            {
+                "appointment_id": MOCK_APPOINTMENT_ID,
+                "merchant_id": MOCK_MERCHANT_ID,
+                "merchant_name": "Test Merchant",
+                "merchant_address": "123 Test St",
+                "location_id": str(uuid4()),
+                "appointment_date": date(2023, 12, 25),
+                "appointment_time": "10:00:00",
+                "status": "confirmed",
+                "staffs": [],
+                "services": [],
+                "notes": "",
+                "total_amount": 100.0,
+                "discount": 0.0,
+                "payment_status": "Paid",
+                "payment_id": "pay_123",
+                "cleared_amount": 100.0,
+                "created_at": datetime(2023, 12, 1, 10, 0, 0),
+                "modified_at": datetime(2023, 12, 1, 10, 0, 0),
+            }
+        ],
+        1,
+    )
+    result = await get_appointments_by_customer_id(MOCK_CUSTOMER_ID)
+    assert result.customer_id == MOCK_CUSTOMER_ID
+    assert len(result.appointments) == 1
+    assert result.appointments[0].appointment_id == MOCK_APPOINTMENT_ID

tests/unit/test_appointment_service.py

@@ -1,13 +0,0 @@
-import unittest
-from unittest.mock import patch
-from app.services.appointment import reschedule_appointment
-
-class TestAppointmentService(unittest.TestCase):
-    @patch('app.services.appointment.logger')
-    def test_reschedule_appointment_invalid_date(self, mock_logger):
-        response = reschedule_appointment('e4fbbb1a-2858-4d2b-b851-f1be10b0a344', '2025-02-30', '14:30:00')
-        self.assertEqual(response.status_code, 400)
-        mock_logger.error.assert_called_with('Invalid date or time format for appointment e4fbbb1a-2858-4d2b-b851-f1be10b0a344: day is out of range for month')
-
-if __name__ == '__main__':
-    unittest.main()