feat(favorites): add favorites feature for merchants

implement full CRUD operations for user favorites including:
- add/remove merchants to favorites
- list favorites with pagination
- check favorite status
- update favorite notes
- get favorite details

README.md

@@ -1,11 +0,0 @@
----
-title: Bookmyservice Ums
-emoji: 📉
-colorFrom: blue
-colorTo: blue
-sdk: docker
-pinned: false
-short_description: User Management Services
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

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, wallet_router, address_router, pet_router, guest_router
+from app.routers import user_router, profile_router, account_router, wallet_router, address_router, pet_router, guest_router, favorite_router
 from app.middleware.rate_limiter import RateLimitMiddleware
 from app.middleware.security_middleware import SecurityMiddleware
 import logging
@@ -52,6 +52,7 @@ app.include_router(wallet_router.router, prefix="/wallet", tags=["wallet_managem
 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.include_router(favorite_router.router, prefix="/api/v1/users", tags=["favorites"])
 
 @app.get("/")
 def root():

app/models/favorite_model.py

@@ -0,0 +1,180 @@
+from fastapi import HTTPException
+from app.core.nosql_client import db
+import logging
+from datetime import datetime
+from typing import Optional
+
+logger = logging.getLogger("favorite_model")
+
+class BookMyServiceFavoriteModel:
+    collection = db["favourites"]
+
+    @staticmethod
+    async def create_favorite(
+        customer_id: str,
+        merchant_id: str,
+        merchant_category: str,
+        merchant_name: str,
+        notes: Optional[str] = None
+    ):
+        """Create a new favorite merchant entry"""
+        logger.info(f"Creating favorite for customer {customer_id}, merchant {merchant_id}")
+        
+        try:
+            # Check if favorite already exists
+            existing_favorite = await BookMyServiceFavoriteModel.collection.find_one({
+                "customer_id": customer_id,
+                "merchant_id": merchant_id
+            })
+            
+            if existing_favorite:
+                logger.warning(f"Favorite already exists for customer {customer_id}, merchant {merchant_id}")
+                raise HTTPException(status_code=409, detail="Merchant already in favorites")
+            
+            # Create favorite document
+            favorite_doc = {
+                "customer_id": customer_id,
+                "merchant_id": merchant_id,
+                "merchant_category": merchant_category,
+                "merchant_name": merchant_name,
+                "added_at": datetime.utcnow(),
+                "notes": notes
+            }
+            
+            result = await BookMyServiceFavoriteModel.collection.insert_one(favorite_doc)
+            logger.info(f"Favorite created successfully with ID: {result.inserted_id}")
+            
+            return favorite_doc
+            
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Error creating favorite: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to create favorite")
+
+    @staticmethod
+    async def delete_favorite(customer_id: str, merchant_id: str):
+        """Remove a merchant from favorites"""
+        logger.info(f"Deleting favorite for customer {customer_id}, merchant {merchant_id}")
+        
+        try:
+            result = await BookMyServiceFavoriteModel.collection.delete_one({
+                "customer_id": customer_id,
+                "merchant_id": merchant_id
+            })
+            
+            if result.deleted_count == 0:
+                logger.warning(f"Favorite not found for customer {customer_id}, merchant {merchant_id}")
+                raise HTTPException(status_code=404, detail="Favorite not found")
+            
+            logger.info(f"Favorite deleted successfully")
+            return True
+            
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Error deleting favorite: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to delete favorite")
+
+    @staticmethod
+    async def get_favorites(
+        customer_id: str,
+        category: Optional[str] = None,
+        skip: int = 0,
+        limit: int = 50
+    ):
+        """Get user's favorite merchants, optionally filtered by category"""
+        logger.info(f"Getting favorites for customer {customer_id}, category: {category}")
+        
+        try:
+            # Build query
+            query = {"customer_id": customer_id}
+            if category:
+                query["merchant_category"] = category
+            
+            # Get favorites with pagination
+            cursor = BookMyServiceFavoriteModel.collection.find(query).sort("added_at", -1).skip(skip).limit(limit)
+            favorites = await cursor.to_list(length=limit)
+            
+            # Get total count for pagination
+            total_count = await BookMyServiceFavoriteModel.collection.count_documents(query)
+            
+            logger.info(f"Found {len(favorites)} favorites for customer {customer_id}")
+            
+            return {
+                "favorites": favorites,
+                "total_count": total_count,
+                "skip": skip,
+                "limit": limit
+            }
+            
+        except Exception as e:
+            logger.error(f"Error getting favorites: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to get favorites")
+
+    @staticmethod
+    async def get_favorite(customer_id: str, merchant_id: str):
+        """Get a specific favorite entry"""
+        logger.info(f"Getting favorite for customer {customer_id}, merchant {merchant_id}")
+        
+        try:
+            favorite = await BookMyServiceFavoriteModel.collection.find_one({
+                "customer_id": customer_id,
+                "merchant_id": merchant_id
+            })
+            
+            if not favorite:
+                logger.warning(f"Favorite not found for customer {customer_id}, merchant {merchant_id}")
+                raise HTTPException(status_code=404, detail="Favorite not found")
+            
+            return favorite
+            
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Error getting favorite: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to get favorite")
+
+    @staticmethod
+    async def update_favorite_notes(customer_id: str, merchant_id: str, notes: str):
+        """Update notes for a favorite merchant"""
+        logger.info(f"Updating notes for customer {customer_id}, merchant {merchant_id}")
+        
+        try:
+            result = await BookMyServiceFavoriteModel.collection.update_one(
+                {
+                    "customer_id": customer_id,
+                    "merchant_id": merchant_id
+                },
+                {"$set": {"notes": notes, "updated_at": datetime.utcnow()}}
+            )
+            
+            if result.matched_count == 0:
+                logger.warning(f"Favorite not found for customer {customer_id}, merchant {merchant_id}")
+                raise HTTPException(status_code=404, detail="Favorite not found")
+            
+            logger.info(f"Favorite notes updated successfully")
+            return True
+            
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Error updating favorite notes: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to update favorite notes")
+
+    @staticmethod
+    async def is_favorite(customer_id: str, merchant_id: str) -> bool:
+        """Check if a merchant is in user's favorites"""
+        logger.debug(f"Checking if merchant {merchant_id} is favorite for customer {customer_id}")
+        
+        try:
+            favorite = await BookMyServiceFavoriteModel.collection.find_one({
+                "customer_id": customer_id,
+                "merchant_id": merchant_id
+            })
+            
+            return favorite is not None
+            
+        except Exception as e:
+            logger.error(f"Error checking favorite status: {str(e)}", exc_info=True)
+            return False

app/routers/favorite_router.py

@@ -0,0 +1,196 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from typing import Optional
+from app.schemas.favorite_schema import (
+    FavoriteCreateRequest,
+    FavoriteUpdateRequest,
+    FavoriteResponse,
+    FavoritesListResponse,
+    FavoriteStatusResponse,
+    FavoriteSuccessResponse
+)
+from app.services.favorite_service import FavoriteService
+from app.services.user_service import UserService
+from app.utils.jwt import get_current_user
+import logging
+
+logger = logging.getLogger("favorite_router")
+
+router = APIRouter(
+    prefix="/favorites",
+    tags=["favorites"],
+    responses={404: {"description": "Not found"}},
+)
+
+@router.post(
+    "",
+    response_model=FavoriteSuccessResponse,
+    status_code=status.HTTP_201_CREATED,
+    summary="Add merchant to favorites",
+    description="Add a merchant to the user's list of favorite merchants"
+)
+async def add_favorite(
+    favorite_data: FavoriteCreateRequest,
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Add a merchant to user's favorites.
+    
+    - **merchant_id**: ID of the merchant to favorite
+    - **merchant_category**: Category of the merchant (salon, spa, pet_spa, etc.)
+    - **merchant_name**: Name of the merchant for quick display
+    - **notes**: Optional note about this favorite
+    """
+    try:
+        return await FavoriteService.add_favorite(
+            customer_id=current_user["user_id"],
+            favorite_data=favorite_data
+        )
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Error in add_favorite endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@router.delete(
+    "/{merchant_id}",
+    response_model=FavoriteSuccessResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Remove merchant from favorites",
+    description="Remove a merchant from the user's list of favorite merchants"
+)
+async def remove_favorite(
+    merchant_id: str,
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Remove a merchant from user's favorites.
+    
+    - **merchant_id**: ID of the merchant to remove from favorites
+    """
+    try:
+        return await FavoriteService.remove_favorite(
+            customer_id=current_user["user_id"],
+            merchant_id=merchant_id
+        )
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Error in remove_favorite endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@router.get(
+    "",
+    response_model=FavoritesListResponse,
+    status_code=status.HTTP_200_OK,
+    summary="List favorite merchants",
+    description="Get user's list of favorite merchants, optionally filtered by category"
+)
+async def list_favorites(
+    category: Optional[str] = Query(None, description="Filter by merchant category"),
+    skip: int = Query(0, ge=0, description="Number of items to skip"),
+    limit: int = Query(50, ge=1, le=100, description="Maximum number of items to return"),
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Get user's favorite merchants.
+    
+    - **category**: Optional filter by merchant category
+    - **skip**: Number of items to skip (for pagination)
+    - **limit**: Maximum number of items to return (max 100)
+    """
+    try:
+        return await FavoriteService.get_favorites(
+            customer_id=current_user["user_id"],
+            category=category,
+            skip=skip,
+            limit=limit
+        )
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Error in list_favorites endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@router.get(
+    "/{merchant_id}/status",
+    response_model=FavoriteStatusResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Check favorite status",
+    description="Check if a merchant is in user's favorites"
+)
+async def check_favorite_status(
+    merchant_id: str,
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Check if a merchant is in user's favorites.
+    
+    - **merchant_id**: ID of the merchant to check
+    """
+    try:
+        return await FavoriteService.check_favorite_status(
+            customer_id=current_user["user_id"],
+            merchant_id=merchant_id
+        )
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Error in check_favorite_status endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@router.get(
+    "/{merchant_id}",
+    response_model=FavoriteResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Get favorite details",
+    description="Get detailed information about a specific favorite merchant"
+)
+async def get_favorite_details(
+    merchant_id: str,
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Get detailed information about a specific favorite merchant.
+    
+    - **merchant_id**: ID of the merchant
+    """
+    try:
+        return await FavoriteService.get_favorite_details(
+            customer_id=current_user["user_id"],
+            merchant_id=merchant_id
+        )
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Error in get_favorite_details endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@router.patch(
+    "/{merchant_id}/notes",
+    response_model=FavoriteSuccessResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Update favorite notes",
+    description="Update the notes for a favorite merchant"
+)
+async def update_favorite_notes(
+    merchant_id: str,
+    notes_data: FavoriteUpdateRequest,
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Update the notes for a favorite merchant.
+    
+    - **merchant_id**: ID of the merchant
+    - **notes**: Updated note about this favorite
+    """
+    try:
+        return await FavoriteService.update_favorite_notes(
+            customer_id=current_user["user_id"],
+            merchant_id=merchant_id,
+            notes_data=notes_data
+        )
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Error in update_favorite_notes endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal server error")

app/schemas/favorite_schema.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from datetime import datetime
+
+class FavoriteCreateRequest(BaseModel):
+    """Request schema for creating a favorite"""
+    merchant_id: str = Field(..., description="ID of the merchant to favorite")
+    merchant_category: str = Field(..., description="Category of the merchant (salon, spa, pet_spa, etc.)")
+    merchant_name: str = Field(..., description="Name of the merchant for quick display")
+    notes: Optional[str] = Field(None, description="Optional note about this favorite")
+
+class FavoriteUpdateRequest(BaseModel):
+    """Request schema for updating favorite notes"""
+    notes: Optional[str] = Field(None, description="Updated note about this favorite")
+
+class FavoriteResponse(BaseModel):
+    """Response schema for a favorite merchant"""
+    id: str = Field(..., description="Favorite ID")
+    customer_id: str = Field(..., description="ID of the customer who favorited")
+    merchant_id: str = Field(..., description="ID of the merchant")
+    merchant_category: str = Field(..., description="Category of the merchant")
+    merchant_name: str = Field(..., description="Name of the merchant")
+    added_at: datetime = Field(..., description="When the merchant was favorited")
+    notes: Optional[str] = Field(None, description="Optional note about this favorite")
+
+class FavoritesListResponse(BaseModel):
+    """Response schema for listing favorites"""
+    favorites: List[FavoriteResponse] = Field(..., description="List of favorite merchants")
+    total_count: int = Field(..., description="Total number of favorites")
+    skip: int = Field(..., description="Number of items skipped")
+    limit: int = Field(..., description="Maximum number of items returned")
+
+class FavoriteStatusResponse(BaseModel):
+    """Response schema for checking favorite status"""
+    is_favorite: bool = Field(..., description="Whether the merchant is in favorites")
+    favorite_id: Optional[str] = Field(None, description="ID of the favorite if exists")
+
+class FavoriteSuccessResponse(BaseModel):
+    """Response schema for successful favorite operations"""
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Operation result message")
+    favorite_id: Optional[str] = Field(None, description="ID of the created/updated favorite")

app/services/favorite_service.py

@@ -0,0 +1,171 @@
+from fastapi import HTTPException, Depends
+from typing import Optional
+from app.models.favorite_model import BookMyServiceFavoriteModel
+from app.schemas.favorite_schema import (
+    FavoriteCreateRequest,
+    FavoriteUpdateRequest,
+    FavoriteResponse,
+    FavoritesListResponse,
+    FavoriteStatusResponse,
+    FavoriteSuccessResponse
+)
+from app.services.user_service import UserService
+import logging
+
+logger = logging.getLogger("favorite_service")
+
+class FavoriteService:
+    
+    @staticmethod
+    async def add_favorite(
+        customer_id: str,
+        favorite_data: FavoriteCreateRequest
+    ) -> FavoriteSuccessResponse:
+        """Add a merchant to user's favorites"""
+        try:
+            # Create favorite in database
+            favorite_doc = await BookMyServiceFavoriteModel.create_favorite(
+                customer_id=customer_id,
+                merchant_id=favorite_data.merchant_id,
+                merchant_category=favorite_data.merchant_category,
+                merchant_name=favorite_data.merchant_name,
+                notes=favorite_data.notes
+            )
+            
+            return FavoriteSuccessResponse(
+                success=True,
+                message="Merchant added to favorites successfully",
+                favorite_id=str(favorite_doc.get("_id")) if favorite_doc.get("_id") else None
+            )
+            
+        except HTTPException as e:
+            raise e
+        except Exception as e:
+            logger.error(f"Error adding favorite: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to add favorite")
+
+    @staticmethod
+    async def remove_favorite(customer_id: str, merchant_id: str) -> FavoriteSuccessResponse:
+        """Remove a merchant from user's favorites"""
+        try:
+            await BookMyServiceFavoriteModel.delete_favorite(customer_id, merchant_id)
+            
+            return FavoriteSuccessResponse(
+                success=True,
+                message="Merchant removed from favorites successfully",
+                favorite_id=None
+            )
+            
+        except HTTPException as e:
+            raise e
+        except Exception as e:
+            logger.error(f"Error removing favorite: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to remove favorite")
+
+    @staticmethod
+    async def get_favorites(
+        customer_id: str,
+        category: Optional[str] = None,
+        skip: int = 0,
+        limit: int = 50
+    ) -> FavoritesListResponse:
+        """Get user's favorite merchants"""
+        try:
+            result = await BookMyServiceFavoriteModel.get_favorites(
+                customer_id=customer_id,
+                category=category,
+                skip=skip,
+                limit=limit
+            )
+            
+            # Convert MongoDB documents to response format
+            favorites = []
+            for fav in result["favorites"]:
+                favorites.append(FavoriteResponse(
+                    id=str(fav["_id"]),
+                    customer_id=fav["customer_id"],
+                    merchant_id=fav["merchant_id"],
+                    merchant_category=fav["merchant_category"],
+                    merchant_name=fav["merchant_name"],
+                    added_at=fav["added_at"],
+                    notes=fav.get("notes")
+                ))
+            
+            return FavoritesListResponse(
+                favorites=favorites,
+                total_count=result["total_count"],
+                skip=result["skip"],
+                limit=result["limit"]
+            )
+            
+        except Exception as e:
+            logger.error(f"Error getting favorites: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to get favorites")
+
+    @staticmethod
+    async def check_favorite_status(customer_id: str, merchant_id: str) -> FavoriteStatusResponse:
+        """Check if a merchant is in user's favorites"""
+        try:
+            is_fav = await BookMyServiceFavoriteModel.is_favorite(customer_id, merchant_id)
+            
+            favorite_id = None
+            if is_fav:
+                favorite = await BookMyServiceFavoriteModel.get_favorite(customer_id, merchant_id)
+                favorite_id = str(favorite["_id"]) if favorite and favorite.get("_id") else None
+            
+            return FavoriteStatusResponse(
+                is_favorite=is_fav,
+                favorite_id=favorite_id
+            )
+            
+        except Exception as e:
+            logger.error(f"Error checking favorite status: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to check favorite status")
+
+    @staticmethod
+    async def update_favorite_notes(
+        customer_id: str,
+        merchant_id: str,
+        notes_data: FavoriteUpdateRequest
+    ) -> FavoriteSuccessResponse:
+        """Update notes for a favorite merchant"""
+        try:
+            await BookMyServiceFavoriteModel.update_favorite_notes(
+                customer_id=customer_id,
+                merchant_id=merchant_id,
+                notes=notes_data.notes
+            )
+            
+            return FavoriteSuccessResponse(
+                success=True,
+                message="Favorite notes updated successfully",
+                favorite_id=None
+            )
+            
+        except HTTPException as e:
+            raise e
+        except Exception as e:
+            logger.error(f"Error updating favorite notes: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to update favorite notes")
+
+    @staticmethod
+    async def get_favorite_details(customer_id: str, merchant_id: str) -> FavoriteResponse:
+        """Get detailed information about a specific favorite"""
+        try:
+            favorite = await BookMyServiceFavoriteModel.get_favorite(customer_id, merchant_id)
+            
+            return FavoriteResponse(
+                id=str(favorite["_id"]),
+                customer_id=favorite["customer_id"],
+                merchant_id=favorite["merchant_id"],
+                merchant_category=favorite["merchant_category"],
+                merchant_name=favorite["merchant_name"],
+                added_at=favorite["added_at"],
+                notes=favorite.get("notes")
+            )
+            
+        except HTTPException as e:
+            raise e
+        except Exception as e:
+            logger.error(f"Error getting favorite details: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Failed to get favorite details")

app/services/user_service.py

@@ -44,7 +44,7 @@ class UserService:
                 phone_number = None
                 
             # Generate OTP - hardcoded for testing purposes
-            otp = '77777'
+            otp = '777777'
             logger.debug(f"Generated hardcoded OTP for identifier: {identifier}")
             
             await BookMyServiceOTPModel.store_otp(identifier, phone_number, otp)

main.py

@@ -1,6 +0,0 @@
-def main():
-    print("Hello from bookmyservice-ums!")
-
-
-if __name__ == "__main__":
-    main()

pyproject.toml

@@ -1,7 +0,0 @@
-[project]
-name = "bookmyservice-ums"
-version = "0.1.0"
-description = "Add your description here"
-readme = "README.md"
-requires-python = ">=3.13"
-dependencies = []

test_phone_functionality.py

@@ -1,136 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify phone number functionality in UMS service
-"""
-
-import requests
-import json
-import sys
-
-BASE_URL = "http://127.0.0.1:8001"
-
-def test_phone_validation():
-    """Test phone number validation in various endpoints"""
-    print("🧪 Testing phone number validation...")
-    
-    # Test 1: Valid phone number in send-otp endpoint
-    print("\n1. Testing valid phone number in /auth/send-otp")
-    response = requests.post(f"{BASE_URL}/auth/send-otp", json={
-        "phone": "+1234567890"
-    })
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-    
-    # Test 2: Valid email in send-otp endpoint
-    print("\n2. Testing valid email in /auth/send-otp")
-    response = requests.post(f"{BASE_URL}/auth/send-otp", json={
-        "email": "test@example.com"
-    })
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-    
-    # Test 3: Both email and phone provided (should fail)
-    print("\n3. Testing both email and phone in /auth/send-otp (should fail)")
-    response = requests.post(f"{BASE_URL}/auth/send-otp", json={
-        "email": "test@example.com",
-        "phone": "+1234567890"
-    })
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-    
-    # Test 4: Invalid phone format
-    print("\n4. Testing invalid phone format in /auth/send-otp")
-    response = requests.post(f"{BASE_URL}/auth/send-otp", json={
-        "phone": "invalid-phone"
-    })
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-    
-    # Test 5: New unified endpoint with phone
-    print("\n5. Testing phone number in /auth/send-otp-login")
-    response = requests.post(f"{BASE_URL}/auth/send-otp-login", json={
-        "login_input": "+1234567890"
-    })
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-    
-    # Test 6: New unified endpoint with email
-    print("\n6. Testing email in /auth/send-otp-login")
-    response = requests.post(f"{BASE_URL}/auth/send-otp-login", json={
-        "login_input": "test@example.com"
-    })
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-    
-    # Test 7: Invalid identifier in unified endpoint
-    print("\n7. Testing invalid identifier in /auth/send-otp-login")
-    response = requests.post(f"{BASE_URL}/auth/send-otp-login", json={
-        "login_input": "invalid-identifier"
-    })
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-
-def test_registration_validation():
-    """Test registration endpoint validation"""
-    print("\n🧪 Testing registration validation...")
-    
-    # Test 1: Registration with phone only
-    print("\n1. Testing registration with phone only")
-    response = requests.post(f"{BASE_URL}/auth/register", json={
-        "phone": "+1234567890",
-        "name": "Test User",
-        "mode": "otp",
-        "otp": "123456"
-    }, headers={"Authorization": "dummy-token"})
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-    
-    # Test 2: Registration with email only
-    print("\n2. Testing registration with email only")
-    response = requests.post(f"{BASE_URL}/auth/register", json={
-        "email": "test@example.com",
-        "name": "Test User",
-        "mode": "otp",
-        "otp": "123456"
-    }, headers={"Authorization": "dummy-token"})
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-    
-    # Test 3: Registration with both email and phone (should fail)
-    print("\n3. Testing registration with both email and phone (should fail)")
-    response = requests.post(f"{BASE_URL}/auth/register", json={
-        "email": "test@example.com",
-        "phone": "+1234567890",
-        "name": "Test User",
-        "mode": "otp",
-        "otp": "123456"
-    }, headers={"Authorization": "dummy-token"})
-    print(f"Status: {response.status_code}")
-    print(f"Response: {response.json()}")
-
-def main():
-    """Main test function"""
-    print("🚀 Starting phone number functionality tests...")
-    print(f"Testing against: {BASE_URL}")
-    
-    try:
-        # Check if service is running
-        response = requests.get(f"{BASE_URL}/")
-        print(f"✅ Service is running: {response.json()}")
-        
-        # Run tests
-        test_phone_validation()
-        test_registration_validation()
-        
-        print("\n✅ All tests completed!")
-        
-    except requests.exceptions.ConnectionError:
-        print(f"❌ Could not connect to {BASE_URL}")
-        print("Make sure the UMS service is running on port 8001")
-        sys.exit(1)
-    except Exception as e:
-        print(f"❌ Error during testing: {str(e)}")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()