feat: add wallet, address, pet and guest management features

- Add new routers for wallet, address, pet and guest management
- Implement models and schemas for each feature
- Add CRUD operations for wallet transactions, addresses, pets and guests
- Include validation and error handling for all new features

app/app.py

@@ -2,7 +2,7 @@
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from app.routers import user_router, profile_router, account_router
+from app.routers import user_router, profile_router, account_router, wallet_router, address_router, pet_router, guest_router
 from app.middleware.rate_limiter import RateLimitMiddleware
 from app.middleware.security_middleware import SecurityMiddleware
 import logging
@@ -48,6 +48,10 @@ app.add_middleware(
 app.include_router(user_router.router, prefix="/auth", tags=["user_auth"])
 app.include_router(profile_router.router, prefix="/profile", tags=["profile"])
 app.include_router(account_router.router, prefix="/account", tags=["account_management"])
+app.include_router(wallet_router.router, prefix="/wallet", tags=["wallet_management"])
+app.include_router(address_router.router, prefix="/addresses", tags=["address_management"])
+app.include_router(pet_router.router, prefix="/api/v1/users", tags=["pet_management"])
+app.include_router(guest_router.router, prefix="/api/v1/users", tags=["guest_management"])
 
 @app.get("/")
 def root():

app/models/address_model.py

@@ -0,0 +1,175 @@
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+from bson import ObjectId
+import logging
+
+from app.core.nosql_client import db
+
+logger = logging.getLogger(__name__)
+
+class AddressModel:
+    """Model for managing user delivery addresses"""
+    
+    collection = db["user_addresses"]
+    
+    @staticmethod
+    async def create_address(user_id: str, address_data: Dict[str, Any]) -> Optional[str]:
+        """Create a new address for a user"""
+        try:
+            address_doc = {
+                "user_id": user_id,
+                "address_line_1": address_data.get("address_line_1"),
+                "address_line_2": address_data.get("address_line_2", ""),
+                "city": address_data.get("city"),
+                "state": address_data.get("state"),
+                "postal_code": address_data.get("postal_code"),
+                "country": address_data.get("country", "India"),
+                "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()
+            }
+            
+            # If this is set as default, unset other default addresses
+            if address_doc["is_default"]:
+                await AddressModel.collection.update_many(
+                    {"user_id": user_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 {user_id}")
+            return str(result.inserted_id)
+            
+        except Exception as e:
+            logger.error(f"Error creating address for user {user_id}: {str(e)}")
+            return None
+    
+    @staticmethod
+    async def get_user_addresses(user_id: str) -> List[Dict[str, Any]]:
+        """Get all addresses for a user"""
+        try:
+            cursor = AddressModel.collection.find({"user_id": user_id}).sort("created_at", -1)
+            addresses = []
+            
+            async for address in cursor:
+                address["_id"] = str(address["_id"])
+                addresses.append(address)
+            
+            return addresses
+            
+        except Exception as e:
+            logger.error(f"Error getting addresses for user {user_id}: {str(e)}")
+            return []
+    
+    @staticmethod
+    async def get_address_by_id(user_id: str, address_id: str) -> Optional[Dict[str, Any]]:
+        """Get a specific address by ID for a user"""
+        try:
+            address = await AddressModel.collection.find_one({
+                "_id": ObjectId(address_id),
+                "user_id": user_id
+            })
+            
+            if address:
+                address["_id"] = str(address["_id"])
+            
+            return address
+            
+        except Exception as e:
+            logger.error(f"Error getting address {address_id} for user {user_id}: {str(e)}")
+            return None
+    
+    @staticmethod
+    async def update_address(user_id: str, address_id: str, update_data: Dict[str, Any]) -> bool:
+        """Update an existing 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(
+                    {"user_id": user_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), "user_id": user_id},
+                {"$set": update_fields}
+            )
+            
+            return result.modified_count > 0
+            
+        except Exception as e:
+            logger.error(f"Error updating address {address_id} for user {user_id}: {str(e)}")
+            return False
+    
+    @staticmethod
+    async def delete_address(user_id: str, address_id: str) -> bool:
+        """Delete an address"""
+        try:
+            result = await AddressModel.collection.delete_one({
+                "_id": ObjectId(address_id),
+                "user_id": user_id
+            })
+            
+            logger.info(f"Deleted address {address_id} for user {user_id}")
+            return result.deleted_count > 0
+            
+        except Exception as e:
+            logger.error(f"Error deleting address {address_id} for user {user_id}: {str(e)}")
+            return False
+    
+    @staticmethod
+    async def get_default_address(user_id: str) -> Optional[Dict[str, Any]]:
+        """Get the default address for a user"""
+        try:
+            address = await AddressModel.collection.find_one({
+                "user_id": user_id,
+                "is_default": True
+            })
+            
+            if address:
+                address["_id"] = str(address["_id"])
+            
+            return address
+            
+        except Exception as e:
+            logger.error(f"Error getting default address for user {user_id}: {str(e)}")
+            return None
+    
+    @staticmethod
+    async def set_default_address(user_id: str, address_id: str) -> bool:
+        """Set an address as default"""
+        try:
+            # First, unset all default addresses for the user
+            await AddressModel.collection.update_many(
+                {"user_id": user_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), "user_id": user_id},
+                {"$set": {"is_default": True, "updated_at": datetime.utcnow()}}
+            )
+            
+            return result.modified_count > 0
+            
+        except Exception as e:
+            logger.error(f"Error setting default address {address_id} for user {user_id}: {str(e)}")
+            return False

app/models/guest_model.py

@@ -0,0 +1,237 @@
+from app.core.nosql_client import db
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+import uuid
+import logging
+
+logger = logging.getLogger(__name__)
+
+class GuestModel:
+    """Model for managing guest profiles in the database"""
+    
+    @staticmethod
+    async def create_guest(
+        user_id: str,
+        first_name: str,
+        last_name: Optional[str] = None,
+        email: Optional[str] = None,
+        phone_number: Optional[str] = None,
+        gender: Optional[str] = None,
+        date_of_birth: Optional[datetime] = None,
+        relationship: Optional[str] = None,
+        notes: Optional[str] = None
+    ) -> Optional[str]:
+        """
+        Create a new guest profile for a user.
+        
+        Args:
+            user_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
+        """
+        try:
+            guests_collection = db.guests
+            
+            guest_id = str(uuid.uuid4())
+            current_time = datetime.utcnow()
+            
+            guest_data = {
+                "guest_id": guest_id,
+                "user_id": user_id,
+                "first_name": first_name,
+                "last_name": last_name,
+                "email": email,
+                "phone_number": phone_number,
+                "gender": gender,
+                "date_of_birth": date_of_birth,
+                "relationship": relationship,
+                "notes": notes,
+                "created_at": current_time,
+                "updated_at": current_time
+            }
+            
+            result = await guests_collection.insert_one(guest_data)
+            
+            if result.inserted_id:
+                logger.info(f"Guest created successfully: {guest_id} for user: {user_id}")
+                return guest_id
+            else:
+                logger.error(f"Failed to create guest for user: {user_id}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error creating guest for user {user_id}: {str(e)}")
+            return None
+    
+    @staticmethod
+    async def get_user_guests(user_id: str) -> List[Dict[str, Any]]:
+        """
+        Get all guests for a specific user.
+        
+        Args:
+            user_id: ID of the user
+            
+        Returns:
+            List of guest documents
+        """
+        try:
+            guests_collection = db.guests
+            
+            cursor = guests_collection.find({"user_id": user_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: {user_id}")
+            return guests
+            
+        except Exception as e:
+            logger.error(f"Error getting guests for user {user_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
+        """
+        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}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error getting guest {guest_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
+        """
+        try:
+            guests_collection = db.guests
+            
+            # Add updated timestamp
+            update_fields["updated_at"] = datetime.utcnow()
+            
+            result = await guests_collection.update_one(
+                {"guest_id": guest_id},
+                {"$set": update_fields}
+            )
+            
+            if result.modified_count > 0:
+                logger.info(f"Guest updated successfully: {guest_id}")
+                return True
+            else:
+                logger.warning(f"No changes made to guest: {guest_id}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Error updating guest {guest_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
+        """
+        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}")
+                return True
+            else:
+                logger.warning(f"Guest not found for deletion: {guest_id}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Error deleting guest {guest_id}: {str(e)}")
+            return False
+    
+    @staticmethod
+    async def get_guest_count_for_user(user_id: str) -> int:
+        """
+        Get the total number of guests for a user.
+        
+        Args:
+            user_id: ID of the user
+            
+        Returns:
+            Number of guests
+        """
+        try:
+            guests_collection = db.guests
+            
+            count = await guests_collection.count_documents({"user_id": user_id})
+            return count
+            
+        except Exception as e:
+            logger.error(f"Error counting guests for user {user_id}: {str(e)}")
+            return 0
+    
+    @staticmethod
+    async def check_guest_ownership(guest_id: str, user_id: str) -> bool:
+        """
+        Check if a guest belongs to a specific user.
+        
+        Args:
+            guest_id: ID of the guest
+            user_id: ID of the user
+            
+        Returns:
+            True if guest belongs to user, False otherwise
+        """
+        try:
+            guests_collection = db.guests
+            
+            guest = await guests_collection.find_one({
+                "guest_id": guest_id,
+                "user_id": user_id
+            })
+            
+            return guest is not None
+            
+        except Exception as e:
+            logger.error(f"Error checking guest ownership {guest_id} for user {user_id}: {str(e)}")
+            return False

app/models/pet_model.py

@@ -0,0 +1,220 @@
+from app.core.nosql_client import db
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+import uuid
+import logging
+
+logger = logging.getLogger(__name__)
+
+class PetModel:
+    """Model for managing pet profiles in the database"""
+    
+    @staticmethod
+    async def create_pet(
+        user_id: str,
+        pet_name: str,
+        species: str,
+        breed: Optional[str] = None,
+        date_of_birth: Optional[datetime] = None,
+        age: Optional[int] = None,
+        weight: Optional[float] = None,
+        gender: Optional[str] = None,
+        temperament: Optional[str] = None,
+        health_notes: Optional[str] = None,
+        is_vaccinated: bool = False,
+        pet_photo_url: Optional[str] = None
+    ) -> Optional[str]:
+        """
+        Create a new pet profile for a user.
+        
+        Args:
+            user_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
+        """
+        try:
+            pets_collection = db.pets
+            
+            pet_id = str(uuid.uuid4())
+            current_time = datetime.utcnow()
+            
+            pet_data = {
+                "pet_id": pet_id,
+                "user_id": user_id,
+                "pet_name": pet_name,
+                "species": species,
+                "breed": breed,
+                "date_of_birth": date_of_birth,
+                "age": age,
+                "weight": weight,
+                "gender": gender,
+                "temperament": temperament,
+                "health_notes": health_notes,
+                "is_vaccinated": is_vaccinated,
+                "pet_photo_url": pet_photo_url,
+                "created_at": current_time,
+                "updated_at": current_time
+            }
+            
+            result = await pets_collection.insert_one(pet_data)
+            
+            if result.inserted_id:
+                logger.info(f"Pet created successfully: {pet_id} for user: {user_id}")
+                return pet_id
+            else:
+                logger.error(f"Failed to create pet for user: {user_id}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error creating pet for user {user_id}: {str(e)}")
+            return None
+    
+    @staticmethod
+    async def get_user_pets(user_id: str) -> List[Dict[str, Any]]:
+        """
+        Get all pets for a specific user.
+        
+        Args:
+            user_id: ID of the pet owner
+            
+        Returns:
+            List of pet documents
+        """
+        try:
+            pets_collection = db.pets
+            
+            cursor = pets_collection.find({"user_id": user_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: {user_id}")
+            return pets
+            
+        except Exception as e:
+            logger.error(f"Error getting pets for user {user_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
+        """
+        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}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error getting pet {pet_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
+        """
+        try:
+            pets_collection = db.pets
+            
+            # Add updated timestamp
+            update_fields["updated_at"] = datetime.utcnow()
+            
+            result = await pets_collection.update_one(
+                {"pet_id": pet_id},
+                {"$set": update_fields}
+            )
+            
+            if result.modified_count > 0:
+                logger.info(f"Pet updated successfully: {pet_id}")
+                return True
+            else:
+                logger.warning(f"No changes made to pet: {pet_id}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Error updating pet {pet_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
+        """
+        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}")
+                return True
+            else:
+                logger.warning(f"Pet not found for deletion: {pet_id}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Error deleting pet {pet_id}: {str(e)}")
+            return False
+    
+    @staticmethod
+    async def get_pet_count_for_user(user_id: str) -> int:
+        """
+        Get the total number of pets for a user.
+        
+        Args:
+            user_id: ID of the pet owner
+            
+        Returns:
+            Number of pets
+        """
+        try:
+            pets_collection = db.pets
+            
+            count = await pets_collection.count_documents({"user_id": user_id})
+            return count
+            
+        except Exception as e:
+            logger.error(f"Error counting pets for user {user_id}: {str(e)}")
+            return 0

app/models/user_model.py

@@ -123,4 +123,37 @@ class BookMyServiceUserModel:
             
         except ValueError as ve:
             logger.error(f"Validation error for identifier {identifier}: {str(ve)}")
-            raise HTTPException(status_code=400, detail=str(ve))
+            raise HTTPException(status_code=400, detail=str(ve))
+    
+    @staticmethod
+    async def update_profile(user_id: str, update_fields: dict):
+        """Update user profile by user_id"""
+        try:
+            from datetime import datetime
+            
+            # Add updated_at timestamp
+            update_fields["updated_at"] = datetime.utcnow()
+            
+            result = await BookMyServiceUserModel.collection.update_one(
+                {"user_id": user_id}, 
+                {"$set": update_fields}
+            )
+            
+            if result.matched_count == 0:
+                raise HTTPException(status_code=404, detail="User not found")
+            
+            return result.modified_count > 0
+            
+        except Exception as e:
+            logger.error(f"Error updating profile for user {user_id}: {str(e)}")
+            raise HTTPException(status_code=500, detail="Failed to update profile")
+    
+    @staticmethod
+    async def find_by_id(user_id: str):
+        """Find user by user_id"""
+        try:
+            user = await BookMyServiceUserModel.collection.find_one({"user_id": user_id})
+            return user
+        except Exception as e:
+            logger.error(f"Error finding user by ID {user_id}: {str(e)}")
+            return None

app/models/wallet_model.py

@@ -0,0 +1,158 @@
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+from bson import ObjectId
+import logging
+
+from app.core.nosql_client import db
+
+logger = logging.getLogger(__name__)
+
+class WalletModel:
+    """Model for managing user wallet operations"""
+    
+    wallet_collection = db["user_wallets"]
+    transaction_collection = db["wallet_transactions"]
+    
+    @staticmethod
+    async def get_wallet_balance(user_id: str) -> float:
+        """Get current wallet balance for a user"""
+        try:
+            wallet = await WalletModel.wallet_collection.find_one({"user_id": user_id})
+            if wallet:
+                return wallet.get("balance", 0.0)
+            else:
+                # Create wallet if doesn't exist
+                await WalletModel.create_wallet(user_id)
+                return 0.0
+        except Exception as e:
+            logger.error(f"Error getting wallet balance for user {user_id}: {str(e)}")
+            return 0.0
+    
+    @staticmethod
+    async def create_wallet(user_id: str, initial_balance: float = 0.0) -> bool:
+        """Create a new wallet for a user"""
+        try:
+            wallet_doc = {
+                "user_id": user_id,
+                "balance": initial_balance,
+                "created_at": datetime.utcnow(),
+                "updated_at": datetime.utcnow()
+            }
+            
+            result = await WalletModel.wallet_collection.insert_one(wallet_doc)
+            logger.info(f"Created wallet for user {user_id} with balance {initial_balance}")
+            return result.inserted_id is not None
+        except Exception as e:
+            logger.error(f"Error creating wallet for user {user_id}: {str(e)}")
+            return False
+    
+    @staticmethod
+    async def update_balance(user_id: str, amount: float, transaction_type: str, 
+                           description: str = "", reference_id: str = None) -> bool:
+        """Update wallet balance and create transaction record"""
+        try:
+            # Get current balance
+            current_balance = await WalletModel.get_wallet_balance(user_id)
+            
+            # Calculate new balance
+            if transaction_type in ["credit", "refund", "cashback"]:
+                new_balance = current_balance + amount
+            elif transaction_type in ["debit", "payment", "withdrawal"]:
+                if current_balance < amount:
+                    logger.warning(f"Insufficient balance for user {user_id}. Current: {current_balance}, Required: {amount}")
+                    return False
+                new_balance = current_balance - amount
+            else:
+                logger.error(f"Invalid transaction type: {transaction_type}")
+                return False
+            
+            # Update wallet balance
+            update_result = await WalletModel.wallet_collection.update_one(
+                {"user_id": user_id},
+                {
+                    "$set": {
+                        "balance": new_balance,
+                        "updated_at": datetime.utcnow()
+                    }
+                },
+                upsert=True
+            )
+            
+            # Create transaction record
+            transaction_doc = {
+                "user_id": user_id,
+                "amount": amount,
+                "transaction_type": transaction_type,
+                "description": description,
+                "reference_id": reference_id,
+                "balance_before": current_balance,
+                "balance_after": new_balance,
+                "timestamp": datetime.utcnow(),
+                "status": "completed"
+            }
+            
+            await WalletModel.transaction_collection.insert_one(transaction_doc)
+            
+            logger.info(f"Updated wallet for user {user_id}: {transaction_type} of {amount}, new balance: {new_balance}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error updating wallet balance for user {user_id}: {str(e)}")
+            return False
+    
+    @staticmethod
+    async def get_transaction_history(user_id: str, page: int = 1, per_page: int = 20) -> Dict[str, Any]:
+        """Get paginated transaction history for a user"""
+        try:
+            skip = (page - 1) * per_page
+            
+            # Get transactions with pagination
+            cursor = WalletModel.transaction_collection.find(
+                {"user_id": user_id}
+            ).sort("timestamp", -1).skip(skip).limit(per_page)
+            
+            transactions = []
+            async for transaction in cursor:
+                # Convert ObjectId to string for JSON serialization
+                transaction["_id"] = str(transaction["_id"])
+                transactions.append(transaction)
+            
+            # Get total count
+            total_count = await WalletModel.transaction_collection.count_documents({"user_id": user_id})
+            
+            return {
+                "transactions": transactions,
+                "total_count": total_count,
+                "page": page,
+                "per_page": per_page,
+                "total_pages": (total_count + per_page - 1) // per_page
+            }
+            
+        except Exception as e:
+            logger.error(f"Error getting transaction history for user {user_id}: {str(e)}")
+            return {
+                "transactions": [],
+                "total_count": 0,
+                "page": page,
+                "per_page": per_page,
+                "total_pages": 0
+            }
+    
+    @staticmethod
+    async def get_wallet_summary(user_id: str) -> Dict[str, Any]:
+        """Get wallet summary including balance and recent transactions"""
+        try:
+            balance = await WalletModel.get_wallet_balance(user_id)
+            recent_transactions = await WalletModel.get_transaction_history(user_id, page=1, per_page=5)
+            
+            return {
+                "balance": balance,
+                "recent_transactions": recent_transactions["transactions"]
+            }
+            
+        except Exception as e:
+            logger.error(f"Error getting wallet summary for user {user_id}: {str(e)}")
+            return {
+                "balance": 0.0,
+                "recent_transactions": []
+            }

app/routers/address_router.py

@@ -0,0 +1,337 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import List
+import logging
+
+from app.utils.jwt import get_current_user_id
+from app.models.address_model import AddressModel
+from app.schemas.address_schema import (
+    AddressCreateRequest, AddressUpdateRequest, AddressResponse,
+    AddressListResponse, SetDefaultAddressRequest, AddressOperationResponse
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+@router.get("/", response_model=AddressListResponse)
+async def get_user_addresses(current_user_id: str = Depends(get_current_user_id)):
+    """
+    Get all delivery addresses for the current user.
+    
+    This endpoint is JWT protected and requires a valid Bearer token.
+    """
+    try:
+        logger.info(f"Get addresses request for user: {current_user_id}")
+        
+        addresses = await AddressModel.get_user_addresses(current_user_id)
+        
+        address_responses = []
+        for addr in addresses:
+            address_responses.append(AddressResponse(
+                address_id=addr["address_id"],
+                user_id=addr["user_id"],
+                address_type=addr["address_type"],
+                full_name=addr["full_name"],
+                phone=addr["phone"],
+                address_line_1=addr["address_line_1"],
+                address_line_2=addr.get("address_line_2"),
+                city=addr["city"],
+                state=addr["state"],
+                postal_code=addr["postal_code"],
+                country=addr["country"],
+                is_default=addr.get("is_default", False),
+                created_at=addr.get("created_at"),
+                updated_at=addr.get("updated_at")
+            ))
+        
+        return AddressListResponse(
+            success=True,
+            message="Addresses retrieved successfully",
+            addresses=address_responses,
+            total_count=len(address_responses)
+        )
+        
+    except Exception as e:
+        logger.error(f"Error getting addresses for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve addresses"
+        )
+
+@router.post("/", response_model=AddressOperationResponse)
+async def create_address(
+    address_data: AddressCreateRequest,
+    current_user_id: str = Depends(get_current_user_id)
+):
+    """
+    Create a new delivery address for the current user.
+    """
+    try:
+        logger.info(f"Create address request for user: {current_user_id}")
+        
+        # Check if user already has 5 addresses (limit)
+        existing_addresses = await AddressModel.get_user_addresses(current_user_id)
+        if len(existing_addresses) >= 5:
+            raise HTTPException(
+                status_code=400, 
+                detail="Maximum of 5 addresses allowed per user"
+            )
+        
+        # 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(
+            user_id=current_user_id,
+            address_type=address_data.address_type,
+            full_name=address_data.full_name,
+            phone=address_data.phone,
+            address_line_1=address_data.address_line_1,
+            address_line_2=address_data.address_line_2,
+            city=address_data.city,
+            state=address_data.state,
+            postal_code=address_data.postal_code,
+            country=address_data.country,
+            is_default=is_default
+        )
+        
+        if address_id:
+            # Get the created address
+            created_address = await AddressModel.get_address_by_id(address_id)
+            
+            address_response = AddressResponse(
+                address_id=created_address["address_id"],
+                user_id=created_address["user_id"],
+                address_type=created_address["address_type"],
+                full_name=created_address["full_name"],
+                phone=created_address["phone"],
+                address_line_1=created_address["address_line_1"],
+                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"],
+                is_default=created_address.get("is_default", False),
+                created_at=created_address.get("created_at"),
+                updated_at=created_address.get("updated_at")
+            )
+            
+            return AddressOperationResponse(
+                success=True,
+                message="Address created successfully",
+                address=address_response
+            )
+        else:
+            return AddressOperationResponse(
+                success=False,
+                message="Failed to create address"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating address for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create address"
+        )
+
+@router.put("/{address_id}", response_model=AddressOperationResponse)
+async def update_address(
+    address_id: str,
+    address_data: AddressUpdateRequest,
+    current_user_id: str = Depends(get_current_user_id)
+):
+    """
+    Update an existing delivery address.
+    """
+    try:
+        logger.info(f"Update address request for user: {current_user_id}, address: {address_id}")
+        
+        # Check if address exists and belongs to user
+        existing_address = await AddressModel.get_address_by_id(address_id)
+        if not existing_address:
+            raise HTTPException(status_code=404, detail="Address not found")
+        
+        if existing_address["user_id"] != current_user_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+        
+        # Prepare update fields
+        update_fields = {}
+        
+        if address_data.address_type is not None:
+            update_fields["address_type"] = address_data.address_type
+        if address_data.full_name is not None:
+            update_fields["full_name"] = address_data.full_name
+        if address_data.phone is not None:
+            update_fields["phone"] = address_data.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:
+            update_fields["address_line_2"] = address_data.address_line_2
+        if address_data.city is not None:
+            update_fields["city"] = address_data.city
+        if address_data.state is not None:
+            update_fields["state"] = address_data.state
+        if address_data.postal_code is not None:
+            update_fields["postal_code"] = address_data.postal_code
+        if address_data.country is not None:
+            update_fields["country"] = address_data.country
+        
+        if not update_fields:
+            raise HTTPException(status_code=400, detail="No fields to update")
+        
+        success = await AddressModel.update_address(address_id, update_fields)
+        
+        if success:
+            # Get updated address
+            updated_address = await AddressModel.get_address_by_id(address_id)
+            
+            address_response = AddressResponse(
+                address_id=updated_address["address_id"],
+                user_id=updated_address["user_id"],
+                address_type=updated_address["address_type"],
+                full_name=updated_address["full_name"],
+                phone=updated_address["phone"],
+                address_line_1=updated_address["address_line_1"],
+                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"],
+                is_default=updated_address.get("is_default", False),
+                created_at=updated_address.get("created_at"),
+                updated_at=updated_address.get("updated_at")
+            )
+            
+            return AddressOperationResponse(
+                success=True,
+                message="Address updated successfully",
+                address=address_response
+            )
+        else:
+            return AddressOperationResponse(
+                success=False,
+                message="Failed to update address"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating address {address_id} for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update address"
+        )
+
+@router.delete("/{address_id}", response_model=AddressOperationResponse)
+async def delete_address(
+    address_id: str,
+    current_user_id: str = Depends(get_current_user_id)
+):
+    """
+    Delete a delivery address.
+    """
+    try:
+        logger.info(f"Delete address request for user: {current_user_id}, address: {address_id}")
+        
+        # Check if address exists and belongs to user
+        existing_address = await AddressModel.get_address_by_id(address_id)
+        if not existing_address:
+            raise HTTPException(status_code=404, detail="Address not found")
+        
+        if existing_address["user_id"] != current_user_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+        
+        # Check if this is the default 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_user_id)
+            other_addresses = [addr for addr in user_addresses if addr["address_id"] != address_id]
+            
+            if other_addresses:
+                # Set the first other address as default
+                await AddressModel.set_default_address(current_user_id, other_addresses[0]["address_id"])
+        
+        success = await AddressModel.delete_address(address_id)
+        
+        if success:
+            return AddressOperationResponse(
+                success=True,
+                message="Address deleted successfully"
+            )
+        else:
+            return AddressOperationResponse(
+                success=False,
+                message="Failed to delete address"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting address {address_id} for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete address"
+        )
+
+@router.post("/set-default", response_model=AddressOperationResponse)
+async def set_default_address(
+    request: SetDefaultAddressRequest,
+    current_user_id: str = Depends(get_current_user_id)
+):
+    """
+    Set an address as the default delivery address.
+    """
+    try:
+        logger.info(f"Set default address request for user: {current_user_id}, address: {request.address_id}")
+        
+        # Check if address exists and belongs to user
+        existing_address = await AddressModel.get_address_by_id(request.address_id)
+        if not existing_address:
+            raise HTTPException(status_code=404, detail="Address not found")
+        
+        if existing_address["user_id"] != current_user_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+        
+        success = await AddressModel.set_default_address(current_user_id, request.address_id)
+        
+        if success:
+            # Get updated address
+            updated_address = await AddressModel.get_address_by_id(request.address_id)
+            
+            address_response = AddressResponse(
+                address_id=updated_address["address_id"],
+                user_id=updated_address["user_id"],
+                address_type=updated_address["address_type"],
+                full_name=updated_address["full_name"],
+                phone=updated_address["phone"],
+                address_line_1=updated_address["address_line_1"],
+                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"],
+                is_default=updated_address.get("is_default", False),
+                created_at=updated_address.get("created_at"),
+                updated_at=updated_address.get("updated_at")
+            )
+            
+            return AddressOperationResponse(
+                success=True,
+                message="Default address set successfully",
+                address=address_response
+            )
+        else:
+            return AddressOperationResponse(
+                success=False,
+                message="Failed to set default address"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error setting default address for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to set default address"
+        )

app/routers/guest_router.py

@@ -0,0 +1,273 @@
+from fastapi import APIRouter, HTTPException, Depends, status
+from fastapi.security import HTTPBearer
+from app.models.guest_model import GuestModel
+from app.schemas.guest_schema import (
+    GuestCreateRequest, 
+    GuestUpdateRequest, 
+    GuestResponse, 
+    GuestListResponse, 
+    GuestDeleteResponse
+)
+from app.utils.jwt import verify_token
+from typing import Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+security = HTTPBearer()
+
+async def get_current_user(token: str = Depends(security)) -> Dict[str, Any]:
+    """
+    Dependency to get current authenticated user from JWT token
+    """
+    try:
+        payload = verify_token(token.credentials)
+        if not payload:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid or expired token"
+            )
+        return payload
+    except Exception as e:
+        logger.error(f"Token verification failed: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token"
+        )
+
+@router.get("/{user_id}/guests", response_model=GuestListResponse)
+async def get_user_guests(
+    user_id: str,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Get all guests for a specific user.
+    
+    - **user_id**: ID of the user
+    - Returns list of guests with total count
+    """
+    try:
+        # Verify user can only access their own guests
+        if current_user.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. You can only view your own guests."
+            )
+        
+        guests_data = await GuestModel.get_user_guests(user_id)
+        
+        guests = [GuestResponse(**guest) for guest in guests_data]
+        
+        return GuestListResponse(
+            guests=guests,
+            total_count=len(guests)
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting guests for user {user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve guests"
+        )
+
+@router.post("/{user_id}/guests", response_model=GuestResponse, status_code=status.HTTP_201_CREATED)
+async def create_guest(
+    user_id: str,
+    guest_data: GuestCreateRequest,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Create a new guest profile for a user.
+    
+    - **user_id**: ID of the user creating the guest profile
+    - **guest_data**: Guest information including name, contact details, etc.
+    - Returns the created guest profile
+    """
+    try:
+        # Verify user can only create guests for themselves
+        if current_user.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. You can only create guests for yourself."
+            )
+        
+        # Create guest in database
+        guest_id = await GuestModel.create_guest(
+            user_id=user_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 if guest_data.gender else None,
+            date_of_birth=guest_data.date_of_birth,
+            relationship=guest_data.relationship.value if guest_data.relationship else None,
+            notes=guest_data.notes
+        )
+        
+        if not guest_id:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to create guest profile"
+            )
+        
+        # Retrieve and return the created guest
+        created_guest = await GuestModel.get_guest_by_id(guest_id)
+        if not created_guest:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Guest created but failed to retrieve"
+            )
+        
+        return GuestResponse(**created_guest)
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating guest for user {user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create guest profile"
+        )
+
+@router.put("/{user_id}/guests/{guest_id}", response_model=GuestResponse)
+async def update_guest(
+    user_id: str,
+    guest_id: str,
+    guest_data: GuestUpdateRequest,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Update an existing guest profile.
+    
+    - **user_id**: ID of the user who owns the guest profile
+    - **guest_id**: ID of the guest to update
+    - **guest_data**: Updated guest information
+    - Returns the updated guest profile
+    """
+    try:
+        # Verify user can only update their own guests
+        if current_user.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. You can only update your own guests."
+            )
+        
+        # Check if guest exists and belongs to user
+        existing_guest = await GuestModel.get_guest_by_id(guest_id)
+        if not existing_guest:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Guest not found"
+            )
+        
+        if existing_guest.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. This guest doesn't belong to you."
+            )
+        
+        # Prepare update fields (only include non-None values)
+        update_fields = {}
+        for field, value in guest_data.dict(exclude_unset=True).items():
+            if value is not None:
+                if hasattr(value, 'value'):  # Handle enum values
+                    update_fields[field] = value.value
+                else:
+                    update_fields[field] = value
+        
+        if not update_fields:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="No valid fields provided for update"
+            )
+        
+        # Update guest in database
+        success = await GuestModel.update_guest(guest_id, update_fields)
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to update guest profile"
+            )
+        
+        # Retrieve and return updated guest
+        updated_guest = await GuestModel.get_guest_by_id(guest_id)
+        if not updated_guest:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Guest updated but failed to retrieve"
+            )
+        
+        return GuestResponse(**updated_guest)
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating guest {guest_id} for user {user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update guest profile"
+        )
+
+@router.delete("/{user_id}/guests/{guest_id}", response_model=GuestDeleteResponse)
+async def delete_guest(
+    user_id: str,
+    guest_id: str,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Delete a guest profile.
+    
+    - **user_id**: ID of the user who owns the guest profile
+    - **guest_id**: ID of the guest to delete
+    - Returns confirmation of deletion
+    """
+    try:
+        # Verify user can only delete their own guests
+        if current_user.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. You can only delete your own guests."
+            )
+        
+        # Check if guest exists and belongs to user
+        existing_guest = await GuestModel.get_guest_by_id(guest_id)
+        if not existing_guest:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Guest not found"
+            )
+        
+        if existing_guest.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. This guest doesn't belong to you."
+            )
+        
+        # Delete guest from database
+        success = await GuestModel.delete_guest(guest_id)
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to delete guest profile"
+            )
+        
+        guest_name = existing_guest.get('first_name', 'Guest')
+        if existing_guest.get('last_name'):
+            guest_name += f" {existing_guest.get('last_name')}"
+        
+        return GuestDeleteResponse(
+            message=f"Guest '{guest_name}' has been successfully deleted",
+            guest_id=guest_id
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting guest {guest_id} for user {user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete guest profile"
+        )

app/routers/pet_router.py

@@ -0,0 +1,272 @@
+from fastapi import APIRouter, HTTPException, Depends, status
+from fastapi.security import HTTPBearer
+from app.models.pet_model import PetModel
+from app.schemas.pet_schema import (
+    PetCreateRequest, 
+    PetUpdateRequest, 
+    PetResponse, 
+    PetListResponse, 
+    PetDeleteResponse
+)
+from app.utils.jwt import verify_token
+from typing import Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+security = HTTPBearer()
+
+async def get_current_user(token: str = Depends(security)) -> Dict[str, Any]:
+    """
+    Dependency to get current authenticated user from JWT token
+    """
+    try:
+        payload = verify_token(token.credentials)
+        if not payload:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid or expired token"
+            )
+        return payload
+    except Exception as e:
+        logger.error(f"Token verification failed: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token"
+        )
+
+@router.get("/{user_id}/pets", response_model=PetListResponse)
+async def get_user_pets(
+    user_id: str,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Get all pets for a specific user.
+    
+    - **user_id**: ID of the pet owner
+    - Returns list of pets with total count
+    """
+    try:
+        # Verify user can only access their own pets
+        if current_user.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. You can only view your own pets."
+            )
+        
+        pets_data = await PetModel.get_user_pets(user_id)
+        
+        pets = [PetResponse(**pet) for pet in pets_data]
+        
+        return PetListResponse(
+            pets=pets,
+            total_count=len(pets)
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting pets for user {user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve pets"
+        )
+
+@router.post("/{user_id}/pets", response_model=PetResponse, status_code=status.HTTP_201_CREATED)
+async def create_pet(
+    user_id: str,
+    pet_data: PetCreateRequest,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Create a new pet profile for a user.
+    
+    - **user_id**: ID of the pet owner
+    - **pet_data**: Pet information including name, species, breed, etc.
+    - Returns the created pet profile
+    """
+    try:
+        # Verify user can only create pets for themselves
+        if current_user.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. You can only create pets for yourself."
+            )
+        
+        # Create pet in database
+        pet_id = await PetModel.create_pet(
+            user_id=user_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 if pet_data.gender else None,
+            temperament=pet_data.temperament.value if pet_data.temperament else None,
+            health_notes=pet_data.health_notes,
+            is_vaccinated=pet_data.is_vaccinated,
+            pet_photo_url=pet_data.pet_photo_url
+        )
+        
+        if not pet_id:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to create pet profile"
+            )
+        
+        # Retrieve and return the created pet
+        created_pet = await PetModel.get_pet_by_id(pet_id)
+        if not created_pet:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Pet created but failed to retrieve"
+            )
+        
+        return PetResponse(**created_pet)
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating pet for user {user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create pet profile"
+        )
+
+@router.put("/{user_id}/pets/{pet_id}", response_model=PetResponse)
+async def update_pet(
+    user_id: str,
+    pet_id: str,
+    pet_data: PetUpdateRequest,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Update an existing pet profile.
+    
+    - **user_id**: ID of the pet owner
+    - **pet_id**: ID of the pet to update
+    - **pet_data**: Updated pet information
+    - Returns the updated pet profile
+    """
+    try:
+        # Verify user can only update their own pets
+        if current_user.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. You can only update your own pets."
+            )
+        
+        # Check if pet exists and belongs to user
+        existing_pet = await PetModel.get_pet_by_id(pet_id)
+        if not existing_pet:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Pet not found"
+            )
+        
+        if existing_pet.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. This pet doesn't belong to you."
+            )
+        
+        # Prepare update fields (only include non-None values)
+        update_fields = {}
+        for field, value in pet_data.dict(exclude_unset=True).items():
+            if value is not None:
+                if hasattr(value, 'value'):  # Handle enum values
+                    update_fields[field] = value.value
+                else:
+                    update_fields[field] = value
+        
+        if not update_fields:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="No valid fields provided for update"
+            )
+        
+        # Update pet in database
+        success = await PetModel.update_pet(pet_id, update_fields)
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to update pet profile"
+            )
+        
+        # Retrieve and return updated pet
+        updated_pet = await PetModel.get_pet_by_id(pet_id)
+        if not updated_pet:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Pet updated but failed to retrieve"
+            )
+        
+        return PetResponse(**updated_pet)
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating pet {pet_id} for user {user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update pet profile"
+        )
+
+@router.delete("/{user_id}/pets/{pet_id}", response_model=PetDeleteResponse)
+async def delete_pet(
+    user_id: str,
+    pet_id: str,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Delete a pet profile.
+    
+    - **user_id**: ID of the pet owner
+    - **pet_id**: ID of the pet to delete
+    - Returns confirmation of deletion
+    """
+    try:
+        # Verify user can only delete their own pets
+        if current_user.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. You can only delete your own pets."
+            )
+        
+        # Check if pet exists and belongs to user
+        existing_pet = await PetModel.get_pet_by_id(pet_id)
+        if not existing_pet:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Pet not found"
+            )
+        
+        if existing_pet.get("user_id") != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied. This pet doesn't belong to you."
+            )
+        
+        # Delete pet from database
+        success = await PetModel.delete_pet(pet_id)
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to delete pet profile"
+            )
+        
+        return PetDeleteResponse(
+            message=f"Pet '{existing_pet.get('pet_name')}' has been successfully deleted",
+            pet_id=pet_id
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting pet {pet_id} for user {user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete pet profile"
+        )

app/routers/profile_router.py

@@ -7,6 +7,13 @@ import logging
 
 from app.utils.jwt import get_current_user_id
 from app.services.profile_service import profile_service
+from app.services.wallet_service import WalletService
+from app.models.user_model import BookMyServiceUserModel
+from app.models.address_model import AddressModel
+from app.schemas.profile_schema import (
+    ProfileUpdateRequest, ProfileResponse, ProfileOperationResponse,
+    PersonalDetailsResponse, WalletDisplayResponse, ProfileDashboardResponse
+)
 
 logger = logging.getLogger(__name__)
 
@@ -50,3 +57,144 @@ async def get_profile(current_user_id: str = Depends(get_current_user_id)):
             detail="Internal server error"
         )
 
+@router.get("/dashboard", response_model=ProfileDashboardResponse)
+async def get_profile_dashboard(current_user_id: str = Depends(get_current_user_id)):
+    """
+    Get complete profile dashboard with personal details, wallet, and address info.
+    
+    This endpoint matches the screenshot requirements showing:
+    - Personal details (name, email, phone, DOB)
+    - Wallet balance
+    - Address management info
+    """
+    try:
+        logger.info(f"Dashboard request for user: {current_user_id}")
+        
+        # Get user profile
+        user = await BookMyServiceUserModel.find_by_id(current_user_id)
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+        
+        # Parse name into first and last name
+        name_parts = user.get("name", "").split(" ", 1)
+        first_name = name_parts[0] if name_parts else ""
+        last_name = name_parts[1] if len(name_parts) > 1 else ""
+        
+        # Get wallet balance
+        wallet_balance = await WalletService.get_wallet_balance(current_user_id)
+        
+        # Get address count and default address status
+        addresses = await AddressModel.get_user_addresses(current_user_id)
+        address_count = len(addresses)
+        has_default_address = any(addr.get("is_default", False) for addr in addresses)
+        
+        # Build response
+        personal_details = PersonalDetailsResponse(
+            first_name=first_name,
+            last_name=last_name,
+            email=user.get("email", ""),
+            phone=user.get("phone", ""),
+            date_of_birth=user.get("date_of_birth")
+        )
+        
+        wallet_display = WalletDisplayResponse(
+            balance=wallet_balance.balance,
+            formatted_balance=wallet_balance.formatted_balance,
+            currency=wallet_balance.currency
+        )
+        
+        return ProfileDashboardResponse(
+            personal_details=personal_details,
+            wallet=wallet_display,
+            address_count=address_count,
+            has_default_address=has_default_address
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting profile dashboard for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Internal server error"
+        )
+
+@router.put("/update", response_model=ProfileOperationResponse)
+async def update_profile(
+    profile_data: ProfileUpdateRequest,
+    current_user_id: str = Depends(get_current_user_id)
+):
+    """
+    Update user profile information including personal details and DOB.
+    """
+    try:
+        logger.info(f"Profile update request for user: {current_user_id}")
+        
+        # Prepare update fields
+        update_fields = {}
+        
+        if profile_data.name is not None:
+            update_fields["name"] = profile_data.name
+        
+        if profile_data.email is not None:
+            # Check if email is already used by another user
+            existing_user = await BookMyServiceUserModel.find_by_email(str(profile_data.email))
+            if existing_user and existing_user.get("user_id") != current_user_id:
+                raise HTTPException(status_code=409, detail="Email already in use by another account")
+            update_fields["email"] = str(profile_data.email)
+        
+        if profile_data.phone is not None:
+            # Check if phone is already used by another user
+            existing_user = await BookMyServiceUserModel.find_by_phone(profile_data.phone)
+            if existing_user and existing_user.get("user_id") != current_user_id:
+                raise HTTPException(status_code=409, detail="Phone number already in use by another account")
+            update_fields["phone"] = profile_data.phone
+        
+        if profile_data.date_of_birth is not None:
+            update_fields["date_of_birth"] = profile_data.date_of_birth
+        
+        if profile_data.profile_picture is not None:
+            update_fields["profile_picture"] = profile_data.profile_picture
+        
+        if not update_fields:
+            raise HTTPException(status_code=400, detail="No fields to update")
+        
+        # Update profile
+        success = await BookMyServiceUserModel.update_profile(current_user_id, update_fields)
+        
+        if success:
+            # Get updated profile
+            updated_user = await BookMyServiceUserModel.find_by_id(current_user_id)
+            
+            profile_response = ProfileResponse(
+                user_id=updated_user["user_id"],
+                name=updated_user["name"],
+                email=updated_user.get("email"),
+                phone=updated_user.get("phone"),
+                date_of_birth=updated_user.get("date_of_birth"),
+                profile_picture=updated_user.get("profile_picture"),
+                auth_method=updated_user.get("auth_mode", "unknown"),
+                created_at=updated_user.get("created_at"),
+                updated_at=updated_user.get("updated_at")
+            )
+            
+            return ProfileOperationResponse(
+                success=True,
+                message="Profile updated successfully",
+                profile=profile_response
+            )
+        else:
+            return ProfileOperationResponse(
+                success=False,
+                message="Failed to update profile"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating profile for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Internal server error"
+        )
+

app/routers/wallet_router.py

@@ -0,0 +1,223 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Query
+from typing import List, Optional
+import logging
+
+from app.utils.jwt import get_current_user_id
+from app.services.wallet_service import WalletService
+from app.schemas.wallet_schema import (
+    WalletBalanceResponse, TransactionHistoryResponse, WalletSummaryResponse,
+    AddMoneyRequest, WithdrawMoneyRequest, TransactionRequest, TransactionResponse
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+@router.get("/balance", response_model=WalletBalanceResponse)
+async def get_wallet_balance(current_user_id: str = Depends(get_current_user_id)):
+    """
+    Get current user's wallet balance.
+    
+    This endpoint is JWT protected and requires a valid Bearer token.
+    """
+    try:
+        logger.info(f"Wallet balance request for user: {current_user_id}")
+        
+        balance_info = await WalletService.get_wallet_balance(current_user_id)
+        return balance_info
+        
+    except Exception as e:
+        logger.error(f"Error getting wallet balance for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve wallet balance"
+        )
+
+@router.get("/summary", response_model=WalletSummaryResponse)
+async def get_wallet_summary(current_user_id: str = Depends(get_current_user_id)):
+    """
+    Get wallet summary including balance and recent transaction stats.
+    """
+    try:
+        logger.info(f"Wallet summary request for user: {current_user_id}")
+        
+        summary = await WalletService.get_wallet_summary(current_user_id)
+        return summary
+        
+    except Exception as e:
+        logger.error(f"Error getting wallet summary for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve wallet summary"
+        )
+
+@router.get("/transactions", response_model=TransactionHistoryResponse)
+async def get_transaction_history(
+    current_user_id: str = Depends(get_current_user_id),
+    page: int = Query(1, ge=1, description="Page number"),
+    limit: int = Query(10, ge=1, le=100, description="Number of transactions per page"),
+    transaction_type: Optional[str] = Query(None, description="Filter by transaction type")
+):
+    """
+    Get paginated transaction history for the current user.
+    
+    Query parameters:
+    - page: Page number (default: 1)
+    - limit: Number of transactions per page (default: 10, max: 100)
+    - transaction_type: Filter by type (credit, debit, refund, etc.)
+    """
+    try:
+        logger.info(f"Transaction history request for user: {current_user_id}, page: {page}, limit: {limit}")
+        
+        history = await WalletService.get_transaction_history(
+            current_user_id, 
+            page=page, 
+            limit=limit, 
+            transaction_type=transaction_type
+        )
+        return history
+        
+    except Exception as e:
+        logger.error(f"Error getting transaction history for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve transaction history"
+        )
+
+@router.post("/add-money", response_model=TransactionResponse)
+async def add_money_to_wallet(
+    request: AddMoneyRequest,
+    current_user_id: str = Depends(get_current_user_id)
+):
+    """
+    Add money to user's wallet.
+    
+    This would typically integrate with a payment gateway.
+    For now, it simulates adding money to the wallet.
+    """
+    try:
+        logger.info(f"Add money request for user: {current_user_id}, amount: {request.amount}")
+        
+        if request.amount <= 0:
+            raise HTTPException(status_code=400, detail="Amount must be greater than zero")
+        
+        transaction = await WalletService.add_money(
+            current_user_id,
+            request.amount,
+            request.payment_method,
+            request.reference_id,
+            request.description
+        )
+        
+        return TransactionResponse(
+            success=True,
+            message="Money added successfully",
+            transaction=transaction,
+            new_balance=transaction.balance_after
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error adding money for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to add money to wallet"
+        )
+
+@router.post("/withdraw", response_model=TransactionResponse)
+async def withdraw_money(
+    request: WithdrawMoneyRequest,
+    current_user_id: str = Depends(get_current_user_id)
+):
+    """
+    Withdraw money from user's wallet.
+    
+    This would typically integrate with a payment gateway for bank transfers.
+    """
+    try:
+        logger.info(f"Withdraw request for user: {current_user_id}, amount: {request.amount}")
+        
+        if request.amount <= 0:
+            raise HTTPException(status_code=400, detail="Amount must be greater than zero")
+        
+        # Check if user has sufficient balance
+        balance_info = await WalletService.get_wallet_balance(current_user_id)
+        if balance_info.balance < request.amount:
+            raise HTTPException(status_code=400, detail="Insufficient wallet balance")
+        
+        transaction = await WalletService.deduct_money(
+            current_user_id,
+            request.amount,
+            "withdrawal",
+            request.bank_account_id,
+            request.description or "Wallet withdrawal"
+        )
+        
+        return TransactionResponse(
+            success=True,
+            message="Withdrawal processed successfully",
+            transaction=transaction,
+            new_balance=transaction.balance_after
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error processing withdrawal for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to process withdrawal"
+        )
+
+@router.post("/transaction", response_model=TransactionResponse)
+async def create_transaction(
+    request: TransactionRequest,
+    current_user_id: str = Depends(get_current_user_id)
+):
+    """
+    Create a generic transaction (for internal use, service bookings, etc.).
+    """
+    try:
+        logger.info(f"Transaction request for user: {current_user_id}, type: {request.transaction_type}, amount: {request.amount}")
+        
+        if request.amount <= 0:
+            raise HTTPException(status_code=400, detail="Amount must be greater than zero")
+        
+        if request.transaction_type == "debit":
+            # Check if user has sufficient balance for debit transactions
+            balance_info = await WalletService.get_wallet_balance(current_user_id)
+            if balance_info.balance < request.amount:
+                raise HTTPException(status_code=400, detail="Insufficient wallet balance")
+            
+            transaction = await WalletService.deduct_money(
+                current_user_id,
+                request.amount,
+                request.category or "service",
+                request.reference_id,
+                request.description
+            )
+        else:  # credit or refund
+            transaction = await WalletService.add_money(
+                current_user_id,
+                request.amount,
+                request.category or "refund",
+                request.reference_id,
+                request.description
+            )
+        
+        return TransactionResponse(
+            success=True,
+            message=f"Transaction processed successfully",
+            transaction=transaction,
+            new_balance=transaction.balance_after
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating transaction for user {current_user_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to process transaction"
+        )

app/schemas/address_schema.py

@@ -0,0 +1,91 @@
+from pydantic import BaseModel, Field, validator
+from datetime import datetime
+from typing import List, Optional, Literal
+
+class AddressCreateRequest(BaseModel):
+    """Request model for creating a new address"""
+    address_line_1: str = Field(..., min_length=5, max_length=200, description="Primary address line")
+    address_line_2: Optional[str] = Field("", max_length=200, description="Secondary address line")
+    city: str = Field(..., min_length=2, max_length=100, description="City name")
+    state: str = Field(..., min_length=2, max_length=100, description="State name")
+    postal_code: str = Field(..., min_length=5, max_length=10, description="Postal/ZIP code")
+    country: str = Field(default="India", max_length=100, description="Country name")
+    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"""
+    address_line_1: Optional[str] = Field(None, min_length=5, max_length=200, description="Primary address line")
+    address_line_2: Optional[str] = Field(None, max_length=200, description="Secondary address line")
+    city: Optional[str] = Field(None, min_length=2, max_length=100, description="City name")
+    state: Optional[str] = Field(None, min_length=2, max_length=100, description="State name")
+    postal_code: Optional[str] = Field(None, min_length=5, max_length=10, description="Postal/ZIP code")
+    country: Optional[str] = Field(None, max_length=100, description="Country name")
+    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"""
+    address_id: str = Field(..., description="Unique address ID")
+    address_line_1: str = Field(..., description="Primary address line")
+    address_line_2: str = Field(..., description="Secondary address line")
+    city: str = Field(..., description="City name")
+    state: str = Field(..., description="State name")
+    postal_code: str = Field(..., description="Postal/ZIP code")
+    country: str = Field(..., description="Country name")
+    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")
+    
+    class Config:
+        from_attributes = True
+
+class AddressListResponse(BaseModel):
+    """Response model for list of addresses"""
+    addresses: List[AddressResponse] = Field(..., description="List of user addresses")
+    total_count: int = Field(..., description="Total number of addresses")
+    default_address_id: Optional[str] = Field(None, description="ID of default address")
+
+class SetDefaultAddressRequest(BaseModel):
+    """Request model for setting default address"""
+    address_id: str = Field(..., description="Address ID to set as default")
+
+class AddressOperationResponse(BaseModel):
+    """Response model for address operations"""
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    address_id: Optional[str] = Field(None, description="Address ID if applicable")

app/schemas/guest_schema.py

@@ -0,0 +1,155 @@
+from pydantic import BaseModel, Field, validator, EmailStr
+from typing import Optional, List
+from datetime import datetime
+from enum import Enum
+
+class GenderEnum(str, Enum):
+    MALE = "Male"
+    FEMALE = "Female"
+    OTHER = "Other"
+
+class RelationshipEnum(str, Enum):
+    FAMILY = "Family"
+    FRIEND = "Friend"
+    COLLEAGUE = "Colleague"
+    OTHER = "Other"
+
+class GuestCreateRequest(BaseModel):
+    """Schema for creating a new guest profile"""
+    first_name: str = Field(..., min_length=1, max_length=100, description="Guest's first name")
+    last_name: Optional[str] = Field(None, max_length=100, description="Guest's last name")
+    email: Optional[EmailStr] = Field(None, description="Guest's email address")
+    phone_number: Optional[str] = Field(None, max_length=20, description="Guest's phone number")
+    gender: Optional[GenderEnum] = Field(None, description="Guest's gender")
+    date_of_birth: Optional[datetime] = 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")
+    
+    @validator('first_name')
+    def validate_first_name(cls, v):
+        if not v or not v.strip():
+            raise ValueError('First name cannot be empty')
+        return v.strip()
+    
+    @validator('last_name')
+    def validate_last_name(cls, v):
+        if v is not None and v.strip() == '':
+            return None
+        return v.strip() if v else v
+    
+    @validator('phone_number')
+    def validate_phone_number(cls, v):
+        if v is not None:
+            # Remove spaces and special characters for validation
+            cleaned = ''.join(filter(str.isdigit, v))
+            if len(cleaned) < 10 or len(cleaned) > 15:
+                raise ValueError('Phone number must be between 10 and 15 digits')
+        return v
+    
+    @validator('date_of_birth')
+    def validate_date_of_birth(cls, v):
+        if v is not None:
+            if v > datetime.now():
+                raise ValueError('Date of birth cannot be in the future')
+            # Check if age would be reasonable (not more than 120 years old)
+            age = (datetime.now() - v).days // 365
+            if age > 120:
+                raise ValueError('Date of birth indicates unrealistic age')
+        return v
+
+class GuestUpdateRequest(BaseModel):
+    """Schema for updating a guest profile"""
+    first_name: Optional[str] = Field(None, min_length=1, max_length=100, description="Guest's first name")
+    last_name: Optional[str] = Field(None, max_length=100, description="Guest's last name")
+    email: Optional[EmailStr] = Field(None, description="Guest's email address")
+    phone_number: Optional[str] = Field(None, max_length=20, description="Guest's phone number")
+    gender: Optional[GenderEnum] = Field(None, description="Guest's gender")
+    date_of_birth: Optional[datetime] = 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")
+    
+    @validator('first_name')
+    def validate_first_name(cls, v):
+        if v is not None and (not v or not v.strip()):
+            raise ValueError('First name cannot be empty')
+        return v.strip() if v else v
+    
+    @validator('last_name')
+    def validate_last_name(cls, v):
+        if v is not None and v.strip() == '':
+            return None
+        return v.strip() if v else v
+    
+    @validator('phone_number')
+    def validate_phone_number(cls, v):
+        if v is not None:
+            # Remove spaces and special characters for validation
+            cleaned = ''.join(filter(str.isdigit, v))
+            if len(cleaned) < 10 or len(cleaned) > 15:
+                raise ValueError('Phone number must be between 10 and 15 digits')
+        return v
+    
+    @validator('date_of_birth')
+    def validate_date_of_birth(cls, v):
+        if v is not None:
+            if v > datetime.now():
+                raise ValueError('Date of birth cannot be in the future')
+            # Check if age would be reasonable (not more than 120 years old)
+            age = (datetime.now() - v).days // 365
+            if age > 120:
+                raise ValueError('Date of birth indicates unrealistic age')
+        return v
+
+class GuestResponse(BaseModel):
+    """Schema for guest profile response"""
+    guest_id: str = Field(..., description="Unique guest identifier")
+    user_id: str = Field(..., description="User ID who created this guest profile")
+    first_name: str = Field(..., description="Guest's first name")
+    last_name: Optional[str] = Field(None, description="Guest's last name")
+    email: Optional[str] = Field(None, description="Guest's email address")
+    phone_number: Optional[str] = Field(None, description="Guest's phone number")
+    gender: Optional[str] = Field(None, description="Guest's gender")
+    date_of_birth: Optional[datetime] = 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")
+    created_at: datetime = Field(..., description="Guest profile creation timestamp")
+    updated_at: datetime = Field(..., description="Guest profile last update timestamp")
+    
+    @property
+    def full_name(self) -> str:
+        """Get the full name of the guest"""
+        if self.last_name:
+            return f"{self.first_name} {self.last_name}"
+        return self.first_name
+    
+    @property
+    def age(self) -> Optional[int]:
+        """Calculate age from date of birth"""
+        if self.date_of_birth:
+            today = datetime.now()
+            return today.year - self.date_of_birth.year - (
+                (today.month, today.day) < (self.date_of_birth.month, self.date_of_birth.day)
+            )
+        return None
+    
+    class Config:
+        from_attributes = True
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+class GuestListResponse(BaseModel):
+    """Schema for list of guests response"""
+    guests: List[GuestResponse] = Field(..., description="List of user's guests")
+    total_count: int = Field(..., description="Total number of guests")
+    
+    class Config:
+        from_attributes = True
+
+class GuestDeleteResponse(BaseModel):
+    """Schema for guest deletion response"""
+    message: str = Field(..., description="Deletion confirmation message")
+    guest_id: str = Field(..., description="ID of the deleted guest")
+    
+    class Config:
+        from_attributes = True

app/schemas/pet_schema.py

@@ -0,0 +1,108 @@
+from pydantic import BaseModel, Field, validator
+from typing import Optional, List
+from datetime import datetime
+from enum import Enum
+
+class SpeciesEnum(str, Enum):
+    DOG = "Dog"
+    CAT = "Cat"
+    OTHER = "Other"
+
+class GenderEnum(str, Enum):
+    MALE = "Male"
+    FEMALE = "Female"
+    OTHER = "Other"
+
+class TemperamentEnum(str, Enum):
+    CALM = "Calm"
+    NERVOUS = "Nervous"
+    AGGRESSIVE = "Aggressive"
+    SOCIAL = "Social"
+
+class PetCreateRequest(BaseModel):
+    """Schema for creating a new pet profile"""
+    pet_name: str = Field(..., min_length=1, max_length=100, description="Name of the pet")
+    species: SpeciesEnum = Field(..., description="Species of the pet")
+    breed: Optional[str] = Field(None, max_length=100, description="Breed of the pet")
+    date_of_birth: Optional[datetime] = Field(None, description="Pet's date of birth")
+    age: Optional[int] = Field(None, ge=0, le=50, description="Pet's age in years")
+    weight: Optional[float] = Field(None, ge=0, le=200, description="Pet's weight in kg")
+    gender: Optional[GenderEnum] = Field(None, description="Pet's gender")
+    temperament: Optional[TemperamentEnum] = Field(None, description="Pet's temperament")
+    health_notes: Optional[str] = Field(None, max_length=1000, description="Health notes, allergies, medications")
+    is_vaccinated: bool = Field(False, description="Vaccination status")
+    pet_photo_url: Optional[str] = Field(None, max_length=500, description="URL to pet's photo")
+    
+    @validator('pet_name')
+    def validate_pet_name(cls, v):
+        if not v or not v.strip():
+            raise ValueError('Pet name cannot be empty')
+        return v.strip()
+    
+    @validator('age', 'date_of_birth')
+    def validate_age_or_dob(cls, v, values):
+        # At least one of age or date_of_birth should be provided
+        if 'age' in values and 'date_of_birth' in values:
+            if not values.get('age') and not values.get('date_of_birth'):
+                raise ValueError('Either age or date of birth must be provided')
+        return v
+
+class PetUpdateRequest(BaseModel):
+    """Schema for updating a pet profile"""
+    pet_name: Optional[str] = Field(None, min_length=1, max_length=100, description="Name of the pet")
+    species: Optional[SpeciesEnum] = Field(None, description="Species of the pet")
+    breed: Optional[str] = Field(None, max_length=100, description="Breed of the pet")
+    date_of_birth: Optional[datetime] = Field(None, description="Pet's date of birth")
+    age: Optional[int] = Field(None, ge=0, le=50, description="Pet's age in years")
+    weight: Optional[float] = Field(None, ge=0, le=200, description="Pet's weight in kg")
+    gender: Optional[GenderEnum] = Field(None, description="Pet's gender")
+    temperament: Optional[TemperamentEnum] = Field(None, description="Pet's temperament")
+    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")
+    
+    @validator('pet_name')
+    def validate_pet_name(cls, v):
+        if v is not None and (not v or not v.strip()):
+            raise ValueError('Pet name cannot be empty')
+        return v.strip() if v else v
+
+class PetResponse(BaseModel):
+    """Schema for pet profile response"""
+    pet_id: str = Field(..., description="Unique pet identifier")
+    user_id: str = Field(..., description="Owner's user ID")
+    pet_name: str = Field(..., description="Name of the pet")
+    species: str = Field(..., description="Species of the pet")
+    breed: Optional[str] = Field(None, description="Breed of the pet")
+    date_of_birth: Optional[datetime] = Field(None, description="Pet's date of birth")
+    age: Optional[int] = Field(None, description="Pet's age in years")
+    weight: Optional[float] = Field(None, description="Pet's weight in kg")
+    gender: Optional[str] = Field(None, description="Pet's gender")
+    temperament: Optional[str] = Field(None, description="Pet's temperament")
+    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")
+    created_at: datetime = Field(..., description="Pet profile creation timestamp")
+    updated_at: datetime = Field(..., description="Pet profile last update timestamp")
+    
+    class Config:
+        from_attributes = True
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+class PetListResponse(BaseModel):
+    """Schema for list of pets response"""
+    pets: List[PetResponse] = Field(..., description="List of user's pets")
+    total_count: int = Field(..., description="Total number of pets")
+    
+    class Config:
+        from_attributes = True
+
+class PetDeleteResponse(BaseModel):
+    """Schema for pet deletion response"""
+    message: str = Field(..., description="Deletion confirmation message")
+    pet_id: str = Field(..., description="ID of the deleted pet")
+    
+    class Config:
+        from_attributes = True

app/schemas/profile_schema.py

@@ -0,0 +1,91 @@
+from pydantic import BaseModel, EmailStr, Field, validator
+from datetime import datetime, date
+from typing import Optional, Dict, Any
+import re
+
+class ProfileUpdateRequest(BaseModel):
+    """Request model for updating user profile"""
+    name: Optional[str] = Field(None, min_length=2, max_length=100, description="User's full name")
+    email: Optional[EmailStr] = Field(None, description="User's email address")
+    phone: Optional[str] = Field(None, description="User's phone number")
+    date_of_birth: Optional[str] = Field(None, description="Date of birth in DD/MM/YYYY format")
+    profile_picture: Optional[str] = Field(None, description="Profile picture URL")
+    
+    @validator('phone')
+    def validate_phone(cls, v):
+        if v is not None:
+            # Remove any non-digit characters
+            phone_digits = re.sub(r'\D', '', v)
+            if len(phone_digits) != 10:
+                raise ValueError('Phone number must be exactly 10 digits')
+            return phone_digits
+        return v
+    
+    @validator('date_of_birth')
+    def validate_date_of_birth(cls, v):
+        if v is not None:
+            try:
+                # Parse DD/MM/YYYY format
+                day, month, year = map(int, v.split('/'))
+                birth_date = date(year, month, day)
+                
+                # Check if date is not in the future
+                if birth_date > date.today():
+                    raise ValueError('Date of birth cannot be in the future')
+                
+                # Check if age is reasonable (not more than 120 years)
+                age = (date.today() - birth_date).days // 365
+                if age > 120:
+                    raise ValueError('Invalid date of birth')
+                
+                return v
+            except ValueError as e:
+                if "Invalid date of birth" in str(e) or "Date of birth cannot be in the future" in str(e):
+                    raise e
+                raise ValueError('Date of birth must be in DD/MM/YYYY format')
+        return v
+
+class ProfileResponse(BaseModel):
+    """Response model for user profile"""
+    user_id: str = Field(..., description="Unique user identifier")
+    name: str = Field(..., description="User's full name")
+    email: Optional[str] = Field(None, description="User's email address")
+    phone: Optional[str] = Field(None, description="User's phone number")
+    date_of_birth: Optional[str] = Field(None, description="Date of birth in DD/MM/YYYY format")
+    profile_picture: Optional[str] = Field(None, description="Profile picture URL")
+    auth_method: str = Field(..., description="Authentication method used")
+    created_at: datetime = Field(..., description="Account creation timestamp")
+    updated_at: Optional[datetime] = Field(None, description="Last profile update timestamp")
+    
+    class Config:
+        from_attributes = True
+
+class PersonalDetailsResponse(BaseModel):
+    """Response model for personal details section"""
+    first_name: str = Field(..., description="User's first name")
+    last_name: str = Field(..., description="User's last name")
+    email: str = Field(..., description="User's email address")
+    phone: str = Field(..., description="User's phone number")
+    date_of_birth: Optional[str] = Field(None, description="Date of birth in DD/MM/YYYY format")
+    
+    class Config:
+        from_attributes = True
+
+class ProfileOperationResponse(BaseModel):
+    """Response model for profile operations"""
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    profile: Optional[ProfileResponse] = Field(None, description="Updated profile data")
+
+class WalletDisplayResponse(BaseModel):
+    """Response model for wallet display in profile"""
+    balance: float = Field(..., description="Current wallet balance")
+    formatted_balance: str = Field(..., description="Formatted balance with currency symbol")
+    currency: str = Field(default="INR", description="Currency code")
+
+class ProfileDashboardResponse(BaseModel):
+    """Complete response model for profile dashboard"""
+    personal_details: PersonalDetailsResponse = Field(..., description="Personal details")
+    wallet: WalletDisplayResponse = Field(..., description="Wallet information")
+    address_count: int = Field(..., description="Number of saved addresses")
+    has_default_address: bool = Field(..., description="Whether user has a default address set")

app/schemas/wallet_schema.py

@@ -0,0 +1,71 @@
+from pydantic import BaseModel, Field
+from datetime import datetime
+from typing import List, Optional, Literal
+from decimal import Decimal
+
+class WalletBalanceResponse(BaseModel):
+    """Response model for wallet balance"""
+    balance: float = Field(..., description="Current wallet balance")
+    currency: str = Field(default="INR", description="Currency code")
+    formatted_balance: str = Field(..., description="Formatted balance with currency symbol")
+
+class TransactionEntry(BaseModel):
+    """Model for individual transaction entry"""
+    transaction_id: str = Field(..., description="Unique transaction ID")
+    amount: float = Field(..., description="Transaction amount")
+    transaction_type: Literal["credit", "debit", "refund", "cashback", "payment", "withdrawal"] = Field(..., description="Type of transaction")
+    description: str = Field(..., description="Transaction description")
+    reference_id: Optional[str] = Field(None, description="Reference ID for the transaction")
+    balance_before: float = Field(..., description="Balance before transaction")
+    balance_after: float = Field(..., description="Balance after transaction")
+    timestamp: datetime = Field(..., description="Transaction timestamp")
+    status: Literal["completed", "pending", "failed"] = Field(default="completed", description="Transaction status")
+
+class TransactionHistoryResponse(BaseModel):
+    """Response model for transaction history"""
+    transactions: List[TransactionEntry] = Field(..., description="List of transactions")
+    total_count: int = Field(..., description="Total number of transactions")
+    page: int = Field(..., description="Current page number")
+    per_page: int = Field(..., description="Number of items per page")
+    total_pages: int = Field(..., description="Total number of pages")
+
+class WalletSummaryResponse(BaseModel):
+    """Response model for wallet summary"""
+    balance: float = Field(..., description="Current wallet balance")
+    formatted_balance: str = Field(..., description="Formatted balance with currency symbol")
+    recent_transactions: List[TransactionEntry] = Field(..., description="Recent transactions")
+
+class AddMoneyRequest(BaseModel):
+    """Request model for adding money to wallet"""
+    amount: float = Field(..., gt=0, description="Amount to add (must be positive)")
+    payment_method: Literal["card", "upi", "netbanking"] = Field(..., description="Payment method")
+    reference_id: Optional[str] = Field(None, description="Payment reference ID")
+    description: Optional[str] = Field("Wallet top-up", description="Transaction description")
+
+class WithdrawMoneyRequest(BaseModel):
+    """Request model for withdrawing money from wallet"""
+    amount: float = Field(..., gt=0, description="Amount to withdraw (must be positive)")
+    bank_account_id: str = Field(..., description="Bank account ID for withdrawal")
+    description: Optional[str] = Field("Wallet withdrawal", description="Transaction description")
+
+class TransactionRequest(BaseModel):
+    """Generic transaction request model"""
+    amount: float = Field(..., gt=0, description="Transaction amount")
+    transaction_type: Literal["credit", "debit", "refund", "cashback", "payment"] = Field(..., description="Transaction type")
+    description: str = Field(..., description="Transaction description")
+    reference_id: Optional[str] = Field(None, description="Reference ID")
+    category: Optional[str] = Field(None, description="Transaction category")
+
+class TransactionResponse(BaseModel):
+    """Response model for transaction operations"""
+    success: bool = Field(..., description="Transaction success status")
+    message: str = Field(..., description="Response message")
+    transaction: Optional[TransactionEntry] = Field(None, description="Transaction details")
+    new_balance: Optional[float] = Field(None, description="New wallet balance after transaction")
+
+class WalletTransactionResponse(BaseModel):
+    """Response model for wallet transaction operations"""
+    success: bool = Field(..., description="Transaction success status")
+    message: str = Field(..., description="Response message")
+    transaction_id: Optional[str] = Field(None, description="Transaction ID if successful")
+    new_balance: Optional[float] = Field(None, description="New wallet balance after transaction")

app/services/wallet_service.py

@@ -0,0 +1,212 @@
+from typing import Dict, Any, Optional
+import logging
+from datetime import datetime
+
+from app.models.wallet_model import WalletModel
+from app.schemas.wallet_schema import (
+    WalletBalanceResponse, WalletSummaryResponse, TransactionHistoryResponse,
+    TransactionEntry, WalletTransactionResponse
+)
+
+logger = logging.getLogger(__name__)
+
+class WalletService:
+    """Service for wallet operations"""
+    
+    @staticmethod
+    async def get_wallet_balance(user_id: str) -> WalletBalanceResponse:
+        """Get formatted wallet balance for user"""
+        try:
+            balance = await WalletModel.get_wallet_balance(user_id)
+            
+            return WalletBalanceResponse(
+                balance=balance,
+                currency="INR",
+                formatted_balance=f"₹{balance:,.2f}"
+            )
+            
+        except Exception as e:
+            logger.error(f"Error getting wallet balance for user {user_id}: {str(e)}")
+            return WalletBalanceResponse(
+                balance=0.0,
+                currency="INR",
+                formatted_balance="₹0.00"
+            )
+    
+    @staticmethod
+    async def get_wallet_summary(user_id: str) -> WalletSummaryResponse:
+        """Get wallet summary with balance and recent transactions"""
+        try:
+            summary_data = await WalletModel.get_wallet_summary(user_id)
+            
+            # Convert transactions to schema format
+            recent_transactions = []
+            for transaction in summary_data.get("recent_transactions", []):
+                recent_transactions.append(TransactionEntry(
+                    transaction_id=transaction["_id"],
+                    amount=transaction["amount"],
+                    transaction_type=transaction["transaction_type"],
+                    description=transaction["description"],
+                    reference_id=transaction.get("reference_id"),
+                    balance_before=transaction["balance_before"],
+                    balance_after=transaction["balance_after"],
+                    timestamp=transaction["timestamp"],
+                    status=transaction["status"]
+                ))
+            
+            balance = summary_data.get("balance", 0.0)
+            
+            return WalletSummaryResponse(
+                balance=balance,
+                formatted_balance=f"₹{balance:,.2f}",
+                recent_transactions=recent_transactions
+            )
+            
+        except Exception as e:
+            logger.error(f"Error getting wallet summary for user {user_id}: {str(e)}")
+            return WalletSummaryResponse(
+                balance=0.0,
+                formatted_balance="₹0.00",
+                recent_transactions=[]
+            )
+    
+    @staticmethod
+    async def get_transaction_history(user_id: str, page: int = 1, per_page: int = 20) -> TransactionHistoryResponse:
+        """Get paginated transaction history"""
+        try:
+            history_data = await WalletModel.get_transaction_history(user_id, page, per_page)
+            
+            # Convert transactions to schema format
+            transactions = []
+            for transaction in history_data.get("transactions", []):
+                transactions.append(TransactionEntry(
+                    transaction_id=transaction["_id"],
+                    amount=transaction["amount"],
+                    transaction_type=transaction["transaction_type"],
+                    description=transaction["description"],
+                    reference_id=transaction.get("reference_id"),
+                    balance_before=transaction["balance_before"],
+                    balance_after=transaction["balance_after"],
+                    timestamp=transaction["timestamp"],
+                    status=transaction["status"]
+                ))
+            
+            return TransactionHistoryResponse(
+                transactions=transactions,
+                total_count=history_data.get("total_count", 0),
+                page=page,
+                per_page=per_page,
+                total_pages=history_data.get("total_pages", 0)
+            )
+            
+        except Exception as e:
+            logger.error(f"Error getting transaction history for user {user_id}: {str(e)}")
+            return TransactionHistoryResponse(
+                transactions=[],
+                total_count=0,
+                page=page,
+                per_page=per_page,
+                total_pages=0
+            )
+    
+    @staticmethod
+    async def add_money(user_id: str, amount: float, payment_method: str, 
+                       description: str = "Wallet top-up", reference_id: str = None) -> WalletTransactionResponse:
+        """Add money to wallet"""
+        try:
+            success = await WalletModel.update_balance(
+                user_id=user_id,
+                amount=amount,
+                transaction_type="credit",
+                description=f"{description} via {payment_method}",
+                reference_id=reference_id
+            )
+            
+            if success:
+                new_balance = await WalletModel.get_wallet_balance(user_id)
+                return WalletTransactionResponse(
+                    success=True,
+                    message=f"Successfully added ₹{amount:,.2f} to wallet",
+                    transaction_id=reference_id,
+                    new_balance=new_balance
+                )
+            else:
+                return WalletTransactionResponse(
+                    success=False,
+                    message="Failed to add money to wallet"
+                )
+                
+        except Exception as e:
+            logger.error(f"Error adding money to wallet for user {user_id}: {str(e)}")
+            return WalletTransactionResponse(
+                success=False,
+                message="Internal error occurred while adding money"
+            )
+    
+    @staticmethod
+    async def deduct_money(user_id: str, amount: float, description: str, 
+                          reference_id: str = None) -> WalletTransactionResponse:
+        """Deduct money from wallet (for payments)"""
+        try:
+            success = await WalletModel.update_balance(
+                user_id=user_id,
+                amount=amount,
+                transaction_type="debit",
+                description=description,
+                reference_id=reference_id
+            )
+            
+            if success:
+                new_balance = await WalletModel.get_wallet_balance(user_id)
+                return WalletTransactionResponse(
+                    success=True,
+                    message=f"Successfully deducted ₹{amount:,.2f} from wallet",
+                    transaction_id=reference_id,
+                    new_balance=new_balance
+                )
+            else:
+                return WalletTransactionResponse(
+                    success=False,
+                    message="Insufficient balance or transaction failed"
+                )
+                
+        except Exception as e:
+            logger.error(f"Error deducting money from wallet for user {user_id}: {str(e)}")
+            return WalletTransactionResponse(
+                success=False,
+                message="Internal error occurred while processing payment"
+            )
+    
+    @staticmethod
+    async def process_refund(user_id: str, amount: float, description: str, 
+                           reference_id: str = None) -> WalletTransactionResponse:
+        """Process refund to wallet"""
+        try:
+            success = await WalletModel.update_balance(
+                user_id=user_id,
+                amount=amount,
+                transaction_type="refund",
+                description=description,
+                reference_id=reference_id
+            )
+            
+            if success:
+                new_balance = await WalletModel.get_wallet_balance(user_id)
+                return WalletTransactionResponse(
+                    success=True,
+                    message=f"Refund of ₹{amount:,.2f} processed successfully",
+                    transaction_id=reference_id,
+                    new_balance=new_balance
+                )
+            else:
+                return WalletTransactionResponse(
+                    success=False,
+                    message="Failed to process refund"
+                )
+                
+        except Exception as e:
+            logger.error(f"Error processing refund for user {user_id}: {str(e)}")
+            return WalletTransactionResponse(
+                success=False,
+                message="Internal error occurred while processing refund"
+            )