cart in redis

app/app.py

@@ -2,7 +2,14 @@ from fastapi import FastAPI
 from app.sql import connect_to_database, disconnect_from_database
 from app.views.appointment_view import router as appointment_router
 from app.views.cart_view import router as cart_router
+import logging
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
 
 app = FastAPI(
     title="Bookings / Appointment Management",
@@ -15,18 +22,22 @@ app = FastAPI(
 async def startup():
     try:
         await connect_to_database()
-        print("Database connected successfully.")
+        logger.info("Database connected successfully.")
+        
+        # Log all registered routes
+        for route in app.router.routes:
+            logger.info(f"Registered route: {route.path}")
     except Exception as e:
-        print(f"Error connecting to the database: {e}")
+        logger.error(f"Error connecting to the database: {e}")
 
 # Shutdown event to close database connection
 @app.on_event("shutdown")
 async def shutdown():
     try:
         await disconnect_from_database()
-        print("Database disconnected successfully.")
+        logger.info("Database disconnected successfully.")
     except Exception as e:
-        print(f"Error disconnecting from the database: {e}")
+        logger.error(f"Error disconnecting from the database: {e}")
 
 # Include appointment router
 app.include_router(

app/controllers/cart_controller.py

@@ -8,23 +8,26 @@ from app.services.cart_service import (
 
 router = APIRouter()
 
-@router.post("/cart/appointment/")
+@router.post("/appointment")
 async def add_to_cart(appointment_cart: AppointmentCart):
-    """
-    API endpoint to add an appointment draft to the cart.
-    """
-    return await add_appointment_to_cart(appointment_cart)
+    try:
+        return await add_appointment_to_cart(
+            user_id=appointment_cart.user_id,
+            appointment_data=appointment_cart.dict()
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to add to cart: {e}")
 
-@router.get("/cart/appointment/{user_id}")
+@router.get("/appointment/{user_id}")
 async def get_from_cart(user_id: str):
-    """
-    API endpoint to retrieve an appointment draft from the cart.
-    """
-    return await retrieve_appointment_from_cart(user_id)
+    try:
+        return await retrieve_appointment_from_cart(user_id)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve from cart: {e}")
 
-@router.delete("/cart/appointment/{user_id}")
+@router.delete("/appointment/{user_id}")
 async def delete_from_cart(user_id: str):
-    """
-    API endpoint to remove an appointment draft from the cart.
-    """
-    return await remove_appointment_from_cart(user_id)
+    try:
+        return await remove_appointment_from_cart(user_id)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to delete from cart: {e}")

app/models/cart_model.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel
-from typing import List
+from pydantic import BaseModel, Field, validator
+from typing import List, Union
 from datetime import timedelta
 
 class Service(BaseModel):
@@ -15,4 +15,13 @@ class AppointmentCart(BaseModel):
     appointment_date: str
     appointment_time: str
     services: List[Service]
-    ttl: timedelta = timedelta(minutes=30)  # Default TTL for drafts
+    ttl: Union[int, str] = Field(default="forever")  # Allow integer or "forever"
+
+    @validator("ttl")
+    def validate_ttl(cls, value):
+        if isinstance(value, int):
+            if value <= 0:
+                raise ValueError("TTL must be a positive integer.")
+        elif value != "forever":
+            raise ValueError("TTL must be a positive integer or 'forever'.")
+        return value

app/repositories/appointment_repository.py

@@ -1,26 +1,170 @@
 from app.models.appointment_model import appointment_table
 from app.sql import database
+from app.utils.appointment_utils import (
+    serialize_appointment,
+    validate_query_result,
+    validate_existing_appointment,
+    build_filter_query,
+)
+from fastapi import HTTPException
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 async def create_appointment(appointment_data: dict):
-    query = appointment_table.insert().values(**appointment_data)
-    return await database.execute(query)
+    """
+    Creates a new appointment in the database.
+
+    Args:
+        appointment_data (dict): The appointment details.
+
+    Returns:
+        str: The ID of the created appointment.
+    """
+    try:
+        query = appointment_table.insert().values(**appointment_data)
+        appointment_id = await database.execute(query)
+        logger.info(f"Appointment created successfully: {appointment_id}")
+        return {"message": "Appointment created successfully", "appointment_id": appointment_id}
+    except Exception as e:
+        logger.error(f"Failed to create appointment: {e}")
+        raise HTTPException(status_code=500, detail="Failed to create appointment.")
 
 async def update_appointment(appointment_id: str, update_data: dict):
-    query = (
-        appointment_table.update()
-        .where(appointment_table.c.appointment_id == appointment_id)
-        .values(**update_data)
-    )
-    return await database.execute(query)
+    """
+    Updates an existing appointment in the database.
+
+    Args:
+        appointment_id (str): The ID of the appointment to update.
+        update_data (dict): The updated fields.
+
+    Returns:
+        dict: Confirmation message.
+    """
+    try:
+        # Validate existing appointment
+        existing_appointment = await get_appointment_by_id(appointment_id)
+        validate_existing_appointment(existing_appointment)
+
+        query = (
+            appointment_table.update()
+            .where(appointment_table.c.appointment_id == appointment_id)
+            .values(**update_data)
+        )
+        result = await database.execute(query)
+
+        if result == 0:
+            logger.warning(f"No rows updated for appointment ID: {appointment_id}")
+            raise HTTPException(status_code=404, detail="Appointment not found.")
+
+        logger.info(f"Appointment updated successfully: {appointment_id}")
+        return {"message": "Appointment updated successfully"}
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Failed to update appointment {appointment_id}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to update appointment.")
 
 async def get_appointment_by_id(appointment_id: str):
-    query = appointment_table.select().where(appointment_table.c.appointment_id == appointment_id)
-    return await database.fetch_one(query)
+    """
+    Fetches an appointment by its ID.
+
+    Args:
+        appointment_id (str): The ID of the appointment.
+
+    Returns:
+        dict: The serialized appointment details.
+    """
+    try:
+        query = appointment_table.select().where(appointment_table.c.appointment_id == appointment_id)
+        result = await database.fetch_one(query)
+
+        validate_query_result(result, "Appointment not found.")
+        logger.info(f"Retrieved appointment: {appointment_id}")
+        return serialize_appointment(result)
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Failed to fetch appointment {appointment_id}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch appointment.")
 
 async def get_appointments_by_customer(customer_id: str):
-    query = appointment_table.select().where(appointment_table.c.customer_id == customer_id)
-    return await database.fetch_all(query)
+    """
+    Fetches all appointments for a specific customer.
+
+    Args:
+        customer_id (str): The ID of the customer.
+
+    Returns:
+        list: List of serialized appointments.
+    """
+    try:
+        query = appointment_table.select().where(appointment_table.c.customer_id == customer_id)
+        results = await database.fetch_all(query)
+
+        if not results:
+            logger.warning(f"No appointments found for customer ID: {customer_id}")
+            raise HTTPException(status_code=404, detail="No appointments found for this customer ID.")
+
+        logger.info(f"Retrieved appointments for customer ID: {customer_id}")
+        return [serialize_appointment(result) for result in results]
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Failed to fetch appointments for customer {customer_id}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch appointments.")
 
 async def get_appointments_by_merchant(merchant_id: str):
-    query = appointment_table.select().where(appointment_table.c.merchant_id == merchant_id)
-    return await database.fetch_all(query)
+    """
+    Fetches all appointments for a specific merchant.
+
+    Args:
+        merchant_id (str): The ID of the merchant.
+
+    Returns:
+        list: List of serialized appointments.
+    """
+    try:
+        query = appointment_table.select().where(appointment_table.c.merchant_id == merchant_id)
+        results = await database.fetch_all(query)
+
+        if not results:
+            logger.warning(f"No appointments found for merchant ID: {merchant_id}")
+            raise HTTPException(status_code=404, detail="No appointments found for this merchant ID.")
+
+        logger.info(f"Retrieved appointments for merchant ID: {merchant_id}")
+        return [serialize_appointment(result) for result in results]
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Failed to fetch appointments for merchant {merchant_id}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch appointments.")
+
+async def get_appointments_with_filters(filters: dict):
+    """
+    Fetches appointments based on dynamic filters.
+
+    Args:
+        filters (dict): The filter conditions.
+
+    Returns:
+        list: List of serialized appointments.
+    """
+    try:
+        filter_query = build_filter_query(filters)
+        query = f"SELECT * FROM appointments WHERE {filter_query}" if filter_query else "SELECT * FROM appointments"
+        results = await database.fetch_all(query, filters)
+
+        if not results:
+            logger.warning("No appointments found matching the filters.")
+            raise HTTPException(status_code=404, detail="No appointments found.")
+
+        logger.info("Retrieved appointments with filters.")
+        return [serialize_appointment(result) for result in results]
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Failed to fetch appointments with filters: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch appointments.")

app/repositories/cart_repository.py

@@ -6,12 +6,35 @@ from app.utils.redis_utils import get_redis_client
 # Get the Redis client
 redis_client = get_redis_client()
 
-async def save_cart_draft(cart_key: str, cart_data: dict, ttl: timedelta):
+async def save_cart_draft(cart_key: str, cart_data: dict, ttl: timedelta = None):
     """
     Save appointment cart as a draft in Redis.
+
+    Args:
+        cart_key (str): The Redis key for the cart.
+        cart_data (dict): The cart data to be saved.
+        ttl (timedelta, optional): The time-to-live for the cart key. Defaults to None (forever).
+
+    Raises:
+        ValueError: If ttl is provided and not a positive duration.
     """
     serialized_data = json.dumps(cart_data)
-    await redis_client.setex(cart_key, ttl, serialized_data)
+
+    try:
+        if ttl is None:
+            # Save the key without expiration (forever)
+            await redis_client.set(cart_key, serialized_data)
+        else:
+            # Validate TTL
+            if not isinstance(ttl, timedelta):
+                raise ValueError("TTL must be a timedelta object.")
+            if ttl.total_seconds() <= 0:
+                raise ValueError("TTL must be a positive duration.")
+
+            # Save the key with an expiration
+            await redis_client.setex(cart_key, int(ttl.total_seconds()), serialized_data)
+    except Exception as e:
+        raise Exception(f"Failed to save cart draft in Redis: {e}")
 
 async def get_cart_draft(cart_key: str):
     """

app/services/appointment_service.py

@@ -1,5 +1,6 @@
 from datetime import datetime, timezone
 from fastapi import HTTPException
+from logging import getLogger
 from app.repositories.appointment_repository import (
     create_appointment,
     update_appointment,
@@ -7,28 +8,93 @@ from app.repositories.appointment_repository import (
 )
 from app.models.appointment_model import Appointment, AppointmentStatus
 
+# Initialize logger
+logger = getLogger(__name__)
+
 async def create_new_appointment(appointment: Appointment):
-    now = datetime.now(timezone.utc)
-    appointment_data = appointment.dict()
-    appointment_data["status"] = AppointmentStatus.confirmed
-    appointment_data["created_at"] = now
-    appointment_data["modified_at"] = now
-    await create_appointment(appointment_data)
-    return {"message": "Appointment created successfully"}
-
-async def reschedule_appointment(appointment_id: str, new_date: datetime, new_time: datetime):
-    existing_appointment = await get_appointment_by_id(appointment_id)
-    if not existing_appointment:
-        raise HTTPException(status_code=404, detail="Appointment not found")
-
-    if existing_appointment["status"] == AppointmentStatus.canceled:
-        raise HTTPException(status_code=400, detail="Cannot reschedule a canceled appointment")
-
-    update_data = {
-        "appointment_date": new_date.date(),
-        "appointment_time": new_time.time(),
-        "status": AppointmentStatus.rescheduled,
-        "modified_at": datetime.now(timezone.utc),
-    }
-    await update_appointment(appointment_id, update_data)
-    return {"message": "Appointment rescheduled successfully"}
+    """
+    Creates a new appointment in the database.
+
+    Args:
+        appointment (Appointment): The appointment details as an Appointment object.
+
+    Returns:
+        dict: Confirmation message.
+    """
+    try:
+        # Get the current timestamp
+        now = datetime.now(timezone.utc)
+        logger.info("Creating new appointment...")
+
+        # Prepare appointment data
+        appointment_data = appointment.dict()
+        appointment_data["status"] = AppointmentStatus.confirmed  # Default status
+        appointment_data["created_at"] = now
+        appointment_data["modified_at"] = now
+
+        # Save the appointment to the database
+        await create_appointment(appointment_data)
+        logger.info(f"Appointment created successfully: {appointment_data['appointment_id']}")
+        return {"message": "Appointment created successfully"}
+    except Exception as e:
+        logger.error(f"Error while creating appointment: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to create appointment: {e}")
+
+
+async def reschedule_appointment(appointment_id: str, new_date: str, new_time: str):
+    """
+    Reschedules an existing appointment.
+
+    Args:
+        appointment_id (str): The ID of the appointment to reschedule.
+        new_date (str): The new date for the appointment in string format (YYYY-MM-DD).
+        new_time (str): The new time for the appointment in string format (HH:MM:SS).
+
+    Returns:
+        dict: Confirmation message.
+    """
+    try:
+        logger.info(f"Rescheduling appointment with ID: {appointment_id}")
+
+        # Validate and parse new_date and new_time into datetime objects
+        new_date_parsed = datetime.strptime(new_date, "%Y-%m-%d")
+        new_time_parsed = datetime.strptime(new_time, "%H:%M:%S").time()
+
+        # Fetch the existing appointment
+        existing_appointment = await get_appointment_by_id(appointment_id)
+        if not existing_appointment:
+            logger.warning(f"Appointment not found: {appointment_id}")
+            raise HTTPException(status_code=404, detail="Appointment not found")
+
+        # Check if the appointment is canceled
+        if existing_appointment["status"] == AppointmentStatus.canceled:
+            logger.warning(f"Attempted to reschedule a canceled appointment: {appointment_id}")
+            raise HTTPException(status_code=400, detail="Cannot reschedule a canceled appointment")
+
+        # Validate reschedule time (e.g., cannot reschedule to a past time)
+        now = datetime.now(timezone.utc)
+        reschedule_datetime = datetime.combine(new_date_parsed.date(), new_time_parsed).replace(tzinfo=timezone.utc)
+        if reschedule_datetime <= now:
+            logger.warning(f"Attempted to reschedule appointment to a past time: {reschedule_datetime}")
+            raise HTTPException(status_code=400, detail="Cannot reschedule to a past time")
+
+        # Update the appointment
+        update_data = {
+            "appointment_date": new_date_parsed.date(),
+            "appointment_time": new_time_parsed,
+            "status": AppointmentStatus.rescheduled,
+            "modified_at": datetime.now(timezone.utc),
+        }
+        await update_appointment(appointment_id, update_data)
+        logger.info(f"Appointment rescheduled successfully: {appointment_id}")
+
+        return {"message": "Appointment rescheduled successfully"}
+    except ValueError as ve:
+        logger.error(f"Invalid date or time format for appointment {appointment_id}: {ve}")
+        raise HTTPException(status_code=400, detail=f"Invalid date or time format: {ve}")
+    except HTTPException as http_exc:
+        logger.error(f"HTTP exception occurred while rescheduling appointment {appointment_id}: {http_exc.detail}")
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Unexpected error while rescheduling appointment {appointment_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to reschedule appointment: {e}")

app/services/cart_service.py

@@ -1,31 +1,104 @@
 from datetime import timedelta
+import json
+import logging
+from fastapi import HTTPException
 from app.models.cart_model import AppointmentCart
 from app.repositories.cart_repository import save_cart_draft, get_cart_draft, delete_cart_draft
 
-async def add_appointment_to_cart(appointment_cart: AppointmentCart):
+# Configure logging
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+async def add_appointment_to_cart(user_id: str, appointment_data: dict):
     """
-    Add an appointment draft to the cart.
+    Add an appointment draft to the cart with optional TTL.
+
+    Args:
+        user_id (str): The ID of the user.
+        appointment_data (dict): The appointment details, including TTL.
+
+    Returns:
+        dict: Confirmation message with cart ID.
     """
-    cart_key = f"cart:{appointment_cart.user_id}"
-    await save_cart_draft(cart_key, appointment_cart.dict(), appointment_cart.ttl)
-    return {"message": "Appointment added to cart as draft.", "cart_id": cart_key}
+    cart_key = f"cart:{user_id}"
+    ttl = appointment_data.get("ttl", "forever")
+
+    try:
+        # Validate user_id
+        if not user_id:
+            raise ValueError("User ID is required.")
+
+        # Validate appointment data
+        if not appointment_data:
+            raise ValueError("Appointment data is required.")
+
+        logger.info(f"Adding appointment to cart for user: {user_id} with TTL: {ttl}")
+
+        # Serialize the data to JSON
+        serialized_data = json.dumps(appointment_data)
+
+        if ttl == "forever":
+            # No expiration for the key
+            await save_cart_draft(cart_key, serialized_data)
+        else:
+            # Validate TTL
+            if not isinstance(ttl, int) or ttl <= 0:
+                raise ValueError("TTL must be a positive integer or 'forever'.")
+
+            # Set key with expiration
+            await save_cart_draft(cart_key, serialized_data, ttl=ttl)
+
+        logger.info(f"Appointment draft added successfully for user: {user_id}")
+        return {"message": "Appointment added to cart successfully", "cart_id": cart_key}
+    except ValueError as e:
+        logger.error(f"Validation error: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Failed to add appointment to cart for user {user_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to add appointment to cart: {e}")
 
 async def retrieve_appointment_from_cart(user_id: str):
     """
     Retrieve an appointment draft from the cart.
+
+    Args:
+        user_id (str): The ID of the user.
+
+    Returns:
+        dict: The appointment draft or a message if not found.
     """
     cart_key = f"cart:{user_id}"
-    cart_data = await get_cart_draft(cart_key)
-    if cart_data:
-        return {"user_id": user_id, "appointment": cart_data}
-    return {"message": "No appointment draft found in the cart."}
+    try:
+        logger.info(f"Retrieving appointment draft for user: {user_id}")
+        cart_data = await get_cart_draft(cart_key)
+        if cart_data:
+            logger.info(f"Appointment draft found for user: {user_id}")
+            return {"user_id": user_id, "appointment": json.loads(cart_data)}
+        logger.info(f"No appointment draft found for user: {user_id}")
+        return {"message": "No appointment draft found in the cart."}
+    except Exception as e:
+        logger.error(f"Failed to retrieve appointment draft for user {user_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve appointment draft: {e}")
 
 async def remove_appointment_from_cart(user_id: str):
     """
     Remove an appointment draft from the cart.
+
+    Args:
+        user_id (str): The ID of the user.
+
+    Returns:
+        dict: Confirmation message or an error message if not found.
     """
     cart_key = f"cart:{user_id}"
-    result = await delete_cart_draft(cart_key)
-    if result:
-        return {"message": "Appointment draft removed from cart."}
-    return {"message": "No appointment draft found to delete."}
+    try:
+        logger.info(f"Removing appointment draft for user: {user_id}")
+        result = await delete_cart_draft(cart_key)
+        if result:
+            logger.info(f"Appointment draft removed successfully for user: {user_id}")
+            return {"message": "Appointment draft removed from cart."}
+        logger.info(f"No appointment draft found to delete for user: {user_id}")
+        return {"message": "No appointment draft found to delete."}
+    except Exception as e:
+        logger.error(f"Failed to remove appointment draft for user {user_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to remove appointment draft: {e}")

app/utils/appointment_utils.py

@@ -0,0 +1,101 @@
+from datetime import datetime, timezone
+from sqlalchemy.sql import text
+from fastapi import HTTPException
+
+def build_filter_query(filters: dict):
+    """
+    Builds a dynamic SQL filter query based on the provided filter parameters.
+
+    Args:
+        filters (dict): A dictionary containing filter conditions.
+
+    Returns:
+        str: The WHERE clause to append to a query.
+    """
+    conditions = []
+    for key, value in filters.items():
+        if value:
+            conditions.append(f"{key} = :{key}")
+    return " AND ".join(conditions)
+
+def validate_query_result(result, error_message="Item not found"):
+    """
+    Validates the query result and raises an HTTPException if no result is found.
+
+    Args:
+        result (dict): The result of the query.
+        error_message (str): The error message to return if the result is None.
+
+    Raises:
+        HTTPException: If the result is None.
+    """
+    if not result:
+        raise HTTPException(status_code=404, detail=error_message)
+
+def validate_datetime_format(datetime_str: str):
+    """
+    Validates if the given string is in proper datetime format (ISO 8601).
+
+    Args:
+        datetime_str (str): The datetime string to validate.
+
+    Raises:
+        HTTPException: If the datetime string is invalid.
+    """
+    try:
+        datetime.fromisoformat(datetime_str)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid datetime format. Use ISO 8601 format.")
+
+def serialize_appointment(appointment):
+    """
+    Serializes an appointment database row into a dictionary.
+
+    Args:
+        appointment (RowProxy): The SQLAlchemy RowProxy object.
+
+    Returns:
+        dict: A serialized dictionary representation of the appointment.
+    """
+    if appointment is None:
+        return None
+
+    return {
+        "appointment_id": appointment["appointment_id"],
+        "merchant_id": appointment["merchant_id"],
+        "customer_id": appointment["customer_id"],
+        "appointment_date": appointment["appointment_date"].isoformat(),
+        "appointment_time": appointment["appointment_time"].isoformat(),
+        "status": appointment["status"],
+        "services": appointment["services"],
+        "created_at": appointment["created_at"].isoformat(),
+        "modified_at": appointment["modified_at"].isoformat(),
+    }
+
+def validate_existing_appointment(appointment):
+    """
+    Validates the existing appointment's status for operations.
+
+    Args:
+        appointment (dict): The appointment data.
+
+    Raises:
+        HTTPException: If the appointment is not found or cannot be modified.
+    """
+    if not appointment:
+        raise HTTPException(status_code=404, detail="Appointment not found.")
+
+    if appointment["status"] == "canceled":
+        raise HTTPException(status_code=400, detail="Cannot modify a canceled appointment.")
+
+def calculate_appointment_duration(services):
+    """
+    Calculates the total duration of the appointment based on its services.
+
+    Args:
+        services (list): A list of services in the appointment.
+
+    Returns:
+        int: Total duration in minutes.
+    """
+    return sum(service.get("duration", 0) for service in services)

app/views/cart_view.py

@@ -1,5 +1,5 @@
 from fastapi import APIRouter
-from app.controllers.cart_controller import router as cart_router
+from app.controllers.cart_controller import router as cart_controller
 
 router = APIRouter()
-router.include_router(cart_router, prefix="/cart", tags=["Cart Management"])
+router.include_router(cart_controller,  prefix="", tags=["Cart Management"])