feat(customer_auth): Add mobile number normalization for OTP operations

- Implement _normalize_mobile() method to standardize mobile number format
- Handle mobile numbers with/without country code (+91 for India)
- Remove spaces and dashes from mobile input for consistency
- Apply normalization to send_oTP() method for OTP generation and storage
- Apply normalization to verify_otp() method for OTP lookup and verification
- Apply normalization to _find_or_create_customer() method calls
- Update all database queries to use normalized mobile numbers
- Update logging statements to reflect normalized mobile numbers
- Ensures consistent mobile number format across all OTP operations and reduces lookup failures due to format mismatches

app/auth/services/customer_auth_service.py

@@ -24,6 +24,33 @@ class CustomerAuthService:
         self.otp_collection = self.db.customer_otps
         self.system_user_service = SystemUserService(self.db)
     
+    def _normalize_mobile(self, mobile: str) -> str:
+        """
+        Normalize mobile number to consistent format.
+        
+        Args:
+            mobile: Raw mobile number (with or without country code)
+            
+        Returns:
+            Normalized mobile number (with country code)
+        """
+        # Remove all spaces and dashes
+        clean_mobile = mobile.replace(" ", "").replace("-", "")
+        
+        # If it doesn't start with +, add +91 (India country code)
+        if not clean_mobile.startswith("+"):
+            if clean_mobile.startswith("91") and len(clean_mobile) == 12:
+                # Already has country code but no +
+                clean_mobile = "+" + clean_mobile
+            elif len(clean_mobile) == 10:
+                # Indian mobile number without country code
+                clean_mobile = "+91" + clean_mobile
+            else:
+                # Assume it needs +91 prefix
+                clean_mobile = "+91" + clean_mobile
+        
+        return clean_mobile
+    
     async def send_otp(self, mobile: str) -> Tuple[bool, str, int]:
         """
         Send OTP to customer mobile number.
@@ -35,6 +62,9 @@ class CustomerAuthService:
             Tuple of (success, message, expires_in_seconds)
         """
         try:
+            # Normalize mobile number
+            normalized_mobile = self._normalize_mobile(mobile)
+            
             # Generate 6-digit OTP
             otp = str(secrets.randbelow(900000) + 100000)
             
@@ -44,7 +74,7 @@ class CustomerAuthService:
             
             # Store OTP in database
             otp_doc = {
-                "mobile": mobile,
+                "mobile": normalized_mobile,
                 "otp": otp,
                 "created_at": datetime.utcnow(),
                 "expires_at": expires_at,
@@ -54,14 +84,14 @@ class CustomerAuthService:
             
             # Upsert OTP (replace existing if any)
             await self.otp_collection.replace_one(
-                {"mobile": mobile},
+                {"mobile": normalized_mobile},
                 otp_doc,
                 upsert=True
             )
             
             # TODO: Integrate with SMS service to send actual OTP
             # For now, log the OTP for testing
-            logger.info(f"OTP generated for {mobile}: {otp} (expires in {expires_in}s)")
+            logger.info(f"OTP generated for {normalized_mobile}: {otp} (expires in {expires_in}s)")
             
             return True, "OTP sent successfully", expires_in
             
@@ -81,22 +111,25 @@ class CustomerAuthService:
             Tuple of (customer_data, message)
         """
         try:
+            # Normalize mobile number
+            normalized_mobile = self._normalize_mobile(mobile)
+            
             # Find OTP record
-            otp_doc = await self.otp_collection.find_one({"mobile": mobile})
+            otp_doc = await self.otp_collection.find_one({"mobile": normalized_mobile})
             
             if not otp_doc:
-                logger.warning(f"OTP verification failed - no OTP found for {mobile}")
+                logger.warning(f"OTP verification failed - no OTP found for {normalized_mobile}")
                 return None, "Invalid OTP"
             
             # Check if OTP is expired
             if datetime.utcnow() > otp_doc["expires_at"]:
-                logger.warning(f"OTP verification failed - expired OTP for {mobile}")
-                await self.otp_collection.delete_one({"mobile": mobile})
+                logger.warning(f"OTP verification failed - expired OTP for {normalized_mobile}")
+                await self.otp_collection.delete_one({"mobile": normalized_mobile})
                 return None, "OTP has expired"
             
             # Check if already verified
             if otp_doc.get("verified", False):
-                logger.warning(f"OTP verification failed - already used OTP for {mobile}")
+                logger.warning(f"OTP verification failed - already used OTP for {normalized_mobile}")
                 return None, "OTP has already been used"
             
             # Increment attempts
@@ -104,31 +137,31 @@ class CustomerAuthService:
             
             # Check max attempts (3 attempts allowed)
             if attempts > 3:
-                logger.warning(f"OTP verification failed - too many attempts for {mobile}")
-                await self.otp_collection.delete_one({"mobile": mobile})
+                logger.warning(f"OTP verification failed - too many attempts for {normalized_mobile}")
+                await self.otp_collection.delete_one({"mobile": normalized_mobile})
                 return None, "Too many attempts. Please request a new OTP"
             
             # Update attempts
             await self.otp_collection.update_one(
-                {"mobile": mobile},
+                {"mobile": normalized_mobile},
                 {"$set": {"attempts": attempts}}
             )
             
             # Verify OTP
             if otp_doc["otp"] != otp:
-                logger.warning(f"OTP verification failed - incorrect OTP for {mobile}")
+                logger.warning(f"OTP verification failed - incorrect OTP for {normalized_mobile}")
                 return None, "Invalid OTP"
             
             # Mark OTP as verified
             await self.otp_collection.update_one(
-                {"mobile": mobile},
+                {"mobile": normalized_mobile},
                 {"$set": {"verified": True}}
             )
             
             # Find or create customer
-            customer = await self._find_or_create_customer(mobile)
+            customer = await self._find_or_create_customer(normalized_mobile)
             
-            logger.info(f"OTP verified successfully for {mobile}")
+            logger.info(f"OTP verified successfully for {normalized_mobile}")
             return customer, "OTP verified successfully"
             
         except Exception as e:
@@ -140,7 +173,7 @@ class CustomerAuthService:
         Find existing customer or create new one.
         
         Args:
-            mobile: Customer mobile number
+            mobile: Customer mobile number (normalized)
             
         Returns:
             Customer data dictionary