added regenerate otp endpoint, updated verify to validate either sms/email and made company id, email str code, mobile str code, status as optional attributes

app/controllers/merchant_controller.py

@@ -94,4 +94,30 @@ async def get_otps(key: str = Query(..., description="The email or mobile number
         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   
+        raise HTTPException(status_code=500, detail="Failed to retrieve OTP") from e  
+    
+from app.services.merchant_services import generate_and_send_otp
+
+@router.post("/otp/regenerate")
+async def regenerate_otp(user: MerchantRegister = Body(...)):
+    """
+    API endpoint to regenerate an OTP for a given email, mobile number, or both.
+
+    Args:
+        user (MerchantRegister): The Merchant object containing email and mobile details.
+
+    Returns:
+        dict: Confirmation message indicating the OTP has been regenerated.
+    """
+    try:
+        logger.info("Regenerating OTP for Merchant with email: %s and mobile: %s", user.email, user.mobile)
+
+        # Regenerate OTP for email & mobile
+        if user.email and user.mobile:
+            await generate_and_send_otp(user.email, user.mobile)       
+
+        return {"message": "OTP successfully regenerated for email and/or mobile.", "email": user.email, "mobile": user.mobile}
+
+    except Exception as e:
+        logger.error("Failed to regenerate OTP for Merchant with email: %s and mobile: %s. Error: %s", user.email, user.mobile, e)
+        raise HTTPException(status_code=500, detail="Failed to regenerate OTP") from e 

app/models/merchant.py

@@ -1,4 +1,5 @@
 from pydantic import BaseModel, EmailStr, Field
+from typing import Optional
 from datetime import datetime
 
 class MerchantRegister(BaseModel):
@@ -6,13 +7,13 @@ 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")
+    merchant_id: Optional[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")
+    status: Optional[str] = Field("pending-verification", description="The status of the customer account")
+    email_ver_code: Optional[str] = Field(..., description="The email verification code")
+    mobile_ver_code: Optional[str] = Field(..., description="The mobile verification code")
+    created_at: Optional[datetime] = Field(default_factory=datetime.now, description="The timestamp when the customer was created")

app/services/merchant_services.py

@@ -44,52 +44,36 @@ async def validate_merchant(merchant: MerchantRegister) -> dict:
         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_email_verification(merchant.email,merchant.mobile)
         await send_sms_verification(merchant.mobile)
         #merchant.merchantId=merchant_id
 
     # If all validations pass
     return merchant.dict()
 
-async def send_email_verification(email: str):
+async def send_sms_email_verification(email: str, mobile: str):
     """
-    Send an email verification link or code.
+    Send an email & sms verification link or code.
 
     Args:
         email (str): The email address to send the verification to.
+        mobile (str): The mobile number 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
+    await set_otp(mobile, {"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)
+    # For demonstration, we'll just log the OTP    
+    logger.info("Sending email & sms  verification to: %s & %s with otp: %s", email, mobile, otp)
     
-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.
+    Verify either SMS OTP or email OTP, and save the complete merchant object in the database.
 
     Args:
         merchant (MerchantRegister): The complete merchant object including email, mobile, and OTPs.
@@ -104,22 +88,24 @@ async def verify_otp_and_save_merchant(merchant: MerchantRegister) -> dict:
     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")
+    email_verified = email_otp_data and email_otp_data["otp"] == merchant.email_ver_code
 
     # Verify mobile OTP
-    if not mobile_otp_data or mobile_otp_data["otp"] != merchant.mobile_ver_code:
-        errors.append("Invalid or expired mobile OTP")
+    mobile_verified = mobile_otp_data and mobile_otp_data["otp"] == merchant.mobile_ver_code
 
-    # Return errors if any
+    # Check if at least one verification is successful
+    if not email_verified and not mobile_verified:
+        errors.append("Invalid or expired OTP for both email and mobile")
+
+    # Return errors if neither OTP is valid
     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["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"}
@@ -141,4 +127,29 @@ async def get_otp_from_cache(key: str) -> dict:
     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 generate_and_send_otp(email: str, mobile: str) -> None:
+    """
+    Generate, store, and send an OTP for the given key (email or mobile).
+
+    Args:
+        email and mobile (str): The email or mobile number to send the OTP to.
+
+    Returns:
+        None
+    """
+    try:
+        # 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
+        await set_otp(mobile, {"otp": otp, "expiry_duration": 15 * 60})
+
+        # Log the OTP generation
+        logger.info("Generated OTP for %s & %s: %s", email, mobile, otp)
+
+    except Exception as e:
+        logger.error("Failed to generate and send OTP for %s, %s: %s", email, mobile, e)
         raise