django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/modules/django_twilio/sendgrid_service.py

@@ -10,21 +10,19 @@ Handles all SendGrid-specific functionality including:
 import logging
 import random
 import string
-from typing import Optional, Dict, Any, Tuple
 from datetime import datetime, timedelta
+from typing import Any, Dict, Optional, Tuple
 
-from sendgrid import SendGridAPIClient
-from sendgrid.helpers.mail import Mail, From
-from asgiref.sync import sync_to_async
 from django.template.loader import render_to_string
-from django.utils.html import strip_tags
+from sendgrid import SendGridAPIClient
+from sendgrid.helpers.mail import Mail
 
 from django_cfg.modules.base import BaseCfgModule
-from django_cfg.modules.django_twilio.models import TwilioConfig, SendGridConfig
 from django_cfg.modules.django_twilio.exceptions import (
     TwilioConfigurationError,
     TwilioSendError,
 )
+from django_cfg.modules.django_twilio.models import SendGridConfig, TwilioConfig
 
 try:
     from django_cfg.apps.accounts.models import CustomUser
@@ -40,14 +38,14 @@ class SendGridService(BaseCfgModule):
     
     Handles email operations with auto-configuration from DjangoConfig.
     """
-    
+
     def __init__(self):
         """Initialize with auto-discovered configuration."""
         super().__init__()
         self._twilio_config: Optional[TwilioConfig] = None
         self._client: Optional[SendGridAPIClient] = None
         self._otp_storage: Dict[str, Dict[str, Any]] = {}  # In-memory storage for OTP codes
-    
+
     def get_twilio_config(self) -> TwilioConfig:
         """Get Twilio configuration (which includes SendGrid config)."""
         if self._twilio_config is None:
@@ -57,7 +55,7 @@ class SendGridService(BaseCfgModule):
                     "DjangoConfig instance not found",
                     suggestions=["Ensure DjangoConfig is properly initialized"]
                 )
-            
+
             twilio_config = getattr(django_config, 'twilio', None)
             if not twilio_config:
                 raise TwilioConfigurationError(
@@ -65,46 +63,46 @@ class SendGridService(BaseCfgModule):
                     missing_fields=["twilio"],
                     suggestions=["Add TwilioConfig to your DjangoConfig class"]
                 )
-            
+
             self._twilio_config = twilio_config
-        
+
         return self._twilio_config
-    
+
     def get_sendgrid_config(self) -> SendGridConfig:
         """Get SendGrid configuration."""
         config = self.get_twilio_config()
-        
+
         if not config.sendgrid:
             raise TwilioConfigurationError(
                 "SendGrid configuration not found",
                 missing_fields=["sendgrid"],
                 suggestions=["Configure SendGridConfig in your Twilio settings"]
             )
-        
+
         return config.sendgrid
-    
+
     def get_client(self) -> SendGridAPIClient:
         """Get or create SendGrid client."""
         if self._client is None:
             config = self.get_sendgrid_config()
-            
+
             try:
                 self._client = SendGridAPIClient(
                     api_key=config.api_key.get_secret_value()
                 )
-                
+
                 logger.info("SendGrid client initialized")
-                    
+
             except Exception as e:
                 raise TwilioConfigurationError(
                     f"Failed to initialize SendGrid client: {str(e)}",
                     suggestions=["Check SendGrid API key configuration"]
                 )
-        
+
         return self._client
-    
+
     # === Email Methods ===
-    
+
     def send_email(
         self,
         to_email: str,
@@ -131,11 +129,11 @@ class SendGridService(BaseCfgModule):
         try:
             client = self.get_client()
             config = self.get_sendgrid_config()
-            
+
             # Use config defaults if not provided
             sender_email = from_email or config.from_email
             sender_name = from_name or config.from_name
-            
+
             message = Mail(
                 from_email=(sender_email, sender_name),
                 to_emails=to_email,
@@ -143,35 +141,35 @@ class SendGridService(BaseCfgModule):
                 html_content=html_content,
                 plain_text_content=plain_content
             )
-            
+
             if config.reply_to_email:
                 message.reply_to = config.reply_to_email
-            
+
             response = client.send(message)
-            
+
             result = {
                 'status_code': response.status_code,
                 'success': response.status_code in [200, 201, 202],
                 'to_email': to_email,
                 'subject': subject,
             }
-            
+
             if result['success']:
                 logger.info(f"Email sent successfully to {self._mask_email(to_email)}")
             else:
                 logger.error(f"SendGrid API error: {response.status_code}")
-            
+
             return result
-            
+
         except Exception as e:
             logger.error(f"Failed to send email: {e}")
             raise TwilioSendError(
                 f"Failed to send email: {str(e)}",
                 context={'to_email': to_email, 'subject': subject}
             )
-    
+
     # === OTP Methods ===
-    
+
     def send_otp_email(
         self,
         email: str,
@@ -194,14 +192,14 @@ class SendGridService(BaseCfgModule):
         try:
             client = self.get_client()
             config = self.get_sendgrid_config()
-            
+
             # Use provided OTP code or generate new one
             if not otp_code:
                 otp_code = self._generate_otp(6)
                 # Store OTP for verification (10 minutes TTL)
                 self._store_otp(email, otp_code, 600)
             # If OTP code is provided, don't store it (it's already in database)
-            
+
             # Prepare email content
             if config.otp_template_id:
                 # Use dynamic template
@@ -213,13 +211,13 @@ class SendGridService(BaseCfgModule):
                 success, message = self._send_simple_otp_email(
                     client, config, email, otp_code, subject
                 )
-            
+
             if success:
                 logger.info(f"Email OTP sent successfully to {self._mask_email(email)}")
                 return True, message, otp_code
             else:
                 raise TwilioSendError(message)
-                
+
         except Exception as e:
             if isinstance(e, TwilioSendError):
                 raise
@@ -227,7 +225,7 @@ class SendGridService(BaseCfgModule):
                 f"Failed to send email OTP: {e}",
                 context={'email': email}
             ) from e
-    
+
     def verify_otp(self, email: str, code: str) -> Tuple[bool, str]:
         """
         Verify OTP code.
@@ -240,30 +238,30 @@ class SendGridService(BaseCfgModule):
             Tuple[bool, str]: (is_valid, message)
         """
         stored_data = self._get_stored_otp(email)
-        
+
         if not stored_data:
             return False, "OTP not found. Please request a new code."
-        
+
         if datetime.now() > stored_data['expires_at']:
             self._remove_otp(email)
             return False, "OTP expired. Please request a new code."
-        
+
         # Increment attempt counter
         stored_data['attempts'] += 1
-        
+
         if stored_data['attempts'] > 5:  # Max attempts
             self._remove_otp(email)
             return False, "Too many attempts. Please request a new code."
-        
+
         if stored_data['code'] == code:
             self._remove_otp(email)
             logger.info(f"Email OTP verified successfully for {self._mask_email(email)}")
             return True, "OTP verified successfully"
         else:
             return False, f"Invalid OTP code. {5 - stored_data['attempts']} attempts remaining."
-    
+
     # === Helper Methods ===
-    
+
     def _get_user_data(self, email: str) -> Tuple[str, str]:
         """
         Retrieves user's full name and username from the database.
@@ -285,9 +283,9 @@ class SendGridService(BaseCfgModule):
         # Fallback to email prefix
         email_prefix = email.split('@')[0]
         return email_prefix, email_prefix
-    
+
     # === Template Methods ===
-    
+
     def _send_template_email(
         self,
         client: SendGridAPIClient,
@@ -300,17 +298,17 @@ class SendGridService(BaseCfgModule):
         try:
             # Get config for dynamic data
             cfg = self.get_config()
-            
+
             # Get user data for template
             user_full_name, user_username = self._get_user_data(email)
-            
+
             # Prepare subject
             subject = f"Your {cfg.project_name if cfg else 'Django CFG'} verification code"
-            
+
             # Prepare template data matching sendgrid_otp_email.html template
             dynamic_data = {
                 'site_name': cfg.project_name if cfg else 'Django CFG',
-                'project_name': cfg.project_name if cfg else 'Django CFG', 
+                'project_name': cfg.project_name if cfg else 'Django CFG',
                 'user_name': user_full_name,  # Real user name
                 'user_email': email,
                 'user': {
@@ -325,29 +323,29 @@ class SendGridService(BaseCfgModule):
                 **config.custom_template_data,
                 **(template_data or {})
             }
-            
+
             message = Mail(
                 from_email=(config.from_email, config.from_name),
                 to_emails=email
                 # subject is handled by dynamic template with {{{subject}}} in SendGrid Console
             )
-            
+
             message.template_id = config.otp_template_id
             message.dynamic_template_data = dynamic_data
-            
+
             if config.reply_to_email:
                 message.reply_to = config.reply_to_email
-            
+
             response = client.send(message)
-            
+
             if response.status_code in [200, 201, 202]:
                 return True, f"OTP sent via email template to {self._mask_email(email)}"
             else:
                 return False, f"SendGrid API error: {response.status_code}"
-                
+
         except Exception as e:
             return False, f"Template email error: {e}"
-    
+
     def _send_simple_otp_email(
         self,
         client: SendGridAPIClient,
@@ -361,7 +359,7 @@ class SendGridService(BaseCfgModule):
             # Get current config for template context
             from django_cfg.core.state import get_current_config
             current_config = get_current_config()
-            
+
             # Prepare context for unified template
             cfg = self.get_config()
             context = {
@@ -371,11 +369,11 @@ class SendGridService(BaseCfgModule):
                 "project_name": cfg.project_name if cfg else 'Django CFG',
                 "user": {"username": email.split("@")[0]},  # Fallback user object
             }
-            
+
             # Add OTP link if config is available
             if current_config:
                 context["otp_link"] = current_config.get_otp_url(otp_code)
-            
+
             # Render Django templates
             try:
                 html_content = render_to_string("emails/otp_email.html", context)
@@ -385,7 +383,7 @@ class SendGridService(BaseCfgModule):
                 logger.warning(f"Django template render failed: {template_error}, using fallback HTML")
                 html_content = self._generate_html_content(otp_code, config.from_name)
                 plain_content = self._generate_plain_content(otp_code)
-            
+
             message = Mail(
                 from_email=(config.from_email, config.from_name),
                 to_emails=email,
@@ -393,26 +391,26 @@ class SendGridService(BaseCfgModule):
                 html_content=html_content,
                 plain_text_content=plain_content
             )
-            
+
             if config.reply_to_email:
                 message.reply_to = config.reply_to_email
-            
+
             response = client.send(message)
-            
+
             if response.status_code in [200, 201, 202]:
                 return True, f"OTP sent via email to {self._mask_email(email)}"
             else:
                 return False, f"SendGrid API error: {response.status_code}"
-                
+
         except Exception as e:
             return False, f"Simple email error: {e}"
-    
+
     # === Utility Methods ===
-    
+
     def _generate_otp(self, length: int = 6) -> str:
         """Generate numeric OTP code."""
         return ''.join(random.choices(string.digits, k=length))
-    
+
     def _store_otp(self, email: str, code: str, ttl_seconds: int = 600) -> None:
         """Store OTP code with expiration."""
         self._otp_storage[email] = {
@@ -421,15 +419,15 @@ class SendGridService(BaseCfgModule):
             'expires_at': datetime.now() + timedelta(seconds=ttl_seconds),
             'attempts': 0,
         }
-    
+
     def _get_stored_otp(self, email: str) -> Optional[Dict[str, Any]]:
         """Get stored OTP data."""
         return self._otp_storage.get(email)
-    
+
     def _remove_otp(self, email: str) -> None:
         """Remove OTP from storage."""
         self._otp_storage.pop(email, None)
-    
+
     def _mask_email(self, email: str) -> str:
         """Mask email for security in logs."""
         if "@" in email:
@@ -437,7 +435,7 @@ class SendGridService(BaseCfgModule):
             if len(parts) == 2:
                 return f"{parts[0][:2]}***@{parts[1]}"
         return "***"
-    
+
     def _generate_html_content(self, otp_code: str, company_name: str) -> str:
         """Generate HTML email content."""
         return f"""
@@ -462,7 +460,7 @@ class SendGridService(BaseCfgModule):
             </div>
         </div>
         """
-    
+
     def _generate_plain_content(self, otp_code: str) -> str:
         """Generate plain text email content."""
         return f"""

django_cfg/modules/django_twilio/simple_service.py

@@ -6,16 +6,17 @@ without the complexity of the OTP system.
 """
 
 import logging
-from typing import Optional, Dict, Any
-from ._imports import Client, TwilioException
+from typing import Any, Dict, Optional
 
 from django_cfg.modules.base import BaseCfgModule
-from django_cfg.modules.django_twilio.models import TwilioConfig
 from django_cfg.modules.django_twilio.exceptions import (
-    TwilioError,
     TwilioConfigurationError,
+    TwilioError,
     TwilioSendError,
 )
+from django_cfg.modules.django_twilio.models import TwilioConfig
+
+from ._imports import Client, TwilioException
 
 logger = logging.getLogger(__name__)
 
@@ -27,13 +28,13 @@ class SimpleTwilioService(BaseCfgModule):
     Provides easy-to-use methods for sending WhatsApp and SMS messages
     without the complexity of OTP verification systems.
     """
-    
+
     def __init__(self):
         """Initialize with auto-discovered configuration."""
         super().__init__()
         self._config: Optional[TwilioConfig] = None
         self._client: Optional[Client] = None
-    
+
     def get_config(self) -> TwilioConfig:
         """Get Twilio configuration from DjangoConfig."""
         if self._config is None:
@@ -43,7 +44,7 @@ class SimpleTwilioService(BaseCfgModule):
                     "DjangoConfig instance not found",
                     suggestions=["Ensure DjangoConfig is properly initialized"]
                 )
-            
+
             twilio_config = getattr(django_config, 'twilio', None)
             if not twilio_config:
                 raise TwilioConfigurationError(
@@ -51,11 +52,11 @@ class SimpleTwilioService(BaseCfgModule):
                     missing_fields=["twilio"],
                     suggestions=["Add TwilioConfig to your DjangoConfig class"]
                 )
-            
+
             self._config = twilio_config
-        
+
         return self._config
-    
+
     def get_client(self) -> Client:
         """Get or create Twilio client."""
         if self._client is None:
@@ -65,23 +66,23 @@ class SimpleTwilioService(BaseCfgModule):
                     config.account_sid,
                     config.auth_token.get_secret_value()
                 )
-                
+
                 if config.debug_logging:
                     logger.info(f"Twilio client initialized for account: {config.account_sid[:8]}...")
-                    
+
             except Exception as e:
                 raise TwilioConfigurationError(
                     f"Failed to initialize Twilio client: {str(e)}",
                     context={"account_sid": config.account_sid[:8] + "..."},
                     suggestions=["Verify your Twilio credentials"]
                 )
-        
+
         return self._client
-    
+
     def send_whatsapp_message(
-        self, 
-        to: str, 
-        body: str, 
+        self,
+        to: str,
+        body: str,
         from_number: Optional[str] = None,
         content_sid: Optional[str] = None,
         content_variables: Optional[Dict[str, str]] = None
@@ -105,23 +106,23 @@ class SimpleTwilioService(BaseCfgModule):
         try:
             client = self.get_client()
             config = self.get_config()
-            
+
             # Ensure to number has whatsapp prefix
             if not to.startswith('whatsapp:'):
                 to = f'whatsapp:{to}'
-            
+
             # Use default from number if not provided
             if not from_number:
                 from_number = 'whatsapp:+14155238886'  # Twilio sandbox
             elif not from_number.startswith('whatsapp:'):
                 from_number = f'whatsapp:{from_number}'
-            
+
             # Prepare message parameters
             message_params = {
                 'to': to,
                 'from_': from_number,
             }
-            
+
             # Use content template if provided
             if content_sid:
                 message_params['content_sid'] = content_sid
@@ -130,13 +131,13 @@ class SimpleTwilioService(BaseCfgModule):
                     message_params['content_variables'] = json.dumps(content_variables)
             else:
                 message_params['body'] = body
-            
+
             if config.debug_logging:
                 logger.info(f"Sending WhatsApp message to {to[:15]}...")
-            
+
             # Send message
             message = client.messages.create(**message_params)
-            
+
             result = {
                 'sid': message.sid,
                 'status': message.status,
@@ -147,12 +148,12 @@ class SimpleTwilioService(BaseCfgModule):
                 'price': message.price,
                 'price_unit': message.price_unit,
             }
-            
+
             if config.debug_logging:
                 logger.info(f"WhatsApp message sent successfully: {message.sid}")
-            
+
             return result
-            
+
         except TwilioException as e:
             logger.error(f"Twilio API error: {e}")
             raise TwilioSendError(
@@ -167,11 +168,11 @@ class SimpleTwilioService(BaseCfgModule):
         except Exception as e:
             logger.error(f"Unexpected error sending WhatsApp message: {e}")
             raise TwilioSendError(f"Unexpected error: {str(e)}")
-    
+
     def send_sms_message(
-        self, 
-        to: str, 
-        body: str, 
+        self,
+        to: str,
+        body: str,
         from_number: Optional[str] = None
     ) -> Dict[str, Any]:
         """
@@ -191,21 +192,21 @@ class SimpleTwilioService(BaseCfgModule):
         try:
             client = self.get_client()
             config = self.get_config()
-            
+
             # Use default from number if not provided
             if not from_number:
                 from_number = '+12297021650'  # Your SMS number
-            
+
             if config.debug_logging:
                 logger.info(f"Sending SMS to {to[:10]}...")
-            
+
             # Send message
             message = client.messages.create(
                 to=to,
                 from_=from_number,
                 body=body
             )
-            
+
             result = {
                 'sid': message.sid,
                 'status': message.status,
@@ -216,12 +217,12 @@ class SimpleTwilioService(BaseCfgModule):
                 'price': message.price,
                 'price_unit': message.price_unit,
             }
-            
+
             if config.debug_logging:
                 logger.info(f"SMS sent successfully: {message.sid}")
-            
+
             return result
-            
+
         except TwilioException as e:
             logger.error(f"Twilio API error: {e}")
             raise TwilioSendError(
@@ -236,7 +237,7 @@ class SimpleTwilioService(BaseCfgModule):
         except Exception as e:
             logger.error(f"Unexpected error sending SMS: {e}")
             raise TwilioSendError(f"Unexpected error: {str(e)}")
-    
+
     def get_message_status(self, message_sid: str) -> Dict[str, Any]:
         """
         Get status of a sent message.
@@ -250,7 +251,7 @@ class SimpleTwilioService(BaseCfgModule):
         try:
             client = self.get_client()
             message = client.messages(message_sid).fetch()
-            
+
             return {
                 'sid': message.sid,
                 'status': message.status,
@@ -265,7 +266,7 @@ class SimpleTwilioService(BaseCfgModule):
                 'error_code': message.error_code,
                 'error_message': message.error_message,
             }
-            
+
         except TwilioException as e:
             raise TwilioError(f"Failed to get message status: {str(e)}")
 

django_cfg/modules/django_twilio/sms.py

@@ -7,6 +7,7 @@ error handling and international support.
 
 import logging
 from typing import Tuple
+
 from asgiref.sync import sync_to_async
 
 from .base import BaseTwilioService