django-cfg 1.1.51__tar.gz → 1.1.52__tar.gz

{django_cfg-1.1.51 → django_cfg-1.1.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.1.51
+Version: 1.1.52
 Summary: 🚀 Production-ready Django configuration framework with type-safe settings, smart automation, and modern developer experience
 Project-URL: Homepage, https://github.com/markolofsen/django-cfg
 Project-URL: Documentation, https://django-cfg.readthedocs.io

{django_cfg-1.1.51 → django_cfg-1.1.52}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.1.51"
+version = "1.1.52"
 description = "🚀 Production-ready Django configuration framework with type-safe settings, smart automation, and modern developer experience"
 readme = "README.md"
 license = {text = "MIT"}

{django_cfg-1.1.51 → django_cfg-1.1.52}/src/django_cfg/__init__.py

@@ -38,7 +38,7 @@ default_app_config = "django_cfg.apps.DjangoCfgConfig"
 from typing import TYPE_CHECKING
 
 # Version information
-__version__ = "1.1.51"
+__version__ = "1.1.52"
 __author__ = "ReformsAI Team"
 __email__ = "info@reforms.ai"
 __license__ = "MIT"

{django_cfg-1.1.51 → django_cfg-1.1.52}/src/django_cfg/apps/accounts/services/otp_service.py

@@ -6,7 +6,7 @@ from typing import Optional, Tuple
 import re
 
 from django_cfg.modules.django_telegram import DjangoTelegram
-from django_cfg.modules.django_twilio import SimpleTwilioService, send_whatsapp_otp, verify_otp
+from django_cfg.modules.django_twilio import SimpleTwilioService, send_whatsapp_otp_hybrid, verify_otp
 from ..models import OTPSecret, CustomUser
 from ..utils.notifications import AccountNotifications
 from ..signals import notify_failed_otp_attempt
@@ -219,32 +219,36 @@ class OTPService:
                     user, otp_code, is_new_user=created, source_url=source_url, channel='email'
                 )
             else:  # phone channel
-                # Use Twilio Verify API for professional OTP
+                # Use hybrid WhatsApp OTP from twilio_service
+                success, message = send_whatsapp_otp_hybrid(cleaned_identifier, otp_code)
+                
+                if not success:
+                    logger.error(f"❌ Failed to send phone OTP to {cleaned_identifier[:8]}: {message}")
+                    return False, "phone_send_failed"
+                
+                logger.info(f"🎉 Phone OTP sent successfully to {cleaned_identifier[:8]}: {message}")
+                
+                # Send telegram notification for admin
                 try:
-                    success, message = send_whatsapp_otp(cleaned_identifier)
-                    if not success:
-                        logger.error(f"Twilio Verify API failed: {message}")
-                        return False, "phone_send_failed"
-                    
-                    logger.info(f"Twilio Verify OTP sent to {cleaned_identifier}")
+                    # Extract method from message (e.g., "OTP sent via WhatsApp... (Direct WhatsApp)")
+                    method_used = "Hybrid WhatsApp"
+                    if "(Direct WhatsApp)" in message:
+                        method_used = "Direct WhatsApp"
+                    elif "(Verify API)" in message:
+                        method_used = "Verify API"
                     
-                    # Still send telegram notification for admin
-                    try:
-                        DjangoTelegram.send_info(
-                            "📱 Phone OTP Request (Verify API)",
-                            {
-                                "phone": cleaned_identifier,
-                                "user_type": "New User" if created else "Existing User",
-                                "source_url": source_url or "Direct",
-                                "timestamp": timezone.now().strftime("%Y-%m-%d %H:%M:%S UTC")
-                            }
-                        )
-                    except Exception as e:
-                        logger.error(f"Failed to send telegram notification: {e}")
-                        
+                    DjangoTelegram.send_info(
+                        f"📱 Phone OTP Request ({method_used})",
+                        {
+                            "phone": cleaned_identifier,
+                            "method": method_used,
+                            "user_type": "New User" if created else "Existing User",
+                            "source_url": source_url or "Direct",
+                            "timestamp": timezone.now().strftime("%Y-%m-%d %H:%M:%S UTC")
+                        }
+                    )
                 except Exception as e:
-                    logger.error(f"Twilio Verify API error: {e}")
-                    return False, "phone_send_failed"
+                    logger.error(f"Failed to send telegram notification: {e}")
 
             return True, "success"
         except Exception as e:

{django_cfg-1.1.51 → django_cfg-1.1.52}/src/django_cfg/modules/django_twilio/__init__.py

@@ -89,6 +89,10 @@ def __getattr__(name: str):
         from django_cfg.modules.django_twilio.twilio_service import send_whatsapp_otp
         return send_whatsapp_otp
     
+    elif name == "send_whatsapp_otp_hybrid":
+        from django_cfg.modules.django_twilio.twilio_service import send_whatsapp_otp_hybrid
+        return send_whatsapp_otp_hybrid
+    
     elif name == "send_sms_otp":
         from django_cfg.modules.django_twilio.twilio_service import send_sms_otp
         return send_sms_otp
@@ -144,6 +148,7 @@ __all__ = [
     
     # OTP functions
     "send_whatsapp_otp",
+    "send_whatsapp_otp_hybrid",
     "send_email_otp", 
     "send_sms_otp",
     "verify_otp",

{django_cfg-1.1.51 → django_cfg-1.1.52}/src/django_cfg/modules/django_twilio/twilio_service.py

@@ -238,7 +238,78 @@ class TwilioService(BaseModule):
     
     # === OTP Methods (Twilio Verify API) ===
     
-    def send_whatsapp_otp(self, phone_number: str, fallback_to_sms: bool = True) -> Tuple[bool, str]:
+    def send_whatsapp_otp_hybrid(self, phone_number: str, otp_code: str, fallback_to_sms: bool = True) -> Tuple[bool, str]:
+        """
+        HYBRID APPROACH: Send OTP via Direct WhatsApp first, then fallback to Verify API.
+        
+        Args:
+            phone_number: Phone number in E.164 format
+            otp_code: The OTP code to send
+            fallback_to_sms: Whether to fallback to SMS if WhatsApp fails
+            
+        Returns:
+            Tuple[bool, str]: (success, message)
+        """
+        success = False
+        final_message = ""
+        method_used = ""
+        
+        # STEP 1: Try Direct WhatsApp with custom OTP
+        try:
+            from django_cfg.core.config import get_current_config
+            django_config = get_current_config()
+            site_name = django_config.project_name if django_config else "Django CFG"
+            
+            # Create beautiful WhatsApp message
+            whatsapp_message = f"""🔐 *{site_name} Verification*
+
+Your verification code: *{otp_code}*
+
+⏰ Expires in 10 minutes
+🔒 Keep this code secure
+
+_Powered by {site_name}_"""
+            
+            logger.info(f"🎯 Attempting Direct WhatsApp OTP to {self._mask_phone(phone_number)}...")
+            result = self.send_whatsapp_message(phone_number, whatsapp_message)
+            
+            if result.get('sid'):  # If we got a message SID, it was sent successfully
+                success = True
+                method_used = "Direct WhatsApp"
+                final_message = f"OTP sent via WhatsApp to {self._mask_phone(phone_number)}"
+                logger.info(f"✅ Direct WhatsApp OTP sent successfully: {result.get('sid', 'N/A')}")
+            else:
+                logger.warning(f"❌ Direct WhatsApp failed: No SID returned")
+                
+        except Exception as e:
+            logger.warning(f"❌ Direct WhatsApp error: {e}")
+        
+        # STEP 2: Fallback to Verify API if Direct WhatsApp failed
+        if not success:
+            try:
+                logger.info(f"🔄 Fallback: Trying Verify API for {self._mask_phone(phone_number)}...")
+                verify_success, verify_message = self.send_whatsapp_otp_verify(phone_number, fallback_to_sms)
+                
+                if verify_success:
+                    success = True
+                    method_used = "Verify API"
+                    final_message = verify_message
+                    logger.info(f"✅ Verify API fallback successful")
+                else:
+                    logger.error(f"❌ Verify API fallback failed: {verify_message}")
+                    
+            except Exception as e:
+                logger.error(f"❌ Verify API fallback error: {e}")
+        
+        # STEP 3: Final check
+        if not success:
+            logger.error(f"❌ All WhatsApp methods failed for {self._mask_phone(phone_number)}")
+            return False, "All WhatsApp delivery methods failed"
+        
+        logger.info(f"🎉 Phone OTP sent via {method_used} to {self._mask_phone(phone_number)}")
+        return True, f"{final_message} ({method_used})"
+
+    def send_whatsapp_otp_verify(self, phone_number: str, fallback_to_sms: bool = True) -> Tuple[bool, str]:
         """
         Send OTP via WhatsApp using Twilio Verify API.
         
@@ -448,10 +519,16 @@ def send_sms(to: str, body: str, **kwargs) -> Dict[str, Any]:
     return service.send_sms_message(to, body, **kwargs)
 
 
+def send_whatsapp_otp_hybrid(phone_number: str, otp_code: str, fallback_to_sms: bool = True) -> Tuple[bool, str]:
+    """Send WhatsApp OTP using hybrid approach (Direct WhatsApp first, then Verify API)."""
+    service = TwilioService()
+    return service.send_whatsapp_otp_hybrid(phone_number, otp_code, fallback_to_sms)
+
+
 def send_whatsapp_otp(phone_number: str, fallback_to_sms: bool = True) -> Tuple[bool, str]:
-    """Send WhatsApp OTP with optional SMS fallback."""
+    """Send WhatsApp OTP with optional SMS fallback using Verify API only."""
     service = TwilioService()
-    return service.send_whatsapp_otp(phone_number, fallback_to_sms)
+    return service.send_whatsapp_otp_verify(phone_number, fallback_to_sms)
 
 
 def send_sms_otp(phone_number: str) -> Tuple[bool, str]: