Upload 24 files

.env

@@ -0,0 +1,11 @@
+MONGO_URI=mongodb+srv://appliedcommerce:xaqtoj-gikdaw-6giQdy@cluster0.qpc5d.mongodb.net/test??ssl=true&ssl_cert_reqs=CERT_NONE
+DB_NAME=ac-user-auth
+
+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-13036.c84.us-east-1-2.ec2.redns.redis-cloud.com:13036
+CACHE_K=vLiMNdXeJZtvRUKUbk0Ck4HeGchzeHP6
+
+#JWT related configurations
+JWT_SECRET=book-my-service
+JWT_EXPIRY_MINUTES=60

app/config/nosql.py

@@ -0,0 +1,51 @@
+"""
+Module for NoSQL database connections and configurations.
+"""
+
+import logging
+from motor.motor_asyncio import AsyncIOMotorClient
+from redis.asyncio import Redis
+from redis.exceptions import RedisError
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+# MongoDB connection
+MONGO_URI = os.getenv("MONGO_URI")
+DB_NAME = os.getenv("DB_NAME")
+mongo_client = AsyncIOMotorClient(MONGO_URI)
+db = mongo_client[DB_NAME]
+
+# Redis connection
+CACHE_URI = os.getenv("CACHE_URI")
+CACHE_K = os.getenv("CACHE_K")
+
+if not MONGO_URI or not DB_NAME:
+    raise ValueError("MongoDB URI or Database Name is not set in the environment variables.")
+
+if not CACHE_URI or not CACHE_K:
+    raise ValueError("Redis URI or Database Name is not set in the environment variables.")
+
+# Parse Redis host and port
+CACHE_HOST, CACHE_PORT = CACHE_URI.split(":")
+CACHE_PORT = int(CACHE_PORT)
+
+# Initialize Redis client
+try:
+    redis_client = Redis(
+        host=CACHE_HOST,
+        port=CACHE_PORT,
+        username="default",
+        password=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_mongo_client() -> AsyncIOMotorClient:
+    return mongo_client

app/controllers/customer_controller.py

@@ -0,0 +1,100 @@
+import logging
+from typing import Optional
+from datetime import datetime, timedelta
+from fastapi import APIRouter, HTTPException, Query, Depends, status, Body
+from fastapi.responses import JSONResponse  
+#from fastapi.security import OAuth2PasswordRequestForm, OAuth2PasswordBearer
+#from jose import JWTError, jwt
+from app.services.customer_services import get_otp_from_cache, validate_email_mobile, verify_otp_and_save_customer
+from app.models.customer import CustomerRegister
+
+
+# Initialize router and logger
+router = APIRouter(prefix="/customer")
+logger = logging.getLogger(__name__)
+
+
+
+@router.post("/register")
+async def register_customer(user: CustomerRegister = Body(...)):
+    """
+    API endpoint to register a new customer.
+
+    Args:
+        user (CustomerRegister): The details of the customer to register.
+
+    Returns:
+        dict: Confirmation message indicating email and SMS verification pending.
+    """
+    try:
+        logger.info("Registering a new customer with email: %s and mobile: %s", user.email, user.mobile)
+
+        # Validate email and mobile format
+        validation_result = await validate_email_mobile(user.email, user.mobile)
+        if validation_result["status"] == "error":
+            logger.error("Validation failed: %s", validation_result["errors"])
+            raise HTTPException(status_code=400, detail=validation_result["errors"])       
+
+        return user.dict()
+
+    except HTTPException as e:
+        logger.error("Failed to register customer: %s", e.detail)
+        raise e
+    except Exception as e:
+        logger.error("Unexpected error while registering customer: %s", e)
+        raise HTTPException(status_code=500, detail="Failed to register customer") from e
+    
+@router.post("/otp/verify")
+async def customer_otp_verification(user: CustomerRegister = Body(...)):
+    """
+    API endpoint to validate OTPs and save the complete customer object.
+
+    Args:
+        user (CustomerRegister): The complete customer object including email, mobile, and OTPs.
+
+    Returns:
+        dict: Confirmation message indicating success or failure.
+    """
+    try:
+        logger.info("Verifying OTPs and registering customer with email: %s and mobile: %s", user.email, user.mobile)
+         # Verify OTPs and save customer
+        result = await verify_otp_and_save_customer(user)
+        if result["status"] == "error":
+            raise HTTPException(status_code=400, detail=result["errors"])
+
+        return {"message": "Customer successfully registered and verified."}
+
+    except HTTPException as e:
+        logger.error("Failed to verify and register customer: %s", e.detail)
+        raise e
+    except Exception as e:
+        logger.error("Unexpected error while verifying and registering customer: %s", e)
+        raise HTTPException(status_code=500, detail="Failed to verify and register customer") from e
+
+@router.get("/otp/get")
+async def get_otps(key: str = Query(..., description="The email or mobile number to retrieve the OTP for")):
+    """
+    API endpoint to retrieve the email or SMS OTP from Redis cache.
+
+    Args:
+        key (str): The email or mobile number to retrieve the OTP for.
+
+    Returns:
+        dict: The OTP data if found, or an error message if not found.
+    """
+    try:
+        logger.info("Retrieving OTP for key: %s", key)
+
+        # Retrieve OTP from Redis
+        otp_data = await get_otp_from_cache(key)
+        if not otp_data:
+            raise HTTPException(status_code=404, detail="OTP not found or expired")
+
+        return {"key": key, "otp_data": otp_data}
+
+    except HTTPException as e:
+        logger.error("Failed to retrieve OTP for key %s: %s", key, e.detail)
+        raise e
+    except Exception as e:
+        logger.error("Unexpected error while retrieving OTP for key %s: %s", key, e)
+        raise HTTPException(status_code=500, detail="Failed to retrieve OTP") from e   

app/controllers/merchant_controller.py

@@ -0,0 +1,97 @@
+import logging
+from typing import Optional
+from datetime import datetime, timedelta
+from fastapi import APIRouter, HTTPException, Query, Depends, status, Body
+from app.models.merchant import MerchantRegister
+from app.services.merchant_services import get_otp_from_cache, verify_otp_and_save_merchant, validate_merchant
+
+
+# Initialize router and logger
+router = APIRouter(prefix="/merchant")
+logger = logging.getLogger(__name__)
+
+
+
+@router.post("/register")
+async def register_customer(user: MerchantRegister = Body(...)):
+    """
+    API endpoint to register a new Merchant.
+
+    Args:
+        user (MerchantRegister): The details of the Merchant to register.
+
+    Returns:
+        dict: Confirmation message indicating email and SMS verification pending.
+    """
+    try:
+        logger.info("Registering a new Merchant with Merchant name : %s, email: %s and mobile: %s", user.merchantname, user.email, user.mobile)
+
+        # Validate email and mobile format
+        validation_result = await validate_merchant(user)
+        if validation_result["status"] == "error":
+            logger.error("Validation failed: %s", validation_result["errors"])
+            raise HTTPException(status_code=400, detail=validation_result["errors"])       
+
+        return user.dict()
+
+    except HTTPException as e:
+        logger.error("Failed to register merchant: %s", e.detail)
+        raise e
+    except Exception as e:
+        logger.error("Unexpected error while registering merchant: %s", e)
+        raise HTTPException(status_code=500, detail="Failed to register Merchant") from e
+    
+@router.post("/otp/verify")
+async def customer_otp_verification(user: MerchantRegister = Body(...)):
+    """
+    API endpoint to validate OTPs and save the complete Merchant object.
+
+    Args:
+        user (MerchantRegister): The complete Merchant object including email, mobile, and OTPs.
+
+    Returns:
+        dict: Confirmation message indicating success or failure.
+    """
+    try:
+        logger.info("Verifying OTPs and registering merchant with email: %s and mobile: %s", user.email, user.mobile)
+         # Verify OTPs and save customer
+        result = await verify_otp_and_save_merchant(user)
+        if result["status"] == "error":
+            raise HTTPException(status_code=400, detail=result["errors"])
+
+        return {"message": "Merchant successfully registered and verified."}
+
+    except HTTPException as e:
+        logger.error("Failed to verify and register merchant: %s", e.detail)
+        raise e
+    except Exception as e:
+        logger.error("Unexpected error while verifying and registering merchant: %s", e)
+        raise HTTPException(status_code=500, detail="Failed to verify and register merchant") from e
+
+@router.get("/otp/get")
+async def get_otps(key: str = Query(..., description="The email or mobile number to retrieve the OTP for")):
+    """
+    API endpoint to retrieve the email or SMS OTP from Redis cache.
+
+    Args:
+        key (str): The email or mobile number to retrieve the OTP for.
+
+    Returns:
+        dict: The OTP data if found, or an error message if not found.
+    """
+    try:
+        logger.info("Retrieving OTP for key: %s", key)
+
+        # Retrieve OTP from Redis
+        otp_data = await get_otp_from_cache(key)
+        if not otp_data:
+            raise HTTPException(status_code=404, detail="OTP not found or expired")
+
+        return {"key": key, "otp_data": otp_data}
+
+    except HTTPException as e:
+        logger.error("Failed to retrieve OTP for key %s: %s", key, e.detail)
+        raise e
+    except Exception as e:
+        logger.error("Unexpected error while retrieving OTP for key %s: %s", key, e)
+        raise HTTPException(status_code=500, detail="Failed to retrieve OTP") from e   

app/main.py

@@ -0,0 +1,31 @@
+"""
+Main application module for Customer Hub Service.
+"""
+import logging
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.routers.router import router
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+#logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="Authentication API's",
+    description="API for managing registration and login related services",
+    version="1.0.0",
+)
+
+# CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Restrict to specific domains in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Register routers
+app.include_router(router, prefix="/api/v1", )
+
+# Ensure there is no trailing newline

app/models/customer.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, EmailStr, Field
+from datetime import datetime
+
+class CustomerRegister(BaseModel):
+    """
+    Pydantic model for customer registration request payload.
+    """
+    email: EmailStr = Field(..., description="The email address of the customer")
+    mobile: str = Field(..., description="The 10-digit mobile number of the customer")
+    status: str = Field("pending-verification", description="The status of the customer account")
+    email_ver_code: str = Field(..., description="The email verification code")
+    mobile_ver_code: str = Field(..., description="The mobile verification code")
+    created_at: datetime = Field(default_factory=datetime.now, description="The timestamp when the customer was created")

app/models/merchant.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, EmailStr, Field
+from datetime import datetime
+
+class MerchantRegister(BaseModel):
+    """
+    Pydantic model for Merchant registration request payload.
+    """
+    merchant_name: str = Field(..., description="The name of the Merchant")
+    merchant_id: str = Field(..., description="The unique identifier for the Merchant")
+    country: str = Field(..., description="The country where the Merchant is located")
+    city: str = Field(..., description="The city where the Merchant is located")
+    area: str = Field(..., description="The area where the Merchant is located")
+    email: EmailStr = Field(..., description="The email address of the customer")
+    mobile: str = Field(..., description="The 10-digit mobile number of the customer")
+    status: str = Field("pending-verification", description="The status of the customer account")
+    email_ver_code: str = Field(..., description="The email verification code")
+    mobile_ver_code: str = Field(..., description="The mobile verification code")
+    created_at: datetime = Field(default_factory=datetime.now, description="The timestamp when the customer was created")

app/repositories/cache_repository.py

@@ -0,0 +1,55 @@
+import json
+import logging
+from app.config.nosql import redis_client
+
+logger = logging.getLogger(__name__)
+
+async def get_otp(key: str) -> dict:
+    """
+    Retrieve OTP data from Redis.
+
+    Args:
+        key (str): The key to retrieve the OTP data (e.g., email or mobile).
+
+    Returns:
+        dict: The OTP data if found, None otherwise.
+    """
+    try:
+        # Construct the Redis key
+        redis_key = f"otp:{key}"
+        
+        # Retrieve the value from Redis
+        value = await redis_client.get(redis_key)
+        
+        # If value exists, parse it as JSON and return
+        if value:
+            return json.loads(value)
+        
+        # Return None if no value is found
+        return None
+    except Exception as e:
+        # Log the error and re-raise it
+        logger.error(f"Failed to retrieve OTP for key {key}: {e}")
+        raise
+    
+async def set_otp(key: str, otp_data: dict):
+    """
+    Store OTP data in Redis with an expiry time.
+
+    Args:
+        key (str): The key to associate the OTP with (e.g., email or mobile).
+        otp_data (dict): The OTP data to store, including the OTP and expiry duration.
+    """
+    try:
+        # Construct the Redis key
+        redis_key = f"otp:{key}"
+        
+        # Extract expiry duration in seconds
+        expiry_duration = otp_data.get("expiry_duration", 15 * 60)  # Default to 15 minutes if not provided
+        
+        # Store the OTP data in Redis with the specified expiry
+        await redis_client.setex(redis_key, expiry_duration, json.dumps(otp_data))
+    except Exception as e:
+        # Log the error and re-raise it
+        logger.error(f"Failed to store OTP for key {key}: {e}")
+        raise

app/repositories/db_repository.py

@@ -0,0 +1,101 @@
+from app.config.nosql import db
+
+async def save_customer(customer_data: dict):
+    """
+    Save customer details to MongoDB.
+
+    Args:
+        customer_data (dict): The customer data to save.
+    """
+    await db["customers"].insert_one(customer_data)
+    
+async def get_customer_by_email(email: str) -> dict:
+    """
+    Retrieve a customer by email from the database.
+
+    Args:
+        email (str): The email address to search for.
+
+    Returns:
+        dict: The customer data if found, None otherwise.
+    """
+    return await db["customers"].find_one({"email": email})
+
+
+async def get_customer_by_mobile(mobile: str) -> dict:
+    """
+    Retrieve a customer by mobile number from the database.
+
+    Args:
+        mobile (str): The mobile number to search for.
+
+    Returns:
+        dict: The customer data if found, None otherwise.
+    """
+    return await db["customers"].find_one({"mobile": mobile})
+
+
+async def get_merchant_by_name(name: str) -> dict:
+    """
+    Retrieve a merchant by name from the database.
+
+    Args:
+        name (str): The name of the merchant.
+
+    Returns:
+        dict: The merchant data if found, None otherwise.
+    """
+    return await db["merchants"].find_one({"merchantname": name})
+
+
+async def get_merchant_by_id(merchant_id: str) -> dict:
+    """
+    Retrieve a merchant by ID from the database.
+
+    Args:
+        merchant_id (str): The unique ID of the merchant.
+
+    Returns:
+        dict: The merchant data if found, None otherwise.
+    """
+    return await db["merchants"].find_one({"merchantId": merchant_id})
+
+
+async def get_merchant_by_email(email: str) -> dict:
+    """
+    Retrieve a merchant by email from the database.
+
+    Args:
+        email (str): The email address of the merchant.
+
+    Returns:
+        dict: The merchant data if found, None otherwise.
+    """
+    return await db["merchants"].find_one({"email": email})
+
+
+async def get_merchant_by_mobile(mobile: str) -> dict:
+    """
+    Retrieve a merchant by mobile number from the database.
+
+    Args:
+        mobile (str): The mobile number of the merchant.
+
+    Returns:
+        dict: The merchant data if found, None otherwise.
+    """
+    return await db["merchants"].find_one({"mobile": mobile})
+
+
+async def save_merchant(merchant_data: dict) -> dict:
+    """
+    Save a new merchant to the database.
+
+    Args:
+        merchant_data (dict): The merchant data to save.
+
+    Returns:
+        dict: The inserted merchant data.
+    """
+    result = await db["merchants"].insert_one(merchant_data)
+    return {"id": str(result.inserted_id), **merchant_data}

app/routers/router.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+from app.controllers.customer_controller import router as customer
+from app.controllers.merchant_controller import router as merchant
+
+router = APIRouter()
+router.include_router(customer, prefix="", tags=["Customer"])
+router.include_router(merchant, prefix="", tags=["Merchant"])

app/services/customer_services.py

@@ -0,0 +1,165 @@
+import re
+import logging
+from app.repositories.cache_repository import get_otp, set_otp
+from app.repositories.db_repository import get_customer_by_email, get_customer_by_mobile, save_customer
+from app.models.customer import CustomerRegister
+from app.utils.auth_utils import validate_email, validate_mobile
+import random
+
+logger = logging.getLogger(__name__)
+
+async def validate_email_mobile(email: str, mobile: str) -> dict:
+    """
+    Validate email and mobile format and check if they already exist in the database.
+
+    Args:
+        email (str): The email address to validate.
+        mobile (str): The mobile number to validate.
+
+    Returns:
+        dict: Validation result with consolidated error messages or success message.
+    """
+    errors = []
+
+    # Validate email format
+    if not validate_email(email):
+        errors.append("Invalid email format")
+
+    # Validate mobile format
+    if not validate_mobile(mobile):
+        errors.append("Invalid mobile number format")
+
+    # Check if email already exists in the database
+    existing_email = await get_customer_by_email(email)
+    if existing_email:
+        errors.append("Email is already registered")
+
+    # Check if mobile already exists in the database
+    existing_mobile = await get_customer_by_mobile(mobile)
+    if existing_mobile:
+        errors.append("Mobile number is already registered")
+
+    # Return errors if any
+    if errors:
+        return {"status": "error", "errors": errors}
+    else:
+        # Send verification emails and SMS if no errors
+        await send_email_verification(email)
+        await send_sms_verification(mobile)
+
+    # If all validations pass
+    return {"status": "success", "message": "Email and mobile are valid"}
+
+async def save_customer_to_db(user: CustomerRegister) -> dict:
+    """
+    Save customer details to MongoDB after checking for duplicates.
+
+    Args:
+        user (CustomerRegister): The customer details to save.
+
+    Returns:
+        dict: Success message or error message if email or mobile already exists.
+    """
+    # Check if email already exists in the database
+    existing_email = await get_customer_by_email(user.email)
+    if existing_email:
+        return {"status": "error", "message": "Email is already registered"}
+
+    # Check if mobile already exists in the database
+    existing_mobile = await get_customer_by_mobile(user.mobile)
+    if existing_mobile:
+        return {"status": "error", "message": "Mobile number is already registered"}
+
+    # Save customer details to the database
+    await save_customer(user.dict())
+    return {"status": "success", "message": "Customer registered successfully"}
+
+async def send_email_verification(email: str):
+    """
+    Send an email verification link or code.
+
+    Args:
+        email (str): The email address to send the verification to.
+    """
+    # Implement your email sending logic here
+    # Generate a 6-digit OTP
+    otp = ''.join(random.choices("0123456789", k=6))    
+    # Store OTP in cache with a 15-minute expiry
+    await set_otp(email, {"otp": otp, "expiry_duration": 15 * 60})  # 15 minutes in seconds
+    # Send the OTP to the email address 
+    # (You would typically use an email service here)
+    # For demonstration, we'll just log the OTP         
+    logger.info("Sending email verification to: %s with OTP: %s", email, otp)   
+    logger.info("Sending email verification to: %s", email)
+    
+async def send_sms_verification(mobile: str):
+    """
+    Send an SMS verification code.
+
+    Args:
+        mobile (str): The mobile number to send the verification to.
+    """
+    # Implement your SMS sending logic here
+    # Generate a 6-digit OTP
+    otp = ''.join(random.choices("0123456789", k=6))
+    # Store OTP in cache with a 15-minute expiry
+    await set_otp(mobile, {"otp": otp, "expiry_duration": 15 * 60})  # 15 minutes in seconds
+    # Send the OTP to the mobile number
+    # (You would typically use an SMS service here)
+    # For demonstration, we'll just log the OTP
+    logger.info("Sending SMS verification to: %s with OTP: %s", mobile, otp)
+    logger.info("Sending SMS verification to: %s", mobile)
+    
+async def verify_otp_and_save_customer(user: CustomerRegister) -> dict:
+    """
+    Verify SMS OTP and email OTP, and save the complete customer object in the database.
+
+    Args:
+        user (CustomerRegister): The complete customer object including email, mobile, and OTPs.
+
+    Returns:
+        dict: Result indicating success or failure.
+    """
+    errors = []
+
+    # Retrieve OTPs from cache
+    email_otp_data = await get_otp(user.email)
+    mobile_otp_data = await get_otp(user.mobile)
+
+    # Verify email OTP
+    if not email_otp_data or email_otp_data["otp"] != user.email_ver_code:
+        errors.append("Invalid or expired email OTP")
+
+    # Verify mobile OTP
+    if not mobile_otp_data or mobile_otp_data["otp"] != user.mobile_ver_code:
+        errors.append("Invalid or expired mobile OTP")
+
+    # Return errors if any
+    if errors:
+        return {"status": "error", "errors": errors}
+
+    # Save the complete customer object to the database
+    customer_data = user.dict()
+    customer_data["status"] = "completed"  # Update status to completed
+    await save_customer(customer_data)
+
+    return {"status": "success", "message": "Customer successfully registered and verified"}
+
+async def get_otp_from_cache(key: str) -> dict:
+    """
+    Retrieve OTP data for the given key (email or mobile) from the cache.
+
+    Args:
+        key (str): The email or mobile number to retrieve the OTP for.
+
+    Returns:
+        dict: The OTP data if found, or None if not found.
+    """
+    try:
+        # Call the get_otp function from the cache repository
+        otp_data = await get_otp(key)
+        return otp_data
+    except Exception as e:
+        # Log the error and re-raise it
+        logger.error(f"Failed to retrieve OTP for key {key}: {e}")
+        raise

app/services/merchant_services.py

@@ -0,0 +1,144 @@
+from app.models.merchant import MerchantRegister
+from app.repositories.db_repository import save_merchant, get_merchant_by_name, get_merchant_by_email, get_merchant_by_mobile
+from app.utils.merchant_utils import generate_tenant_id
+from app.utils.auth_utils import validate_email, validate_mobile
+from app.repositories.cache_repository import get_otp, set_otp  
+import logging
+import random   
+
+
+logger = logging.getLogger(__name__)
+
+async def validate_merchant(merchant: MerchantRegister) -> dict:
+    """
+    Validate if the merchant details are valid and not already existing.
+
+    Args:
+        name (str): The name of the merchant.
+        merchant_id (str): The unique ID of the merchant.
+        email (str): The email address of the merchant.
+        mobile (str): The mobile number of the merchant.
+
+    Returns:
+        dict: Validation result with success or error messages.
+    """
+    errors = []
+
+    # Check if merchant name already exists
+    existing_merchant_name = await get_merchant_by_name(merchant.merchant_name)
+    if existing_merchant_name:
+        errors.append("Merchant name is already registered")
+
+    # Check if merchant email already exists
+    existing_merchant_email = await get_merchant_by_email(merchant.email)
+    if existing_merchant_email:
+        errors.append("Merchant email is already registered")
+
+    # Check if merchant mobile already exists
+    existing_merchant_mobile = await get_merchant_by_mobile(merchant.mobile)
+    if existing_merchant_mobile:
+        errors.append("Merchant mobile number is already registered")
+
+    # Return errors if any
+    if errors:
+        return {"status": "error", "errors": errors}
+    else:
+        #merchant_id = generate_tenant_id(merchant.merchantname, merchant.country, merchant.city, merchant.area)        # Send verification emails and SMS if no errors
+        await send_email_verification(merchant.email)
+        await send_sms_verification(merchant.mobile)
+        #merchant.merchantId=merchant_id
+
+    # If all validations pass
+    return merchant.dict()
+
+async def send_email_verification(email: str):
+    """
+    Send an email verification link or code.
+
+    Args:
+        email (str): The email address to send the verification to.
+    """
+    # Implement your email sending logic here
+    # Generate a 6-digit OTP
+    otp = ''.join(random.choices("0123456789", k=6))    
+    # Store OTP in cache with a 15-minute expiry
+    await set_otp(email, {"otp": otp, "expiry_duration": 15 * 60})  # 15 minutes in seconds
+    # Send the OTP to the email address 
+    # (You would typically use an email service here)
+    # For demonstration, we'll just log the OTP         
+    logger.info("Sending email verification to: %s with OTP: %s", email, otp)   
+    logger.info("Sending email verification to: %s", email)
+    
+async def send_sms_verification(mobile: str):
+    """
+    Send an SMS verification code.
+
+    Args:
+        mobile (str): The mobile number to send the verification to.
+    """
+    # Implement your SMS sending logic here
+    # Generate a 6-digit OTP
+    otp = ''.join(random.choices("0123456789", k=6))
+    # Store OTP in cache with a 15-minute expiry
+    await set_otp(mobile, {"otp": otp, "expiry_duration": 15 * 60})  # 15 minutes in seconds
+    # Send the OTP to the mobile number
+    # (You would typically use an SMS service here)
+    # For demonstration, we'll just log the OTP
+    logger.info("Sending SMS verification to: %s with OTP: %s", mobile, otp)
+    logger.info("Sending SMS verification to: %s", mobile)
+    
+async def verify_otp_and_save_merchant(merchant: MerchantRegister) -> dict:
+    """
+    Verify SMS OTP and email OTP, and save the complete merchant object in the database.
+
+    Args:
+        merchant (MerchantRegister): The complete merchant object including email, mobile, and OTPs.
+
+    Returns:
+        dict: Result indicating success or failure.
+    """
+    errors = []
+
+    # Retrieve OTPs from cache
+    email_otp_data = await get_otp_from_cache(merchant.email)
+    mobile_otp_data = await get_otp_from_cache(merchant.mobile)
+
+    # Verify email OTP
+    if not email_otp_data or email_otp_data["otp"] != merchant.email_ver_code:
+        errors.append("Invalid or expired email OTP")
+
+    # Verify mobile OTP
+    if not mobile_otp_data or mobile_otp_data["otp"] != merchant.mobile_ver_code:
+        errors.append("Invalid or expired mobile OTP")
+
+    # Return errors if any
+    if errors:
+        return {"status": "error", "errors": errors}
+
+    # Save the complete merchant object to the database
+    merchant_data = merchant.dict()
+    merchant_data["merchant_id"] = generate_tenant_id(merchant.merchant_name, merchant.country, merchant.city, merchant.area) 
+    merchant_data["status"] = "completed"  # Update status to completed
+    
+    await save_merchant(merchant_data)
+
+    return {"status": "success", "message": "Merchant successfully registered and verified"}
+    
+async def get_otp_from_cache(key: str) -> dict:
+    """
+    Retrieve OTP data for the given key (email or mobile) from the cache.
+
+    Args:
+        key (str): The email or mobile number to retrieve the OTP for.
+
+    Returns:
+        dict: The OTP data if found, or None if not found.
+    """
+    try:
+        # Call the get_otp function from the cache repository
+        otp_data = await get_otp(key)
+        return otp_data
+    except Exception as e:
+        # Log the error and re-raise it
+        logger.error(f"Failed to retrieve OTP for key {key}: {e}")
+        raise

app/utils/auth_utils.py

@@ -0,0 +1,27 @@
+import re
+import logging
+
+def validate_email(email: str) -> bool:
+    """
+    Validate the email address format.
+
+    Args:
+        email (str): The email address to validate.
+
+    Returns:
+        bool: True if valid, False otherwise.
+    """
+    email_regex = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
+    return re.match(email_regex, email) is not None
+
+def validate_mobile(mobile: str) -> bool:
+    """
+    Validate the mobile number format.
+
+    Args:
+        mobile (str): The mobile number to validate.
+
+    Returns:
+        bool: True if valid, False otherwise.
+    """
+    return mobile.isdigit() and len(mobile) == 10

app/utils/merchant_utils.py

@@ -0,0 +1,33 @@
+import hashlib
+from nanoid import generate
+import re
+ 
+def slugify_company_name(name, max_length=6):
+    slug = re.sub(r'[^A-Z0-9]', '', name.upper())
+    return slug[:max_length]
+ 
+def short_hash(text, length=4):
+    return hashlib.sha1(text.encode()).hexdigest().upper()[:length]
+ 
+def alphanumeric_to_digits(text):
+    result = ''
+    for c in text.upper():
+        if c.isdigit():
+            result += c
+        elif c.isalpha():
+            result += str(ord(c) - 55)  # A=10, B=11, ..., Z=35
+    return result
+ 
+def compute_check_digit(base_id):
+    numeric_string = alphanumeric_to_digits(base_id)
+    total = sum(int(digit) for digit in numeric_string)
+    return str(total % 10)
+ 
+def generate_tenant_id(company_name,country, city, area):
+    short_name = country + "-" + slugify_company_name(company_name, 5) + "-" + slugify_company_name(city,3) +  slugify_company_name(area,3)
+    hash_part = short_hash(short_name)
+    nanoid_part = generate('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 5)
+    base_id = f"{short_name}-{hash_part}-{nanoid_part}"
+    return f"{base_id}"
+ 
+

requirements.txt

@@ -1,2 +1,12 @@
-fastapi
-uvicorn[standard]
+fastapi>=0.95,<1.0
+uvicorn[standard]>=0.22.0
+motor>=3.0
+pydantic
+python-dotenv
+pydantic[email]
+redis
+python-jose
+passlib
+python-multipart
+bcrypt
+nanoid