feat(profiles): add default pet/guest functionality and refactor address model

Implement default pet and guest selection with new endpoints and schema fields
Refactor address model to use embedded documents under customer
Remove contact fields from address schema and simplify validation
Update all related routers and models to support new embedded structure

app/models/address_model.py

@@ -2,22 +2,26 @@ from datetime import datetime
 from typing import Optional, List, Dict, Any
 from bson import ObjectId
 import logging
+import uuid
 
 from app.core.nosql_client import db
 
 logger = logging.getLogger(__name__)
 
 class AddressModel:
-    """Model for managing user delivery addresses"""
-    
-    collection = db["user_addresses"]
-    
+    """Model for managing user delivery addresses embedded under customer documents"""
+
     @staticmethod
     async def create_address(customer_id: str, address_data: Dict[str, Any]) -> Optional[str]:
-        """Create a new address for a user"""
+        """Create a new embedded address for a user inside customers collection"""
         try:
+            from app.models.user_model import BookMyServiceUserModel
+
+            address_id = str(uuid.uuid4())
+            current_time = datetime.utcnow()
+
             address_doc = {
-                "customer_id": customer_id,
+                "address_id": address_id,  # New field for address identification
                 "address_line_1": address_data.get("address_line_1"),
                 "address_line_2": address_data.get("address_line_2", ""),
                 "city": address_data.get("city"),
@@ -27,149 +31,213 @@ class AddressModel:
                 "address_type": address_data.get("address_type", "home"),  # home, work, other
                 "is_default": address_data.get("is_default", False),
                 "landmark": address_data.get("landmark", ""),
-                "contact_name": address_data.get("contact_name", ""),
-                "contact_phone": address_data.get("contact_phone", ""),
-                "created_at": datetime.utcnow(),
-                "updated_at": datetime.utcnow()
+                "created_at": current_time,
+                "updated_at": current_time,
             }
-            
-            # If this is set as default, unset other default addresses
-            if address_doc["is_default"]:
-                await AddressModel.collection.update_many(
-                    {"customer_id": customer_id, "is_default": True},
-                    {"$set": {"is_default": False, "updated_at": datetime.utcnow()}}
-                )
-            
-            result = await AddressModel.collection.insert_one(address_doc)
-            logger.info(f"Created address for user {customer_id}")
-            return str(result.inserted_id)
-            
+
+            # Fetch user doc
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                logger.error(f"User not found for customer_id {customer_id}")
+                return None
+
+            addresses = user.get("addresses", [])
+
+            # If setting default, unset any existing defaults
+            if address_doc.get("is_default"):
+                for a in addresses:
+                    if a.get("is_default"):
+                        a["is_default"] = False
+                        a["updated_at"] = datetime.utcnow()
+            else:
+                # If this is the first address, set default
+                if len(addresses) == 0:
+                    address_doc["is_default"] = True
+
+            addresses.append(address_doc)
+
+            update_result = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"addresses": addresses}}
+            )
+
+            if update_result.modified_count == 0:
+                logger.error(f"Failed to insert embedded address for user {customer_id}")
+                return None
+
+            logger.info(f"Created embedded address for user {customer_id}")
+            return address_doc["address_id"]  # Return the address_id field instead of _id
+
         except Exception as e:
-            logger.error(f"Error creating address for user {customer_id}: {str(e)}")
+            logger.error(f"Error creating embedded address for user {customer_id}: {str(e)}")
             return None
     
     @staticmethod
     async def get_user_addresses(customer_id: str) -> List[Dict[str, Any]]:
-        """Get all addresses for a user"""
+        """Get all embedded addresses for a user from customers collection"""
         try:
-            cursor = AddressModel.collection.find({"customer_id": customer_id}).sort("created_at", -1)
-            addresses = []
-            
-            async for address in cursor:
-                address["_id"] = str(address["_id"])
-                addresses.append(address)
-            
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return []
+
+            addresses = user.get("addresses", [])
+            # Sort by created_at desc and return as-is (no _id field)
+            addresses.sort(key=lambda x: x.get("created_at", datetime.utcnow()), reverse=True)
             return addresses
-            
+
         except Exception as e:
-            logger.error(f"Error getting addresses for user {customer_id}: {str(e)}")
+            logger.error(f"Error getting embedded addresses for user {customer_id}: {str(e)}")
             return []
     
     @staticmethod
     async def get_address_by_id(customer_id: str, address_id: str) -> Optional[Dict[str, Any]]:
-        """Get a specific address by ID for a user"""
+        """Get a specific embedded address by ID for a user"""
         try:
-            address = await AddressModel.collection.find_one({
-                "_id": ObjectId(address_id),
-                "customer_id": customer_id
-            })
-            
-            if address:
-                address["_id"] = str(address["_id"])
-            
-            return address
-            
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return None
+
+            addresses = user.get("addresses", [])
+            
+            for a in addresses:
+                if a.get("address_id") == address_id:
+                    a_copy = dict(a)
+                    # Inject customer_id for backward-compat where used in router
+                    a_copy["customer_id"] = customer_id
+                    return a_copy
+            return None
+
         except Exception as e:
-            logger.error(f"Error getting address {address_id} for user {customer_id}: {str(e)}")
+            logger.error(f"Error getting embedded address {address_id} for user {customer_id}: {str(e)}")
             return None
     
     @staticmethod
     async def update_address(customer_id: str, address_id: str, update_data: Dict[str, Any]) -> bool:
-        """Update an existing address"""
+        """Update an existing embedded address"""
         try:
-            # Prepare update data
-            update_fields = {}
-            allowed_fields = [
-                "address_line_1", "address_line_2", "city", "state", "postal_code", 
-                "country", "address_type", "is_default", "landmark", "contact_name", "contact_phone"
-            ]
-            
-            for field in allowed_fields:
-                if field in update_data:
-                    update_fields[field] = update_data[field]
-            
-            update_fields["updated_at"] = datetime.utcnow()
-            
-            # If setting as default, unset other default addresses
-            if update_fields.get("is_default"):
-                await AddressModel.collection.update_many(
-                    {"customer_id": customer_id, "is_default": True, "_id": {"$ne": ObjectId(address_id)}},
-                    {"$set": {"is_default": False, "updated_at": datetime.utcnow()}}
-                )
-            
-            result = await AddressModel.collection.update_one(
-                {"_id": ObjectId(address_id), "customer_id": customer_id},
-                {"$set": update_fields}
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
+
+            addresses = user.get("addresses", [])
+            
+            updated = False
+            for a in addresses:
+                if a.get("address_id") == address_id:
+                    allowed_fields = [
+                        "address_line_1", "address_line_2", "city", "state", "postal_code",
+                        "country", "address_type", "is_default", "landmark"
+                    ]
+                    for field in allowed_fields:
+                        if field in update_data:
+                            a[field] = update_data[field]
+                    a["updated_at"] = datetime.utcnow()
+                    updated = True
+                    break
+
+            if not updated:
+                return False
+
+            # If setting as default, unset other defaults
+            if update_data.get("is_default"):
+                for a in addresses:
+                    if a.get("address_id") != address_id and a.get("is_default"):
+                        a["is_default"] = False
+                        a["updated_at"] = datetime.utcnow()
+
+            result = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"addresses": addresses}}
             )
-            
             return result.modified_count > 0
-            
+
         except Exception as e:
-            logger.error(f"Error updating address {address_id} for user {customer_id}: {str(e)}")
+            logger.error(f"Error updating embedded address {address_id} for user {customer_id}: {str(e)}")
             return False
     
     @staticmethod
     async def delete_address(customer_id: str, address_id: str) -> bool:
-        """Delete an address"""
+        """Delete an embedded address"""
         try:
-            result = await AddressModel.collection.delete_one({
-                "_id": ObjectId(address_id),
-                "customer_id": customer_id
-            })
-            
-            logger.info(f"Deleted address {address_id} for user {customer_id}")
-            return result.deleted_count > 0
-            
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
+
+            addresses = user.get("addresses", [])
+            # Filter out by new domain id field 'address_id'
+            new_addresses = [a for a in addresses if a.get("address_id") != address_id]
+
+            result = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"addresses": new_addresses}}
+            )
+
+            logger.info(f"Deleted embedded address {address_id} for user {customer_id}")
+            return result.modified_count > 0
+
         except Exception as e:
-            logger.error(f"Error deleting address {address_id} for user {customer_id}: {str(e)}")
+            logger.error(f"Error deleting embedded address {address_id} for user {customer_id}: {str(e)}")
             return False
     
     @staticmethod
     async def get_default_address(customer_id: str) -> Optional[Dict[str, Any]]:
-        """Get the default address for a user"""
+        """Get the default embedded address for a user"""
         try:
-            address = await AddressModel.collection.find_one({
-                "customer_id": customer_id,
-                "is_default": True
-            })
-            
-            if address:
-                address["_id"] = str(address["_id"])
-            
-            return address
-            
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return None
+
+            addresses = user.get("addresses", [])
+            for a in addresses:
+                if a.get("is_default"):
+                    a_copy = dict(a)
+                    a_copy["customer_id"] = customer_id
+                    return a_copy
+            return None
+
         except Exception as e:
-            logger.error(f"Error getting default address for user {customer_id}: {str(e)}")
+            logger.error(f"Error getting default embedded address for user {customer_id}: {str(e)}")
             return None
     
     @staticmethod
     async def set_default_address(customer_id: str, address_id: str) -> bool:
-        """Set an address as default"""
+        """Set an embedded address as default and unset others"""
         try:
-            # First, unset all default addresses for the user
-            await AddressModel.collection.update_many(
-                {"customer_id": customer_id, "is_default": True},
-                {"$set": {"is_default": False, "updated_at": datetime.utcnow()}}
-            )
-            
-            # Then set the specified address as default
-            result = await AddressModel.collection.update_one(
-                {"_id": ObjectId(address_id), "customer_id": customer_id},
-                {"$set": {"is_default": True, "updated_at": datetime.utcnow()}}
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
+
+            addresses = user.get("addresses", [])
+
+            changed = False
+            for a in addresses:
+                if a.get("address_id") == address_id:
+                    if not a.get("is_default"):
+                        a["is_default"] = True
+                        a["updated_at"] = datetime.utcnow()
+                        changed = True
+                else:
+                    if a.get("is_default"):
+                        a["is_default"] = False
+                        a["updated_at"] = datetime.utcnow()
+                        changed = True
+
+            if not changed:
+                # Even if nothing changed, ensure persistence
+                pass
+
+            result = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"addresses": addresses}}
             )
-            
-            return result.modified_count > 0
-            
+            return result.modified_count >= 0
+
         except Exception as e:
-            logger.error(f"Error setting default address {address_id} for user {customer_id}: {str(e)}")
+            logger.error(f"Error setting default embedded address {address_id} for user {customer_id}: {str(e)}")
             return False

app/models/guest_model.py

@@ -9,202 +9,203 @@ from app.utils.db import prepare_for_db
 logger = logging.getLogger(__name__)
 
 class GuestModel:
-    """Model for managing guest profiles in the database"""
+    """Model for managing guest profiles embedded under customer documents"""
     
     @staticmethod
-    async def create_guest(customer_id: str,guest_data:dict) -> Optional[str]:
-        """
-        Create a new guest profile for a user.
-        
-        Args:
-            customer_id: ID of the user creating the guest profile
-            first_name: Guest's first name
-            last_name: Guest's last name
-            email: Guest's email address
-            phone_number: Guest's phone number
-            gender: Guest's gender
-            date_of_birth: Guest's date of birth
-            relationship: Relationship to the user
-            notes: Additional notes about the guest
-            
-        Returns:
-            Guest ID if successful, None otherwise
-        """
+    async def create_guest(customer_id: str, guest_data: dict) -> Optional[str]:
+        """Create a new embedded guest profile under a user in customers collection"""
         try:
-            guests_collection = db.guests
-            
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                logger.error(f"User not found for customer_id {customer_id}")
+                return None
+
             guest_id = str(uuid.uuid4())
             current_time = datetime.utcnow()
-            print("gusest_data",guest_data)
-            
-            guest_data = {
+
+            guest_doc = {
                 "guest_id": guest_id,
-                "customer_id": customer_id,
-                "first_name": guest_data["first_name"],
-                "last_name": guest_data["last_name"],
-                "email": guest_data["email"],
-                "phone_number": guest_data["phone_number"],
-                "gender": guest_data["gender"].value,
-                "date_of_birth": guest_data["date_of_birth"],
-                "relationship": guest_data['relationship'].value,
-                "notes": guest_data['notes'],
+                "first_name": guest_data.get("first_name"),
+                "last_name": guest_data.get("last_name"),
+                "email": guest_data.get("email"),
+                "phone_number": guest_data.get("phone_number"),
+                "gender": getattr(guest_data.get("gender"), "value", guest_data.get("gender")),
+                "date_of_birth": guest_data.get("date_of_birth"),
+                "relationship": getattr(guest_data.get("relationship"), "value", guest_data.get("relationship")),
+                "notes": guest_data.get("notes"),
+                "is_default": guest_data.get("is_default", False),
                 "created_at": current_time,
-                "updated_at": current_time
+                "updated_at": current_time,
             }
 
-            guest_data = prepare_for_db(guest_data)
-            
-            result = await guests_collection.insert_one(guest_data)
-            
-            if result.inserted_id:
+            guests = user.get("guests", [])
+            # Handle default semantics: if setting this guest as default, unset others.
+            if guest_doc.get("is_default"):
+                for existing in guests:
+                    if existing.get("is_default"):
+                        existing["is_default"] = False
+                        existing["updated_at"] = current_time
+            else:
+                # If this is the first guest, make it default by default
+                if len(guests) == 0:
+                    guest_doc["is_default"] = True
+            guests.append(guest_doc)
+
+            update_res = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"guests": guests}}
+            )
+
+            if update_res.modified_count > 0:
                 logger.info(f"Guest created successfully: {guest_id} for user: {customer_id}")
                 return guest_id
             else:
-                logger.error(f"Failed to create guest for user: {customer_id}")
-                return None
-                
+                logger.info(f"Guest creation attempted with no modified_count for user: {customer_id}")
+                return guest_id
+
         except Exception as e:
-            logger.error(f"Error creating guest for user {customer_id}: {str(e)}")
+            logger.error(f"Error creating embedded guest for user {customer_id}: {str(e)}")
             return None
     
     @staticmethod
     async def get_user_guests(customer_id: str) -> List[Dict[str, Any]]:
-        """
-        Get all guests for a specific user.
-        
-        Args:
-            customer_id: ID of the user
-            
-        Returns:
-            List of guest documents
-        """
+        """Get all embedded guests for a specific user from customers collection"""
         try:
-            guests_collection = db.guests
-            
-            cursor = guests_collection.find({"customer_id": customer_id})
-            guests = await cursor.to_list(length=None)
-            
-            # Remove MongoDB's _id field
-            for guest in guests:
-                guest.pop("_id", None)
-            
-            logger.info(f"Retrieved {len(guests)} guests for user: {customer_id}")
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return []
+
+            guests = user.get("guests", [])
+            guests.sort(key=lambda x: x.get("created_at", datetime.utcnow()), reverse=True)
+            for g in guests:
+                g["customer_id"] = customer_id
+            logger.info(f"Retrieved {len(guests)} embedded guests for user: {customer_id}")
             return guests
-            
+
         except Exception as e:
-            logger.error(f"Error getting guests for user {customer_id}: {str(e)}")
+            logger.error(f"Error getting embedded guests for user {customer_id}: {str(e)}")
             return []
     
     @staticmethod
-    async def get_guest_by_id(guest_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get a specific guest by ID.
-        
-        Args:
-            guest_id: ID of the guest
-            
-        Returns:
-            Guest document if found, None otherwise
-        """
+    async def get_guest_by_id(customer_id: str, guest_id: str) -> Optional[Dict[str, Any]]:
+        """Get a specific embedded guest by ID for a user"""
         try:
-            guests_collection = db.guests
-            
-            guest = await guests_collection.find_one({"guest_id": guest_id})
-            
-            if guest:
-                guest.pop("_id", None)
-                logger.info(f"Guest found: {guest_id}")
-                return guest
-            else:
-                logger.warning(f"Guest not found: {guest_id}")
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
                 return None
-                
+
+            guests = user.get("guests", [])
+            for g in guests:
+                if g.get("guest_id") == guest_id:
+                    g_copy = dict(g)
+                    g_copy["customer_id"] = customer_id
+                    logger.info(f"Embedded guest found: {guest_id} for user: {customer_id}")
+                    return g_copy
+            logger.warning(f"Embedded guest not found: {guest_id} for user: {customer_id}")
+            return None
+
         except Exception as e:
-            logger.error(f"Error getting guest {guest_id}: {str(e)}")
+            logger.error(f"Error getting embedded guest {guest_id} for user {customer_id}: {str(e)}")
             return None
     
     @staticmethod
-    async def update_guest(guest_id: str, update_fields: Dict[str, Any]) -> bool:
-        """
-        Update a guest's information.
-        
-        Args:
-            guest_id: ID of the guest to update
-            update_fields: Dictionary of fields to update
-            
-        Returns:
-            True if successful, False otherwise
-        """
+    async def update_guest(customer_id: str, guest_id: str, update_fields: Dict[str, Any]) -> bool:
+        """Update an embedded guest's information under a user"""
         try:
-            guests_collection = db.guests
-            
-            # Add updated timestamp
-            update_fields["updated_at"] = datetime.utcnow()
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
 
-            guest_data = prepare_for_db(update_fields)
-            
-            result = await guests_collection.update_one(
-                {"guest_id": guest_id},
-                {"$set": guest_data}
+            guests = user.get("guests", [])
+            updated = False
+
+            for idx, g in enumerate(guests):
+                if g.get("guest_id") == guest_id:
+                    normalized_updates: Dict[str, Any] = {}
+                    for k, v in update_fields.items():
+                        if hasattr(v, "value"):
+                            normalized_updates[k] = v.value
+                        else:
+                            normalized_updates[k] = v
+
+                    normalized_updates["updated_at"] = datetime.utcnow()
+                    guests[idx] = {**g, **normalized_updates}
+                    updated = True
+                    # If is_default is being set to True, unset default for others
+                    if update_fields.get("is_default"):
+                        for j, other in enumerate(guests):
+                            if other.get("guest_id") != guest_id and other.get("is_default"):
+                                other["is_default"] = False
+                                other["updated_at"] = datetime.utcnow()
+                                guests[j] = other
+                    break
+
+            if not updated:
+                logger.warning(f"Embedded guest not found for update: {guest_id} (user {customer_id})")
+                return False
+
+            result = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"guests": guests}}
             )
-            
+
             if result.modified_count > 0:
-                logger.info(f"Guest updated successfully: {guest_id}")
+                logger.info(f"Embedded guest updated successfully: {guest_id} (user {customer_id})")
                 return True
             else:
-                logger.warning(f"No changes made to guest: {guest_id}")
-                return False
-                
+                logger.info(f"Embedded guest update applied with no modified_count: {guest_id} (user {customer_id})")
+                return True
+
         except Exception as e:
-            logger.error(f"Error updating guest {guest_id}: {str(e)}")
+            logger.error(f"Error updating embedded guest {guest_id} for user {customer_id}: {str(e)}")
             return False
     
     @staticmethod
-    async def delete_guest(guest_id: str) -> bool:
-        """
-        Delete a guest profile.
-        
-        Args:
-            guest_id: ID of the guest to delete
-            
-        Returns:
-            True if successful, False otherwise
-        """
+    async def delete_guest(customer_id: str, guest_id: str) -> bool:
+        """Delete an embedded guest profile under a user"""
         try:
-            guests_collection = db.guests
-            
-            result = await guests_collection.delete_one({"guest_id": guest_id})
-            
-            if result.deleted_count > 0:
-                logger.info(f"Guest deleted successfully: {guest_id}")
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
+
+            guests = user.get("guests", [])
+            new_guests = [g for g in guests if g.get("guest_id") != guest_id]
+            if len(new_guests) == len(guests):
+                logger.warning(f"Embedded guest not found for deletion: {guest_id} (user {customer_id})")
+                return False
+
+            result = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"guests": new_guests}}
+            )
+
+            if result.modified_count > 0:
+                logger.info(f"Embedded guest deleted successfully: {guest_id} (user {customer_id})")
                 return True
             else:
-                logger.warning(f"Guest not found for deletion: {guest_id}")
-                return False
-                
+                logger.info(f"Embedded guest deletion applied with no modified_count: {guest_id} (user {customer_id})")
+                return True
+
         except Exception as e:
-            logger.error(f"Error deleting guest {guest_id}: {str(e)}")
+            logger.error(f"Error deleting embedded guest {guest_id} for user {customer_id}: {str(e)}")
             return False
     
     @staticmethod
     async def get_guest_count_for_user(customer_id: str) -> int:
-        """
-        Get the total number of guests for a user.
-        
-        Args:
-            customer_id: ID of the user
-            
-        Returns:
-            Number of guests
-        """
+        """Get the total number of embedded guests for a user"""
         try:
-            guests_collection = db.guests
-            
-            count = await guests_collection.count_documents({"customer_id": customer_id})
-            return count
-            
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return 0
+            return len(user.get("guests", []))
         except Exception as e:
-            logger.error(f"Error counting guests for user {customer_id}: {str(e)}")
+            logger.error(f"Error counting embedded guests for user {customer_id}: {str(e)}")
             return 0
     
     @staticmethod
@@ -220,15 +221,62 @@ class GuestModel:
             True if guest belongs to user, False otherwise
         """
         try:
-            guests_collection = db.guests
-            
-            guest = await guests_collection.find_one({
-                "guest_id": guest_id,
-                "customer_id": customer_id
-            })
-            
-            return guest is not None
-            
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
+            guests = user.get("guests", [])
+            return any(g.get("guest_id") == guest_id for g in guests)
+        except Exception as e:
+            logger.error(f"Error checking embedded guest ownership {guest_id} for user {customer_id}: {str(e)}")
+            return False
+
+    @staticmethod
+    async def get_default_guest(customer_id: str) -> Optional[Dict[str, Any]]:
+        """Get the default guest for a user"""
+        try:
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return None
+            guests = user.get("guests", [])
+            for g in guests:
+                if g.get("is_default"):
+                    g_copy = dict(g)
+                    g_copy["customer_id"] = customer_id
+                    return g_copy
+            return None
+        except Exception as e:
+            logger.error(f"Error getting default guest for user {customer_id}: {str(e)}")
+            return None
+
+    @staticmethod
+    async def set_default_guest(customer_id: str, guest_id: str) -> bool:
+        """Set a guest as default for a user, unsetting any existing default"""
+        try:
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
+            guests = user.get("guests", [])
+            found = False
+            now = datetime.utcnow()
+            for g in guests:
+                if g.get("guest_id") == guest_id:
+                    g["is_default"] = True
+                    g["updated_at"] = now
+                    found = True
+                else:
+                    if g.get("is_default"):
+                        g["is_default"] = False
+                        g["updated_at"] = now
+            if not found:
+                return False
+            res = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"guests": guests}}
+            )
+            return True
         except Exception as e:
-            logger.error(f"Error checking guest ownership {guest_id} for user {customer_id}: {str(e)}")
+            logger.error(f"Error setting default guest {guest_id} for user {customer_id}: {str(e)}")
             return False

app/models/pet_model.py

@@ -9,209 +9,254 @@ from app.utils.db import prepare_for_db
 logger = logging.getLogger(__name__)
 
 class PetModel:
-    """Model for managing pet profiles in the database"""
+    """Model for managing pet profiles embedded under customer documents"""
     
     @staticmethod
     async def create_pet(
         customer_id: str,
-        pet_data:dict
+        pet_data: dict
     ) -> Optional[str]:
-        """
-        Create a new pet profile for a user.
-        
-        Args:
-            customer_id: ID of the pet owner
-            pet_name: Name of the pet
-            species: Species (Dog, Cat, Other)
-            breed: Breed of the pet
-            date_of_birth: Pet's date of birth
-            age: Pet's age (if DOB not provided)
-            weight: Pet's weight
-            gender: Pet's gender
-            temperament: Pet's temperament
-            health_notes: Health notes including allergies/medications
-            is_vaccinated: Vaccination status
-            pet_photo_url: URL to pet's photo
-            
-        Returns:
-            Pet ID if successful, None otherwise
-        """
+        """Create a new embedded pet profile under a user in customers collection"""
         try:
-            pets_collection = db.pets
-            
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                logger.error(f"User not found for customer_id {customer_id}")
+                return None
+
             pet_id = str(uuid.uuid4())
             current_time = datetime.utcnow()
 
-            
-            pet_data = {
+            pet_doc = {
                 "pet_id": pet_id,
-                "customer_id": customer_id,
-                "pet_name": pet_data['pet_name'],
-                "species": pet_data['species'].value,
-                "breed": pet_data['breed'],
-                "date_of_birth": pet_data['date_of_birth'],
-                "age": pet_data['age'],
-                "weight": pet_data['weight'],
-                "gender": pet_data['gender'].value,
-                "temperament": pet_data['temperament'].value,
-                "health_notes": pet_data['health_notes'],
-                "is_vaccinated": pet_data['is_vaccinated'],
-                "pet_photo_url": pet_data['pet_photo_url'],
+                "pet_name": pet_data.get('pet_name'),
+                "species": getattr(pet_data.get('species'), 'value', pet_data.get('species')),
+                "breed": pet_data.get('breed'),
+                "date_of_birth": pet_data.get('date_of_birth'),
+                "age": pet_data.get('age'),
+                "weight": pet_data.get('weight'),
+                "gender": getattr(pet_data.get('gender'), 'value', pet_data.get('gender')),
+                "temperament": getattr(pet_data.get('temperament'), 'value', pet_data.get('temperament')),
+                "health_notes": pet_data.get('health_notes'),
+                "is_vaccinated": pet_data.get('is_vaccinated'),
+                "pet_photo_url": pet_data.get('pet_photo_url'),
+                "is_default": pet_data.get('is_default', False),
                 "created_at": current_time,
                 "updated_at": current_time
             }
 
-            pet_data = prepare_for_db(pet_data)
-            
-            result = await pets_collection.insert_one(pet_data)
-            
-            if result.inserted_id:
-                logger.info(f"Pet created successfully: {pet_id} for user: {customer_id}")
+            pets = user.get("pets", [])
+            if pet_doc.get("is_default"):
+                for existing in pets:
+                    if existing.get("is_default"):
+                        existing["is_default"] = False
+                        existing["updated_at"] = current_time
+            else:
+                if len(pets) == 0:
+                    pet_doc["is_default"] = True
+            pets.append(pet_doc)
+
+            update_res = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"pets": pets}}
+            )
+
+            if update_res.modified_count > 0:
+                logger.info(f"Embedded pet created successfully: {pet_id} for user: {customer_id}")
                 return pet_id
             else:
-                logger.error(f"Failed to create pet for user: {customer_id}")
-                return None
-                
+                logger.info(f"Embedded pet creation attempted with no modified_count for user: {customer_id}")
+                return pet_id
+
         except Exception as e:
-            logger.error(f"Error creating pet for user {customer_id}: {str(e)}")
+            logger.error(f"Error creating embedded pet for user {customer_id}: {str(e)}")
             return None
     
     @staticmethod
     async def get_user_pets(customer_id: str) -> List[Dict[str, Any]]:
-        """
-        Get all pets for a specific user.
-        
-        Args:
-            customer_id: ID of the pet owner
-            
-        Returns:
-            List of pet documents
-        """
+        """Get all embedded pets for a specific user from customers collection"""
         try:
-            pets_collection = db.pets
-            
-            cursor = pets_collection.find({"customer_id": customer_id})
-            pets = await cursor.to_list(length=None)
-            
-            # Remove MongoDB's _id field
-            for pet in pets:
-                pet.pop("_id", None)
-            
-            logger.info(f"Retrieved {len(pets)} pets for user: {customer_id}")
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return []
+
+            pets = user.get("pets", [])
+            pets.sort(key=lambda x: x.get("created_at", datetime.utcnow()), reverse=True)
+            for p in pets:
+                p["customer_id"] = customer_id
+            logger.info(f"Retrieved {len(pets)} embedded pets for user: {customer_id}")
             return pets
-            
+
         except Exception as e:
-            logger.error(f"Error getting pets for user {customer_id}: {str(e)}")
+            logger.error(f"Error getting embedded pets for user {customer_id}: {str(e)}")
             return []
     
     @staticmethod
-    async def get_pet_by_id(pet_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get a specific pet by ID.
-        
-        Args:
-            pet_id: ID of the pet
-            
-        Returns:
-            Pet document if found, None otherwise
-        """
+    async def get_pet_by_id(customer_id: str, pet_id: str) -> Optional[Dict[str, Any]]:
+        """Get a specific embedded pet by ID for a user"""
         try:
-            pets_collection = db.pets
-            
-            pet = await pets_collection.find_one({"pet_id": pet_id})
-            
-            if pet:
-                pet.pop("_id", None)
-                logger.info(f"Pet found: {pet_id}")
-                return pet
-            else:
-                logger.warning(f"Pet not found: {pet_id}")
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
                 return None
-                
+
+            pets = user.get("pets", [])
+            for p in pets:
+                if p.get("pet_id") == pet_id:
+                    p_copy = dict(p)
+                    p_copy["customer_id"] = customer_id
+                    logger.info(f"Embedded pet found: {pet_id} for user: {customer_id}")
+                    return p_copy
+            logger.warning(f"Embedded pet not found: {pet_id} for user: {customer_id}")
+            return None
+
         except Exception as e:
-            logger.error(f"Error getting pet {pet_id}: {str(e)}")
+            logger.error(f"Error getting embedded pet {pet_id} for user {customer_id}: {str(e)}")
             return None
     
     @staticmethod
-    async def update_pet(pet_id: str, update_fields: Dict[str, Any]) -> bool:
-        """
-        Update a pet's information.
-        
-        Args:
-            pet_id: ID of the pet to update
-            update_fields: Dictionary of fields to update
-            
-        Returns:
-            True if successful, False otherwise
-        """
+    async def update_pet(customer_id: str, pet_id: str, update_fields: Dict[str, Any]) -> bool:
+        """Update an embedded pet's information under a user"""
         try:
-            pets_collection = db.pets
-            
-            # Add updated timestamp
-            update_fields["updated_at"] = datetime.utcnow()
-            
-            pet_data = prepare_for_db(update_fields)
-            
-            result = await pets_collection.update_one(
-                {"pet_id": pet_id},
-                {"$set": pet_data}
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
+
+            pets = user.get("pets", [])
+            updated = False
+
+            for idx, p in enumerate(pets):
+                if p.get("pet_id") == pet_id:
+                    normalized_updates: Dict[str, Any] = {}
+                    for k, v in update_fields.items():
+                        if hasattr(v, "value"):
+                            normalized_updates[k] = v.value
+                        else:
+                            normalized_updates[k] = v
+
+                    normalized_updates["updated_at"] = datetime.utcnow()
+                    pets[idx] = {**p, **normalized_updates}
+                    updated = True
+                    if update_fields.get("is_default"):
+                        for j, other in enumerate(pets):
+                            if other.get("pet_id") != pet_id and other.get("is_default"):
+                                other["is_default"] = False
+                                other["updated_at"] = datetime.utcnow()
+                                pets[j] = other
+                    break
+
+            if not updated:
+                logger.warning(f"Embedded pet not found for update: {pet_id} (user {customer_id})")
+                return False
+
+            result = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"pets": pets}}
             )
-            
+
             if result.modified_count > 0:
-                logger.info(f"Pet updated successfully: {pet_id}")
+                logger.info(f"Embedded pet updated successfully: {pet_id} (user {customer_id})")
                 return True
             else:
-                logger.warning(f"No changes made to pet: {pet_id}")
-                return False
-                
+                logger.info(f"Embedded pet update applied with no modified_count: {pet_id} (user {customer_id})")
+                return True
+
         except Exception as e:
-            logger.error(f"Error updating pet {pet_id}: {str(e)}")
+            logger.error(f"Error updating embedded pet {pet_id} for user {customer_id}: {str(e)}")
             return False
     
     @staticmethod
-    async def delete_pet(pet_id: str) -> bool:
-        """
-        Delete a pet profile.
-        
-        Args:
-            pet_id: ID of the pet to delete
-            
-        Returns:
-            True if successful, False otherwise
-        """
+    async def delete_pet(customer_id: str, pet_id: str) -> bool:
+        """Delete an embedded pet profile under a user"""
         try:
-            pets_collection = db.pets
-            
-            result = await pets_collection.delete_one({"pet_id": pet_id})
-            
-            if result.deleted_count > 0:
-                logger.info(f"Pet deleted successfully: {pet_id}")
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
+
+            pets = user.get("pets", [])
+            new_pets = [p for p in pets if p.get("pet_id") != pet_id]
+            if len(new_pets) == len(pets):
+                logger.warning(f"Embedded pet not found for deletion: {pet_id} (user {customer_id})")
+                return False
+
+            result = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"pets": new_pets}}
+            )
+
+            if result.modified_count > 0:
+                logger.info(f"Embedded pet deleted successfully: {pet_id} (user {customer_id})")
                 return True
             else:
-                logger.warning(f"Pet not found for deletion: {pet_id}")
-                return False
-                
+                logger.info(f"Embedded pet deletion applied with no modified_count: {pet_id} (user {customer_id})")
+                return True
+
         except Exception as e:
-            logger.error(f"Error deleting pet {pet_id}: {str(e)}")
+            logger.error(f"Error deleting embedded pet {pet_id} for user {customer_id}: {str(e)}")
             return False
     
     @staticmethod
     async def get_pet_count_for_user(customer_id: str) -> int:
-        """
-        Get the total number of pets for a user.
-        
-        Args:
-            customer_id: ID of the pet owner
-            
-        Returns:
-            Number of pets
-        """
+        """Get the total number of embedded pets for a user"""
         try:
-            pets_collection = db.pets
-            
-            count = await pets_collection.count_documents({"customer_id": customer_id})
-            return count
-            
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return 0
+            return len(user.get("pets", []))
+        except Exception as e:
+            logger.error(f"Error counting embedded pets for user {customer_id}: {str(e)}")
+            return 0
+
+    @staticmethod
+    async def get_default_pet(customer_id: str) -> Optional[Dict[str, Any]]:
+        """Get the default pet for a user"""
+        try:
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return None
+            pets = user.get("pets", [])
+            for p in pets:
+                if p.get("is_default"):
+                    p_copy = dict(p)
+                    p_copy["customer_id"] = customer_id
+                    return p_copy
+            return None
+        except Exception as e:
+            logger.error(f"Error getting default pet for user {customer_id}: {str(e)}")
+            return None
+
+    @staticmethod
+    async def set_default_pet(customer_id: str, pet_id: str) -> bool:
+        """Set a pet as default for a user, unsetting any existing default"""
+        try:
+            from app.models.user_model import BookMyServiceUserModel
+            user = await BookMyServiceUserModel.collection.find_one({"customer_id": customer_id})
+            if not user:
+                return False
+            pets = user.get("pets", [])
+            found = False
+            now = datetime.utcnow()
+            for p in pets:
+                if p.get("pet_id") == pet_id:
+                    p["is_default"] = True
+                    p["updated_at"] = now
+                    found = True
+                else:
+                    if p.get("is_default"):
+                        p["is_default"] = False
+                        p["updated_at"] = now
+            if not found:
+                return False
+            res = await BookMyServiceUserModel.collection.update_one(
+                {"customer_id": customer_id},
+                {"$set": {"pets": pets}}
+            )
+            return True
         except Exception as e:
-            logger.error(f"Error counting pets for user {customer_id}: {str(e)}")
-            return 0
+            logger.error(f"Error setting default pet {pet_id} for user {customer_id}: {str(e)}")
+            return False

app/routers/address_router.py

@@ -28,18 +28,15 @@ async def get_user_addresses(current_customer_id: str = Depends(get_current_cust
         address_responses = []
         for addr in addresses:
             address_responses.append(AddressResponse(
-                address_id=addr["_id"],
-                customer_id=addr["customer_id"],
+                address_id=addr["address_id"],  # Use the new address_id field
                 address_type=addr["address_type"],
-                contact_name=addr["contact_name"],
-                contact_phone=addr["contact_phone"],
                 address_line_1=addr["address_line_1"],
-                address_line_2=addr.get("address_line_2"),
+                address_line_2=addr.get("address_line_2", ""),
                 city=addr["city"],
                 state=addr["state"],
                 postal_code=addr["postal_code"],
-                country=addr["country"],
-                landmark=addr["landmark"],
+                country=addr.get("country", "India"),
+                landmark=addr.get("landmark", ""),
                 is_default=addr.get("is_default", False),
                 created_at=addr.get("created_at"),
                 updated_at=addr.get("updated_at")
@@ -89,7 +86,7 @@ async def create_address(
         # If this is the first address, make it default
         is_default = len(existing_addresses) == 0 or address_data.is_default
         
-        address_id = await AddressModel.create_address(current_customer_id,address_data.dict())
+        address_id = await AddressModel.create_address(current_customer_id, address_data.dict())
 
         
         if address_id:
@@ -97,19 +94,16 @@ async def create_address(
             created_address = await AddressModel.get_address_by_id(current_customer_id,address_id)
             
             address_response = AddressResponse(
-                address_id=address_id,
-                customer_id=created_address["customer_id"],
+                address_id=created_address["address_id"],  # Use the new address_id field
                 address_type=created_address["address_type"],
-                contact_name=created_address["contact_name"],
-                contact_phone=created_address["contact_phone"],
                 address_line_1=created_address["address_line_1"],
-                address_line_2=created_address.get("address_line_2"),
+                address_line_2=created_address.get("address_line_2", ""),
                 city=created_address["city"],
                 state=created_address["state"],
                 postal_code=created_address["postal_code"],
-                country=created_address["country"],
+                country=created_address.get("country", "India"),
                 is_default=created_address.get("is_default", False),
-                landmark=created_address["landmark"],
+                landmark=created_address.get("landmark", ""),
                 created_at=created_address.get("created_at"),
                 updated_at=created_address.get("updated_at")
             )
@@ -158,10 +152,6 @@ async def update_address(
         
         if address_data.address_type is not None:
             update_fields["address_type"] = address_data.address_type
-        if address_data.contact_name is not None:
-            update_fields["contact_name"] = address_data.contact_name
-        if address_data.contact_phone is not None:
-            update_fields["contact_phone"] = address_data.contact_phone
         if address_data.address_line_1 is not None:
             update_fields["address_line_1"] = address_data.address_line_1
         if address_data.address_line_2 is not None:
@@ -188,18 +178,15 @@ async def update_address(
             updated_address = await AddressModel.get_address_by_id(current_customer_id,address_id)
             
             address_response = AddressResponse(
-                address_id=address_id,
-                customer_id=updated_address["customer_id"],
+                address_id=updated_address["address_id"],  # Use the new address_id field
                 address_type=updated_address["address_type"],
-                contact_name=updated_address["contact_name"],
-                contact_phone=updated_address["contact_phone"],
                 address_line_1=updated_address["address_line_1"],
-                address_line_2=updated_address.get("address_line_2"),
+                address_line_2=updated_address.get("address_line_2", ""),
                 city=updated_address["city"],
                 state=updated_address["state"],
                 postal_code=updated_address["postal_code"],
-                country=updated_address["country"],
-                landmark=updated_address["landmark"],
+                country=updated_address.get("country", "India"),
+                landmark=updated_address.get("landmark", ""),
                 is_default=updated_address.get("is_default", False),
                 created_at=updated_address.get("created_at"),
                 updated_at=updated_address.get("updated_at")
@@ -248,11 +235,12 @@ async def delete_address(
         if existing_address.get("is_default", False):
             # Get other addresses to potentially set a new default
             user_addresses = await AddressModel.get_user_addresses(current_customer_id)
-            other_addresses = [addr for addr in user_addresses if addr["_id"] != address_id]
+            # Compare by new domain id field 'address_id'
+            other_addresses = [addr for addr in user_addresses if addr.get("address_id") != address_id]
             
             if other_addresses:
                 # Set the first other address as default
-                await AddressModel.set_default_address(current_customer_id, other_addresses[0]["_id"])
+                await AddressModel.set_default_address(current_customer_id, other_addresses[0]["address_id"])
         
         success = await AddressModel.delete_address(current_customer_id,address_id)
         
@@ -303,17 +291,16 @@ async def set_default_address(
             
             address_response = AddressResponse(
                 address_id=request.address_id,
-                customer_id=updated_address["customer_id"],
                 address_type=updated_address["address_type"],
-                contact_name=updated_address["contact_name"],
-                contact_phone=updated_address["contact_phone"],
+                contact_name=updated_address.get("contact_name", ""),
+                contact_phone=updated_address.get("contact_phone", ""),
                 address_line_1=updated_address["address_line_1"],
-                address_line_2=updated_address.get("address_line_2"),
+                address_line_2=updated_address.get("address_line_2", ""),
                 city=updated_address["city"],
                 state=updated_address["state"],
                 postal_code=updated_address["postal_code"],
-                country=updated_address["country"],
-                landmark=updated_address["landmark"],
+                country=updated_address.get("country", "India"),
+                landmark=updated_address.get("landmark", ""),
                 is_default=updated_address.get("is_default", False),
                 created_at=updated_address.get("created_at"),
                 updated_at=updated_address.get("updated_at")

app/routers/guest_router.py

@@ -6,7 +6,8 @@ from app.schemas.guest_schema import (
     GuestUpdateRequest, 
     GuestResponse, 
     GuestListResponse, 
-    GuestDeleteResponse
+    GuestDeleteResponse,
+    SetDefaultGuestRequest
 )
 from app.utils.jwt import verify_token
 from typing import Dict, Any
@@ -95,7 +96,7 @@ async def create_guest(
             )
         
         # Retrieve and return the created guest
-        created_guest = await GuestModel.get_guest_by_id(guest_id)
+        created_guest = await GuestModel.get_guest_by_id(customer_id, guest_id)
         if not created_guest:
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -113,6 +114,70 @@ async def create_guest(
             detail="Failed to create guest profile"
         )
 
+@router.get("/guests/default", response_model=GuestResponse)
+async def get_default_guest(
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """Get the default guest for the current user"""
+    try:
+        customer_id = current_user.get("sub")
+        default_guest = await GuestModel.get_default_guest(customer_id)
+        if not default_guest:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Default guest not set"
+            )
+        return GuestResponse(**default_guest)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting default guest for user {customer_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve default guest"
+        )
+
+@router.post("/guests/set-default", response_model=GuestResponse)
+async def set_default_guest(
+    req: SetDefaultGuestRequest,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """Set a guest as default for the current user"""
+    try:
+        customer_id = current_user.get("sub")
+        # Verify guest exists and belongs to user
+        existing_guest = await GuestModel.get_guest_by_id(customer_id, req.guest_id)
+        if not existing_guest:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Guest not found"
+            )
+        if existing_guest.get("customer_id") != customer_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. This guest doesn't belong to you."
+            )
+        success = await GuestModel.set_default_guest(customer_id, req.guest_id)
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to set default guest"
+            )
+        updated_guest = await GuestModel.get_guest_by_id(customer_id, req.guest_id)
+        if not updated_guest:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Default set but failed to retrieve guest"
+            )
+        return GuestResponse(**updated_guest)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error setting default guest {req.guest_id} for user {customer_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to set default guest"
+        )
 @router.put("/guests/{guest_id}", response_model=GuestResponse)
 async def update_guest(
     guest_id: str,
@@ -132,7 +197,7 @@ async def update_guest(
         customer_id=current_user.get("sub")
         
         # Check if guest exists and belongs to user
-        existing_guest = await GuestModel.get_guest_by_id(guest_id)
+        existing_guest = await GuestModel.get_guest_by_id(customer_id, guest_id)
         if not existing_guest:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
@@ -161,7 +226,7 @@ async def update_guest(
             )
         
         # Update guest in database
-        success = await GuestModel.update_guest(guest_id, update_fields)
+        success = await GuestModel.update_guest(customer_id, guest_id, update_fields)
         if not success:
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -169,7 +234,7 @@ async def update_guest(
             )
         
         # Retrieve and return updated guest
-        updated_guest = await GuestModel.get_guest_by_id(guest_id)
+        updated_guest = await GuestModel.get_guest_by_id(customer_id, guest_id)
         if not updated_guest:
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -204,7 +269,7 @@ async def delete_guest(
         customer_id=current_user.get("sub")
         
         # Check if guest exists and belongs to user
-        existing_guest = await GuestModel.get_guest_by_id(guest_id)
+        existing_guest = await GuestModel.get_guest_by_id(customer_id, guest_id)
         if not existing_guest:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
@@ -218,7 +283,7 @@ async def delete_guest(
             )
         
         # Delete guest from database
-        success = await GuestModel.delete_guest(guest_id)
+        success = await GuestModel.delete_guest(customer_id, guest_id)
         if not success:
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,

app/routers/pet_router.py

@@ -6,7 +6,8 @@ from app.schemas.pet_schema import (
     PetUpdateRequest, 
     PetResponse, 
     PetListResponse, 
-    PetDeleteResponse
+    PetDeleteResponse,
+    SetDefaultPetRequest
 )
 from app.utils.jwt import verify_token
 from typing import Dict, Any
@@ -95,7 +96,7 @@ async def create_pet(
             )
         
         # Retrieve and return the created pet
-        created_pet = await PetModel.get_pet_by_id(pet_id)
+        created_pet = await PetModel.get_pet_by_id(customer_id, pet_id)
         if not created_pet:
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -113,6 +114,70 @@ async def create_pet(
             detail="Failed to create pet profile"
         )
 
+@router.get("/pets/default", response_model=PetResponse)
+async def get_default_pet(
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """Get the default pet for the current user"""
+    try:
+        customer_id = current_user.get("sub")
+        default_pet = await PetModel.get_default_pet(customer_id)
+        if not default_pet:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Default pet not set"
+            )
+        return PetResponse(**default_pet)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting default pet for user {customer_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve default pet"
+        )
+
+@router.post("/pets/set-default", response_model=PetResponse)
+async def set_default_pet(
+    req: SetDefaultPetRequest,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """Set a pet as default for the current user"""
+    try:
+        customer_id = current_user.get("sub")
+        # Verify pet exists and belongs to user
+        existing_pet = await PetModel.get_pet_by_id(customer_id, req.pet_id)
+        if not existing_pet:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Pet not found"
+            )
+        if existing_pet.get("customer_id") != customer_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. This pet doesn't belong to you."
+            )
+        success = await PetModel.set_default_pet(customer_id, req.pet_id)
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to set default pet"
+            )
+        updated_pet = await PetModel.get_pet_by_id(customer_id, req.pet_id)
+        if not updated_pet:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Default set but failed to retrieve pet"
+            )
+        return PetResponse(**updated_pet)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error setting default pet {req.pet_id} for user {customer_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to set default pet"
+        )
 @router.put("/pets/{pet_id}", response_model=PetResponse)
 async def update_pet(
     pet_id: str,
@@ -132,7 +197,7 @@ async def update_pet(
         customer_id=current_user.get("sub")
         
         # Check if pet exists and belongs to user
-        existing_pet = await PetModel.get_pet_by_id(pet_id)
+        existing_pet = await PetModel.get_pet_by_id(customer_id, pet_id)
         if not existing_pet:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
@@ -161,7 +226,7 @@ async def update_pet(
             )
         
         # Update pet in database
-        success = await PetModel.update_pet(pet_id, update_fields)
+        success = await PetModel.update_pet(customer_id, pet_id, update_fields)
         if not success:
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -169,7 +234,7 @@ async def update_pet(
             )
         
         # Retrieve and return updated pet
-        updated_pet = await PetModel.get_pet_by_id(pet_id)
+        updated_pet = await PetModel.get_pet_by_id(customer_id, pet_id)
         if not updated_pet:
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -204,7 +269,7 @@ async def delete_pet(
         customer_id=current_user.get("sub")
         
         # Check if pet exists and belongs to user
-        existing_pet = await PetModel.get_pet_by_id(pet_id)
+        existing_pet = await PetModel.get_pet_by_id(customer_id, pet_id)
         if not existing_pet:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
@@ -218,7 +283,7 @@ async def delete_pet(
             )
         
         # Delete pet from database
-        success = await PetModel.delete_pet(pet_id)
+        success = await PetModel.delete_pet(customer_id, pet_id)
         if not success:
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,

app/schemas/address_schema.py

@@ -13,20 +13,12 @@ class AddressCreateRequest(BaseModel):
     address_type: Literal["home", "work", "other"] = Field(default="home", description="Type of address")
     is_default: bool = Field(default=False, description="Set as default address")
     landmark: Optional[str] = Field("", max_length=200, description="Nearby landmark")
-    contact_name: Optional[str] = Field("", max_length=100, description="Contact person name")
-    contact_phone: Optional[str] = Field("", max_length=15, description="Contact phone number")
     
     @validator('postal_code')
     def validate_postal_code(cls, v):
         if not v.isdigit():
             raise ValueError('Postal code must contain only digits')
         return v
-    
-    @validator('contact_phone')
-    def validate_contact_phone(cls, v):
-        if v and not v.isdigit():
-            raise ValueError('Contact phone must contain only digits')
-        return v
 
 class AddressUpdateRequest(BaseModel):
     """Request model for updating an existing address"""
@@ -39,20 +31,12 @@ class AddressUpdateRequest(BaseModel):
     address_type: Optional[Literal["home", "work", "other"]] = Field(None, description="Type of address")
     is_default: Optional[bool] = Field(None, description="Set as default address")
     landmark: Optional[str] = Field(None, max_length=200, description="Nearby landmark")
-    contact_name: Optional[str] = Field(None, max_length=100, description="Contact person name")
-    contact_phone: Optional[str] = Field(None, max_length=15, description="Contact phone number")
     
     @validator('postal_code')
     def validate_postal_code(cls, v):
         if v and not v.isdigit():
             raise ValueError('Postal code must contain only digits')
         return v
-    
-    @validator('contact_phone')
-    def validate_contact_phone(cls, v):
-        if v and not v.isdigit():
-            raise ValueError('Contact phone must contain only digits')
-        return v
 
 class AddressResponse(BaseModel):
     """Response model for address data"""
@@ -66,8 +50,6 @@ class AddressResponse(BaseModel):
     address_type: str = Field(..., description="Type of address")
     is_default: bool = Field(..., description="Is default address")
     landmark: str = Field(..., description="Nearby landmark")
-    contact_name: str = Field(..., description="Contact person name")
-    contact_phone: str = Field(..., description="Contact phone number")
     created_at: datetime = Field(..., description="Address creation timestamp")
     updated_at: datetime = Field(..., description="Address last update timestamp")
     

app/schemas/guest_schema.py

@@ -24,6 +24,7 @@ class GuestCreateRequest(BaseModel):
     date_of_birth: Optional[date] = Field(None, description="Guest's date of birth for age calculation")
     relationship: Optional[RelationshipEnum] = Field(None, description="Relationship to the user")
     notes: Optional[str] = Field(None, max_length=500, description="Additional notes about the guest")
+    is_default: Optional[bool] = Field(None, description="Mark as default guest")
     
     @validator('first_name')
     def validate_first_name(cls, v):
@@ -67,6 +68,7 @@ class GuestUpdateRequest(BaseModel):
     date_of_birth: Optional[date] = Field(None, description="Guest's date of birth for age calculation")
     relationship: Optional[RelationshipEnum] = Field(None, description="Relationship to the user")
     notes: Optional[str] = Field(None, max_length=500, description="Additional notes about the guest")
+    is_default: Optional[bool] = Field(None, description="Mark as default guest")
     
     @validator('first_name')
     def validate_first_name(cls, v):
@@ -112,6 +114,7 @@ class GuestResponse(BaseModel):
     date_of_birth: Optional[date] = Field(None, description="Guest's date of birth")
     relationship: Optional[str] = Field(None, description="Relationship to the user")
     notes: Optional[str] = Field(None, description="Additional notes about the guest")
+    is_default: bool = Field(..., description="Is default guest")
     created_at: datetime = Field(..., description="Guest profile creation timestamp")
     updated_at: datetime = Field(..., description="Guest profile last update timestamp")
     
@@ -152,4 +155,8 @@ class GuestDeleteResponse(BaseModel):
     guest_id: str = Field(..., description="ID of the deleted guest")
     
     class Config:
-        from_attributes = True
+        from_attributes = True
+
+class SetDefaultGuestRequest(BaseModel):
+    """Request model for setting default guest"""
+    guest_id: str = Field(..., description="Guest ID to set as default")

app/schemas/pet_schema.py

@@ -60,6 +60,7 @@ class PetUpdateRequest(BaseModel):
     health_notes: Optional[str] = Field(None, max_length=1000, description="Health notes, allergies, medications")
     is_vaccinated: Optional[bool] = Field(None, description="Vaccination status")
     pet_photo_url: Optional[str] = Field(None, max_length=500, description="URL to pet's photo")
+    is_default: Optional[bool] = Field(None, description="Mark as default pet")
     
     @validator('pet_name')
     def validate_pet_name(cls, v):
@@ -82,6 +83,7 @@ class PetResponse(BaseModel):
     health_notes: Optional[str] = Field(None, description="Health notes, allergies, medications")
     is_vaccinated: bool = Field(..., description="Vaccination status")
     pet_photo_url: Optional[str] = Field(None, description="URL to pet's photo")
+    is_default: bool = Field(..., description="Is default pet")
     created_at: datetime = Field(..., description="Pet profile creation timestamp")
     updated_at: datetime = Field(..., description="Pet profile last update timestamp")
     
@@ -105,4 +107,8 @@ class PetDeleteResponse(BaseModel):
     pet_id: str = Field(..., description="ID of the deleted pet")
     
     class Config:
-        from_attributes = True
+        from_attributes = True
+
+class SetDefaultPetRequest(BaseModel):
+    """Request model for setting default pet"""
+    pet_id: str = Field(..., description="Pet ID to set as default")