Add initial implementation of User Management Service

- Create folder structure and necessary files for the service
- Implement FastAPI application with user authentication and OTP functionality
- Set up MongoDB and Redis configurations
- Add user and OTP models, along with services for user registration and login
- Include utility functions for sending SMS and email OTPs
- Define Pydantic schemas for request validation
- Update requirements.txt with necessary dependencies

.env

@@ -0,0 +1,17 @@
+
+MONGO_URI=mongodb+srv://insightfy:k0KXafAbV8A8NmQK@cluster0.2shrc.mongodb.net/test??ssl=true&ssl_cert_reqs=CERT_NONE
+
+DB_NAME=book-my-service
+
+DATABASE_URI=postgresql+asyncpg://trans_owner:BookMyService7@ep-sweet-surf-a1qeduoy.ap-southeast-1.aws.neon.tech/bookmyservice?options=-csearch_path%3Dtrans
+
+CACHE_URI=redis-11382.c305.ap-south-1-1.ec2.redns.redis-cloud.com:11382
+
+#CACHE_URI=redis-11521.crce182.ap-south-1-1.ec2.redns.redis-cloud.com:11521
+
+CACHE_K=dLRZrhU1d5EP9N1CW6grUgsj7MyWIj2i
+
+
+RAZORPAY_KEY_ID=rzp_test_2UTAol2AFSV5VN
+
+RAZORPAY_KEY_SECRET=elb4JNjUw3eLqhVMiLFiRgki

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.11-slim-buster AS base
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app.app:app", "--host", "0.0.0.0", "--port", "7860"]

app/app.py

@@ -0,0 +1,24 @@
+## bookmyservice-ums/app/app.py
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.routers import user_router, profile_router
+
+app = FastAPI(title="BookMyService User Management Service")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(user_router.router, prefix="/auth", tags=["user_auth"])
+app.include_router(profile_router.router, prefix="/profile", tags=["profile"])
+
+@app.get("/")
+def root():
+    return {"message": "BookMyService UMS is running"}
+
+

app/core/cache_client.py

@@ -0,0 +1,26 @@
+import logging
+from redis.asyncio import Redis
+from redis.exceptions import RedisError
+from app.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+# Parse host and port
+CACHE_HOST, CACHE_PORT = settings.CACHE_URI.split(":")
+CACHE_PORT = int(CACHE_PORT)
+
+try:
+    redis_client = Redis(
+        host=CACHE_HOST,
+        port=CACHE_PORT,
+        username="default",
+        password=settings.CACHE_K,
+        decode_responses=True
+    )
+    logger.info("Connected to Redis.")
+except RedisError as e:
+    logger.error(f"Failed to connect to Redis: {e}")
+    raise
+
+async def get_redis() -> Redis:
+    return redis_client

app/core/config.py

@@ -0,0 +1,34 @@
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+class Settings:
+    # MongoDB
+    MONGO_URI: str = os.getenv("MONGO_URI")
+    DB_NAME: str = os.getenv("DB_NAME")
+
+    # Redis
+    CACHE_URI: str = os.getenv("CACHE_URI")
+    CACHE_K: str = os.getenv("CACHE_K")
+
+    SECRET_KEY: str = os.getenv("SECRET_KEY", "B00Kmyservice@7")
+    ALGORITHM: str = os.getenv("ALGORITHM", "HS256")
+
+    TWILIO_ACCOUNT_SID: str = os.getenv("TWILIO_ACCOUNT_SID")
+    TWILIO_AUTH_TOKEN: str = os.getenv("TWILIO_AUTH_TOKEN")
+    TWILIO_SMS_FROM: str = os.getenv("TWILIO_SMS_FROM")
+
+    SMTP_HOST: str = os.getenv("SMTP_HOST")
+    SMTP_PORT: int = int(os.getenv("SMTP_PORT", "587"))
+    SMTP_USER: str = os.getenv("SMTP_USER")
+    SMTP_PASS: str = os.getenv("SMTP_PASS")
+    SMTP_FROM: str = os.getenv("SMTP_FROM")
+
+    def __post_init__(self):
+        if not self.MONGO_URI or not self.DB_NAME:
+            raise ValueError("MongoDB URI or DB_NAME not configured.")
+        if not self.CACHE_URI or not self.CACHE_K:
+            raise ValueError("Redis URI or password (CACHE_K) not configured.")
+
+settings = Settings()

app/core/nosql_client.py

@@ -0,0 +1,11 @@
+import logging
+from motor.motor_asyncio import AsyncIOMotorClient
+from app.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+mongo_client = AsyncIOMotorClient(settings.MONGO_URI)
+db = mongo_client[settings.DB_NAME]
+
+async def get_mongo_client() -> AsyncIOMotorClient:
+    return mongo_client

app/models/otp_model.py

@@ -0,0 +1,59 @@
+from fastapi import HTTPException
+from app.core.cache_client import get_redis
+from app.utils.sms_utils import send_sms_otp
+from app.utils.email_utils import send_email_otp
+from app.utils.common_utils import is_email
+
+class BookMyServiceOTPModel:
+    OTP_TTL = 300  # 5 minutes
+    RATE_LIMIT_MAX = 3
+    RATE_LIMIT_WINDOW = 600  # 10 minutes
+
+    @staticmethod
+    async def store_otp(identifier: str, phone: str, otp: str, ttl: int = OTP_TTL):
+        redis = await get_redis()
+
+        # Rate limit: max 3 OTPs per 10 minutes
+        rate_key = f"otp_rate_limit:{identifier}"
+        attempts = await redis.incr(rate_key)
+        if attempts == 1:
+            await redis.expire(rate_key, BookMyServiceOTPModel.RATE_LIMIT_WINDOW)
+        elif attempts > BookMyServiceOTPModel.RATE_LIMIT_MAX:
+            raise HTTPException(status_code=429, detail="Too many OTP requests. Try again later.")
+
+        # Store OTP
+        await redis.setex(f"bms_otp:{identifier}", ttl, otp)
+
+        # Send OTP via SMS, fallback to Email if identifier is email
+        try:
+            sid = send_sms_otp(phone, otp)
+            print(f"OTP {otp} sent to {phone} via SMS. SID: {sid}")
+        except Exception as sms_error:
+            print(f"⚠️ SMS failed: {sms_error}")
+            if is_email(identifier):
+                try:
+                    send_email_otp(identifier, otp)
+                    print(f"✅ OTP {otp} sent to {identifier} via email fallback.")
+                except Exception as email_error:
+                    raise HTTPException(status_code=500, detail=f"SMS and email both failed: {email_error}")
+            else:
+                raise HTTPException(status_code=500, detail="SMS failed and no email fallback available.")
+
+    @staticmethod
+    async def verify_otp(identifier: str, otp: str):
+        redis = await get_redis()
+        key = f"bms_otp:{identifier}"
+        stored = await redis.get(key)
+        if stored and stored == otp:
+            await redis.delete(key)
+            return True
+        return False
+
+    @staticmethod
+    async def read_otp(identifier: str):
+        redis = await get_redis()
+        key = f"bms_otp:{identifier}"
+        otp = await redis.get(key)
+        if otp:
+            return otp
+        raise HTTPException(status_code=404, detail="OTP not found or expired")

app/models/user_model.py

@@ -0,0 +1,44 @@
+from fastapi import HTTPException
+from app.core.nosql_client import db
+from app.utils.common_utils import is_email  # Assumes utility exists
+
+class BookMyServiceUserModel:
+    collection = db["book_my_service_users"]
+
+    @staticmethod
+    async def find_by_email(email: str):
+        return await BookMyServiceUserModel.collection.find_one({"email": email})
+
+    @staticmethod
+    async def find_by_mobile(mobile: str):
+        return await BookMyServiceUserModel.collection.find_one({"mobile": mobile})
+
+    @staticmethod
+    async def find_by_identifier(identifier: str):
+        if is_email(identifier):
+            user = await BookMyServiceUserModel.find_by_email(identifier)
+        else:
+            user = await BookMyServiceUserModel.find_by_mobile(identifier)
+
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found with this email or mobile")
+        return user
+
+    @staticmethod
+    async def exists_by_email_or_phone(email: str, phone: str) -> bool:
+        return await BookMyServiceUserModel.collection.find_one({
+            "$or": [{"email": email}, {"mobile": phone}]
+        }) is not None
+
+    @staticmethod
+    async def create(user_data: dict):
+        result = await BookMyServiceUserModel.collection.insert_one(user_data)
+        return result.inserted_id
+
+    @staticmethod
+    async def update_by_identifier(identifier: str, update_fields: dict):
+        query = {"email": identifier} if is_email(identifier) else {"mobile": identifier}
+        result = await BookMyServiceUserModel.collection.update_one(query, {"$set": update_fields})
+        if result.matched_count == 0:
+            raise HTTPException(status_code=404, detail="User not found")
+        return result.modified_count > 0

app/routers/profile_router.py

@@ -0,0 +1,11 @@
+
+## bookmyservice-ums/app/routers/profile_router.py
+
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/me")
+def get_profile():
+    return {"user": "Sample user profile - implement real logic here"}
+

app/routers/user_router.py

@@ -0,0 +1,29 @@
+## bookmyservice-ums/app/routers/user_router.py
+
+from fastapi import APIRouter, HTTPException
+from app.schemas.user_schema import OTPRequest, OTPVerifyRequest, UserRegisterRequest, OAuthLoginRequest, TokenResponse
+from app.services.user_service import UserService
+from app.utils.jwt import create_access_token
+
+router = APIRouter()
+
+@router.post("/send-otp")
+async def send_otp_handler(payload: OTPRequest):
+    identifier = payload.email or payload.phone
+    if not identifier:
+        raise HTTPException(status_code=400, detail="Email or phone required")
+    await UserService.send_otp(identifier, payload.phone or "N/A")
+    return {"message": "OTP sent"}
+
+@router.post("/verify-otp", response_model=TokenResponse)
+async def verify_otp_handler(payload: OTPVerifyRequest):
+    return await UserService.verify_otp_and_login(payload.login_input, payload.otp)
+
+@router.post("/oauth-login", response_model=TokenResponse)
+async def oauth_login_handler(payload: OAuthLoginRequest):
+    user_id = f"{payload.provider}_{payload.token}"  # In production: validate token and extract user info
+    return await UserService.verify_otp_and_login(user_id, otp="")  # simulate OTP match via token
+
+@router.post("/register", response_model=TokenResponse)
+async def register_user(payload: UserRegisterRequest):
+    return await UserService.register(payload)

app/schemas/user_schema.py

@@ -0,0 +1,47 @@
+from pydantic import BaseModel, EmailStr
+from typing import Optional, Literal
+
+# Used for OTP-based or OAuth-based user registration
+class UserRegisterRequest(BaseModel):
+    full_name: str
+    email: Optional[EmailStr] = None
+    phone: Optional[str] = None
+    otp: Optional[str] = None
+    oauth_token: Optional[str] = None
+    provider: Optional[Literal["google", "apple"]] = None
+    mode: Literal["otp", "oauth"]
+
+# Used in login form (optional display name prefilled from local storage)
+class UserLoginRequest(BaseModel):
+    name: Optional[str] = None
+    email: EmailStr
+
+# OTP request via email or phone
+class OTPRequest(BaseModel):
+    email: Optional[EmailStr] = None
+    phone: Optional[str] = None
+
+# Generic OTP request using single login input
+class OTPRequestWithLogin(BaseModel):
+    login_input: str  # email or phone
+
+# OTP verification input
+class OTPVerifyRequest(BaseModel):
+    login_input: str
+    otp: str
+
+# OAuth login using Google/Apple
+class OAuthLoginRequest(BaseModel):
+    provider: Literal["google", "apple"]
+    token: str
+
+# JWT Token response format
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+# Optional: profile info response post-login
+class UserProfileResponse(BaseModel):
+    user_id: str
+    full_name: str
+    email: Optional[EmailStr] = None

app/services/otp_service.py

@@ -0,0 +1,47 @@
+from fastapi import HTTPException
+from app.core.cache_client import get_redis
+from app.utils.sms_utils import send_sms_otp
+from app.utils.email_utils import send_email_otp
+from app.utils.common_utils import is_email
+
+class BookMyServiceOTPModel:
+    OTP_TTL = 300  # 5 minutes
+    RATE_LIMIT_MAX = 3
+    RATE_LIMIT_WINDOW = 600  # 10 minutes
+
+    @staticmethod
+    async def store_otp(identifier: str, phone: str, otp: str, ttl: int = OTP_TTL):
+        redis = await get_redis()
+
+        rate_key = f"otp_rate_limit:{identifier}"
+        attempts = await redis.incr(rate_key)
+        if attempts == 1:
+            await redis.expire(rate_key, BookMyServiceOTPModel.RATE_LIMIT_WINDOW)
+        elif attempts > BookMyServiceOTPModel.RATE_LIMIT_MAX:
+            raise HTTPException(status_code=429, detail="Too many OTP requests. Try again later.")
+
+        await redis.setex(f"bms_otp:{identifier}", ttl, otp)
+
+        try:
+            sid = send_sms_otp(phone, otp)
+            print(f"✅ OTP {otp} sent to {phone}. SID: {sid}")
+        except Exception as sms_error:
+            print(f"⚠️ SMS failed: {sms_error}")
+            if is_email(identifier):
+                try:
+                    send_email_otp(identifier, otp)
+                    print(f"✅ OTP {otp} sent to {identifier} via email fallback.")
+                except Exception as email_error:
+                    raise HTTPException(status_code=500, detail=f"SMS and email both failed: {email_error}")
+            else:
+                raise HTTPException(status_code=500, detail="SMS failed and no fallback available.")
+
+    @staticmethod
+    async def verify_otp(identifier: str, otp: str):
+        redis = await get_redis()
+        key = f"bms_otp:{identifier}"
+        stored = await redis.get(key)
+        if stored and stored == otp:
+            await redis.delete(key)
+            return True
+        return False

app/services/user_service.py

@@ -0,0 +1,80 @@
+import random
+from jose import jwt
+from datetime import datetime, timedelta
+from fastapi import HTTPException
+from app.models.user_model import BookMyServiceUserModel
+from app.models.otp_model import BookMyServiceOTPModel
+from app.core.config import settings
+from app.utils.common_utils import is_email
+from app.schemas.user_schema import UserRegisterRequest
+import logging
+
+logger = logging.getLogger("user_service")
+
+class UserService:
+    @staticmethod
+    async def send_otp(identifier: str, phone: str):
+        otp = str(random.randint(100000, 999999))
+        await BookMyServiceOTPModel.store_otp(identifier, phone, otp)
+        logger.debug(f"OTP sent to {identifier}: {otp}")
+
+    @staticmethod
+    async def verify_otp_and_login(identifier: str, otp: str):
+        if not await BookMyServiceOTPModel.verify_otp(identifier, otp):
+            logger.debug(f"Invalid or expired OTP for identifier: {identifier}")
+            raise HTTPException(status_code=400, detail="Invalid or expired OTP")
+
+        user = await BookMyServiceUserModel.find_by_identifier(identifier)
+        if not user:
+            logger.debug(f"No user found for identifier: {identifier}")
+            raise HTTPException(status_code=404, detail="User not found")
+
+        token_data = {
+            "sub": user.get("user_id"),
+            "user_id": user.get("user_id"),
+            "email": user.get("email"),
+            "role": "user",
+            "exp": datetime.utcnow() + timedelta(hours=8)
+        }
+        access_token = jwt.encode(token_data, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+        return {"access_token": access_token}
+
+    @staticmethod
+    async def register(data: UserRegisterRequest):
+        if data.mode == "otp":
+            identifier = data.email or data.phone
+            if not data.otp or not identifier:
+                raise HTTPException(status_code=400, detail="OTP and email/phone required")
+            if not await BookMyServiceOTPModel.verify_otp(identifier, data.otp):
+                raise HTTPException(status_code=400, detail="Invalid or expired OTP")
+            user_id = f"otp_{identifier}"
+
+        elif data.mode == "oauth":
+            if not data.oauth_token or not data.provider:
+                raise HTTPException(status_code=400, detail="OAuth token and provider required")
+            user_id = f"{data.provider}_{data.oauth_token}"
+
+        else:
+            raise HTTPException(status_code=400, detail="Unsupported registration mode")
+
+        if await BookMyServiceUserModel.collection.find_one({"user_id": user_id}):
+            raise HTTPException(status_code=409, detail="User already registered")
+
+        user_doc = {
+            "user_id": user_id,
+            "full_name": data.full_name,
+            "email": data.email,
+            "phone": data.phone,
+            "created_at": datetime.utcnow()
+        }
+        await BookMyServiceUserModel.collection.insert_one(user_doc)
+
+        token_data = {
+            "sub": user_id,
+            "user_id": user_id,
+            "email": data.email,
+            "role": "user",
+            "exp": datetime.utcnow() + timedelta(hours=8)
+        }
+        access_token = jwt.encode(token_data, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+        return {"access_token": access_token}

app/settings.py

@@ -0,0 +1,11 @@
+
+## bookmyservice-ums/settings.py
+
+from pydantic import BaseSettings
+
+class Settings(BaseSettings):
+    SECRET_KEY: str = "secret-key-placeholder"
+    ALGORITHM: str = "HS256"
+
+settings = Settings()
+

app/utils/common_utils.py

@@ -0,0 +1,4 @@
+import re
+
+def is_email(identifier: str) -> bool:
+    return re.match(r"[^@]+@[^@]+\.[^@]+", identifier) is not None

app/utils/email_utils.py

@@ -0,0 +1,15 @@
+import smtplib
+from email.mime.text import MIMEText
+from app.core.config import settings
+
+async def send_email_otp(to_email: str, otp: str):
+    msg = MIMEText(f"Your OTP is {otp}. It is valid for 5 minutes.")
+    msg["Subject"] = "Your One-Time Password"
+    msg["From"] = settings.SMTP_FROM
+    msg["To"] = to_email
+
+    server = smtplib.SMTP(settings.SMTP_HOST, settings.SMTP_PORT)
+    server.starttls()
+    server.login(settings.SMTP_USER, settings.SMTP_PASS)
+    server.send_message(msg)
+    server.quit()

app/utils/jwt.py

@@ -0,0 +1,14 @@
+
+## bookmyservice-ums/app/utils/jwt.py
+
+from jose import jwt
+from datetime import datetime, timedelta
+
+SECRET_KEY = "secret-key-placeholder"
+ALGORITHM = "HS256"
+
+def create_access_token(data: dict, expires_minutes: int = 60):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=expires_minutes)
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

app/utils/sms_utils.py

@@ -0,0 +1,14 @@
+
+from twilio.rest import Client
+from app.core.config import settings
+
+def send_sms_otp(phone: str, otp: str) -> str:
+    client = Client(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN)
+
+    message = client.messages.create(
+        from_=settings.TWILIO_SMS_FROM,
+        body=f"Your OTP is {otp}",
+        to=phone
+    )
+
+    return message.sid

create_ums_structure.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# Base directory (change this as needed)
+BASE_DIR="bookmyservice-ums/app"
+
+# Create folder structure
+mkdir -p $BASE_DIR/models
+mkdir -p $BASE_DIR/schemas
+mkdir -p $BASE_DIR/routers
+mkdir -p $BASE_DIR/services
+mkdir -p $BASE_DIR/repositories
+mkdir -p $BASE_DIR/utils
+mkdir -p $BASE_DIR/constants
+mkdir -p $BASE_DIR/dependencies
+mkdir -p $BASE_DIR/tests
+
+# Add __init__.py to make each a Python package
+for dir in models schemas routers services repositories utils constants dependencies tests; do
+    touch "$BASE_DIR/$dir/__init__.py"
+done
+
+echo "📁 Folder structure for User Management Service created under $BASE_DIR"

requirements.txt

@@ -0,0 +1,6 @@
+
+fastapi
+uvicorn
+python-jose
+pydantic
+twilio