django-cfg 1.2.22__py3-none-any.whl → 1.2.23__py3-none-any.whl

django_cfg/apps/payments/utils/middleware_utils.py

@@ -0,0 +1,228 @@
+"""
+Utilities for middleware processing.
+"""
+
+from typing import Optional, List
+from django.http import HttpRequest
+from django.conf import settings
+
+
+def get_client_ip(request: HttpRequest) -> Optional[str]:
+    """
+    Get client IP address from request.
+    Handles various proxy headers and configurations.
+    """
+    
+    # Check for forwarded headers first
+    forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
+    if forwarded_for:
+        # Take first IP in chain (original client)
+        return forwarded_for.split(',')[0].strip()
+    
+    # Check for real IP header (common with nginx)
+    real_ip = request.META.get('HTTP_X_REAL_IP')
+    if real_ip:
+        return real_ip.strip()
+    
+    # Check for Cloudflare header
+    cf_ip = request.META.get('HTTP_CF_CONNECTING_IP')
+    if cf_ip:
+        return cf_ip.strip()
+    
+    # Fallback to remote address
+    remote_addr = request.META.get('REMOTE_ADDR')
+    if remote_addr:
+        return remote_addr.strip()
+    
+    return None
+
+
+def is_api_request(request: HttpRequest, api_prefixes: Optional[List[str]] = None) -> bool:
+    """
+    Check if request is an API request based on path prefixes.
+    
+    Args:
+        request: Django HTTP request
+        api_prefixes: List of API prefixes to check (defaults to settings)
+    """
+    
+    if api_prefixes is None:
+        api_prefixes = getattr(settings, 'PAYMENTS_API_PREFIXES', ['/api/'])
+    
+    path = request.path
+    return any(path.startswith(prefix) for prefix in api_prefixes)
+
+
+def extract_api_key(request: HttpRequest) -> Optional[str]:
+    """
+    Extract API key from request headers or query parameters.
+    Supports multiple authentication methods.
+    
+    Priority:
+    1. Authorization header (Bearer token)
+    2. X-API-Key header
+    3. Query parameter (less secure, for testing)
+    """
+    
+    # Method 1: Authorization header (Bearer token)
+    auth_header = request.META.get('HTTP_AUTHORIZATION', '')
+    if auth_header.startswith('Bearer '):
+        return auth_header[7:]  # Remove 'Bearer ' prefix
+    
+    # Method 2: X-API-Key header
+    api_key_header = request.META.get('HTTP_X_API_KEY')
+    if api_key_header:
+        return api_key_header.strip()
+    
+    # Method 3: Custom header variations
+    custom_headers = [
+        'HTTP_X_API_TOKEN',
+        'HTTP_APIKEY',
+        'HTTP_API_TOKEN',
+    ]
+    
+    for header in custom_headers:
+        value = request.META.get(header)
+        if value:
+            return value.strip()
+    
+    # Method 4: Query parameter (less secure, mainly for testing)
+    if getattr(settings, 'PAYMENTS_ALLOW_API_KEY_IN_QUERY', False):
+        query_key = request.GET.get('api_key') or request.GET.get('apikey')
+        if query_key:
+            return query_key.strip()
+    
+    return None
+
+
+def is_exempt_path(request: HttpRequest, exempt_paths: Optional[List[str]] = None) -> bool:
+    """
+    Check if request path is exempt from API key requirements.
+    
+    Args:
+        request: Django HTTP request
+        exempt_paths: List of exempt path prefixes (defaults to settings)
+    """
+    
+    if exempt_paths is None:
+        exempt_paths = getattr(settings, 'PAYMENTS_EXEMPT_PATHS', [
+            '/admin/',
+            '/cfg/',
+            '/api/v1/api-key/validate/',
+        ])
+    
+    path = request.path
+    return any(path.startswith(exempt) for exempt in exempt_paths)
+
+
+def get_request_metadata(request: HttpRequest) -> dict:
+    """
+    Extract useful metadata from request for logging and analytics.
+    """
+    
+    return {
+        'method': request.method,
+        'path': request.path,
+        'query_string': request.META.get('QUERY_STRING', ''),
+        'user_agent': request.META.get('HTTP_USER_AGENT', ''),
+        'referer': request.META.get('HTTP_REFERER', ''),
+        'ip_address': get_client_ip(request),
+        'content_type': request.META.get('CONTENT_TYPE', ''),
+        'content_length': request.META.get('CONTENT_LENGTH', 0),
+        'host': request.META.get('HTTP_HOST', ''),
+        'scheme': request.scheme,
+        'is_secure': request.is_secure(),
+    }
+
+
+def should_track_request_body(request: HttpRequest, max_size: int = 10000) -> bool:
+    """
+    Determine if request body should be tracked for analytics.
+    
+    Args:
+        request: Django HTTP request
+        max_size: Maximum body size to track (bytes)
+    """
+    
+    # Check content length
+    content_length = request.META.get('CONTENT_LENGTH')
+    if content_length and int(content_length) > max_size:
+        return False
+    
+    # Don't track file uploads
+    content_type = request.META.get('CONTENT_TYPE', '')
+    if 'multipart/form-data' in content_type:
+        return False
+    
+    # Don't track binary content
+    if 'application/octet-stream' in content_type:
+        return False
+    
+    # Don't track sensitive endpoints
+    sensitive_paths = getattr(settings, 'PAYMENTS_SENSITIVE_PATHS', [
+        '/api/v1/api-key/',
+        '/api/v1/payment/',
+        '/api/v1/subscription/',
+    ])
+    
+    path = request.path
+    if any(path.startswith(sensitive) for sensitive in sensitive_paths):
+        return False
+    
+    return True
+
+
+def should_track_response_body(response, max_size: int = 10000) -> bool:
+    """
+    Determine if response body should be tracked for analytics.
+    
+    Args:
+        response: Django HTTP response
+        max_size: Maximum body size to track (bytes)
+    """
+    
+    # Don't track large responses
+    if hasattr(response, 'content') and len(response.content) > max_size:
+        return False
+    
+    # Only track successful JSON responses
+    if not (200 <= response.status_code < 300):
+        return False
+    
+    # Check content type
+    content_type = response.get('Content-Type', '')
+    if 'application/json' not in content_type:
+        return False
+    
+    return True
+
+
+def format_error_response(error_code: str, 
+                         message: str, 
+                         status_code: int = 400,
+                         additional_data: Optional[dict] = None) -> dict:
+    """
+    Format standardized error response for middleware.
+    
+    Args:
+        error_code: Machine-readable error code
+        message: Human-readable error message
+        status_code: HTTP status code
+        additional_data: Additional error data
+    """
+    
+    from django.utils import timezone
+    
+    error_response = {
+        'error': {
+            'code': error_code,
+            'message': message,
+            'status_code': status_code,
+            'timestamp': timezone.now().isoformat(),
+        }
+    }
+    
+    if additional_data:
+        error_response['error'].update(additional_data)
+    
+    return error_response

django_cfg/apps/payments/utils/validation_utils.py

@@ -0,0 +1,94 @@
+"""
+Validation utilities for payments module.
+
+Basic validation functions for API keys and subscription access.
+"""
+
+import logging
+from typing import Optional, Dict, Any
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+
+from ..models import APIKey, Subscription
+
+User = get_user_model()
+logger = logging.getLogger(__name__)
+
+
+def validate_api_key(api_key: str) -> bool:
+    """
+    Validate API key.
+    
+    Args:
+        api_key: API key to validate
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    try:
+        key = APIKey.objects.select_related('user').get(
+            key_value=api_key,
+            is_active=True
+        )
+        
+        # Check if key is expired
+        if key.expires_at and key.expires_at < timezone.now():
+            return False
+            
+        return True
+        
+    except APIKey.DoesNotExist:
+        return False
+    except Exception as e:
+        logger.error(f"Error validating API key: {e}")
+        return False
+
+
+def check_subscription_access(user_id: int, endpoint_group: str) -> Dict[str, Any]:
+    """
+    Check subscription access for user and endpoint group.
+    
+    Args:
+        user_id: User ID
+        endpoint_group: Endpoint group name
+        
+    Returns:
+        Access check result dictionary
+    """
+    try:
+        subscription = Subscription.objects.select_related('endpoint_group').get(
+            user_id=user_id,
+            endpoint_group__name=endpoint_group,
+            status='active',
+            expires_at__gt=timezone.now()
+        )
+        
+        # Check usage limits
+        usage_percentage = (subscription.current_usage / subscription.monthly_limit) * 100
+        remaining_requests = subscription.monthly_limit - subscription.current_usage
+        
+        return {
+            'allowed': remaining_requests > 0,
+            'subscription_id': str(subscription.id),
+            'remaining_requests': remaining_requests,
+            'usage_percentage': usage_percentage,
+            'reason': 'Active subscription' if remaining_requests > 0 else 'Usage limit exceeded'
+        }
+        
+    except Subscription.DoesNotExist:
+        return {
+            'allowed': False,
+            'reason': 'No active subscription found',
+            'subscription_id': None,
+            'remaining_requests': 0,
+            'usage_percentage': 0
+        }
+    except Exception as e:
+        logger.error(f"Error checking subscription access: {e}")
+        return {
+            'allowed': False,
+            'reason': f'Access check failed: {str(e)}',
+            'subscription_id': None,
+            'remaining_requests': 0,
+            'usage_percentage': 0
+        }

django_cfg/apps/support/signals.py

@@ -2,6 +2,8 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 import traceback
 import logging
+import socket
+from smtplib import SMTPException
 
 from .models import Message, Ticket
 from .utils.support_email_service import SupportEmailService
@@ -10,7 +12,7 @@ from django_cfg.modules.django_telegram import DjangoTelegram
 logger = logging.getLogger(__name__)
 
 @receiver(post_save, sender=Message)
-def notify_on_message(sender, instance, created, **kwargs):
+def notify_on_message(sender, instance: Message, created: bool, **kwargs):
     """Send notifications when a new message is created."""
     logger.info(f"🔔 Signal triggered: Message {instance.uuid} created={created}")
     
@@ -32,9 +34,14 @@ def notify_on_message(sender, instance, created, **kwargs):
             email_service = SupportEmailService(user)
             email_service.send_support_reply_email(instance)
             logger.info(f"   📬 Email sent successfully!")
+        except (socket.timeout, TimeoutError, SMTPException) as e:
+            logger.warning(f"   ⚠️ Email service timeout/error: {e}")
+            logger.info(f"   📝 Message processed successfully, email notification failed")
+            # Do not re-raise to prevent blocking the main process
         except Exception as e:
             logger.error(f"   ❌ Failed to send email notification: {e}")
-            traceback.print_exc()
+            logger.debug(f"   🔍 Exception details: {traceback.format_exc()}")
+            # Do not re-raise to prevent blocking the main process
     else:
         logger.info(f"   ⏭️ Not sending email (staff: {instance.sender.is_staff}, from_author: {instance.is_from_author})")
 
@@ -60,7 +67,7 @@ def notify_on_message(sender, instance, created, **kwargs):
 
 
 @receiver(post_save, sender=Ticket)
-def notify_on_ticket_created(sender, instance, created, **kwargs):
+def notify_on_ticket_created(sender, instance: Ticket, created: bool, **kwargs):
     """Send notification when a new ticket is created."""
     if not created:
         return
@@ -68,5 +75,10 @@ def notify_on_ticket_created(sender, instance, created, **kwargs):
     try:
         email_service = SupportEmailService(instance.user)
         email_service.send_ticket_created_email(instance)
+        logger.info(f"   📬 Ticket creation email sent successfully!")
+    except (socket.timeout, TimeoutError, SMTPException) as e:
+        logger.warning(f"   ⚠️ Email service timeout/error for ticket creation: {e}")
+        logger.info(f"   📝 Ticket created successfully, email notification failed")
     except Exception as e:
-        logger.error(f"Failed to send ticket creation email: {e}")
+        logger.error(f"   ❌ Failed to send ticket creation email: {e}")
+        logger.debug(f"   🔍 Exception details: {traceback.format_exc()}")

django_cfg/apps/support/templates/support/chat/ticket_chat.html

@@ -197,7 +197,7 @@
             submitBtn.disabled = true;
 
             try {
-                const response = await fetch(`{% url 'send-message-ajax' ticket_uuid=ticket.uuid %}`, {
+                const response = await fetch(`{% url 'cfg_support:send-message-ajax' ticket_uuid=ticket.uuid %}`, {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json',

django_cfg/models/revolution.py

@@ -93,7 +93,7 @@ class ExtendedRevolutionConfig(BaseDjangoRevolutionConfig):
             knowbase_enabled = base_module.is_knowbase_enabled()
             agents_enabled = base_module.is_agents_enabled()
             tasks_enabled = base_module.should_enable_tasks()
-            payments_enabled = base_module.enable_payments()
+            payments_enabled = base_module.is_payments_enabled()
             
             # Add Support zone if enabled
             default_support_zone = 'cfg_support'

django_cfg/modules/base.py

@@ -175,7 +175,7 @@ class BaseCfgModule(ABC):
         """
         return self._get_config_key('enable_maintenance', False)
 
-    def enable_payments(self) -> bool:
+    def is_payments_enabled(self) -> bool:
         """
         Check if django-cfg Payments is enabled.
         

django_cfg/modules/django_email.py

@@ -6,6 +6,9 @@ without requiring manual parameter passing.
 """
 
 from typing import List, Optional, Dict, Any, Union
+import socket
+from smtplib import SMTPException
+import logging
 from django.core.mail import send_mail, EmailMultiAlternatives
 from django.template.loader import render_to_string
 from django.utils.html import strip_tags
@@ -13,6 +16,8 @@ from django.conf import settings
 
 from . import BaseCfgModule
 
+logger = logging.getLogger(__name__)
+
 
 class DjangoEmailService(BaseCfgModule):
     """
@@ -30,6 +35,35 @@ class DjangoEmailService(BaseCfgModule):
         self.config = self.get_config()
         self.email_config = getattr(self.config, 'email', None)
     
+    def _handle_email_sending(self, email_func, *args, **kwargs):
+        """
+        Wrapper for email sending with proper timeout/exception handling.
+        
+        Args:
+            email_func: Email sending function to call
+            *args, **kwargs: Arguments to pass to the function
+            
+        Returns:
+            Result of email_func or 0 on timeout/error
+        """
+        try:
+            result = email_func(*args, **kwargs)
+            logger.debug(f"Email sent successfully: {email_func.__name__}")
+            return result
+        except (socket.timeout, TimeoutError) as e:
+            logger.warning(f"Email sending timeout: {e}")
+            logger.info("Consider checking SMTP server configuration or network connectivity")
+            return 0
+        except SMTPException as e:
+            logger.warning(f"SMTP error during email sending: {e}")
+            logger.info("Email service temporarily unavailable")
+            return 0
+        except Exception as e:
+            logger.error(f"Unexpected error during email sending: {e}")
+            if not kwargs.get('fail_silently', False):
+                raise
+            return 0
+    
     def send_simple(
         self,
         subject: str,
@@ -53,7 +87,8 @@ class DjangoEmailService(BaseCfgModule):
         """
         from_email = self._get_formatted_from_email(from_email)
         
-        return send_mail(
+        return self._handle_email_sending(
+            send_mail,
             subject=subject,
             message=message,
             from_email=from_email,
@@ -89,7 +124,8 @@ class DjangoEmailService(BaseCfgModule):
         if text_message is None:
             text_message = strip_tags(html_message)
         
-        return send_mail(
+        return self._handle_email_sending(
+            send_mail,
             subject=subject,
             message=text_message,
             from_email=from_email,
@@ -174,7 +210,7 @@ class DjangoEmailService(BaseCfgModule):
         if not html_content and not text_content:
             raise ValueError("Either html_content or text_content must be provided")
         
-        try:
+        def _send_multipart_email():
             email = EmailMultiAlternatives(
                 subject=subject,
                 body=text_content or strip_tags(html_content or ''),
@@ -191,7 +227,9 @@ class DjangoEmailService(BaseCfgModule):
             
             email.send(fail_silently=fail_silently)
             return True
-            
+        
+        try:
+            return self._handle_email_sending(_send_multipart_email) or False
         except Exception as e:
             if not fail_silently:
                 raise e

django_cfg/modules/django_unfold/dashboard.py

@@ -163,8 +163,28 @@ class DashboardManager(BaseCfgModule):
                 ]
             ))
         
+        # Add Payments section if enabled
+        if self.is_payments_enabled():
+            navigation_sections.append(NavigationSection(
+                title="Payments",
+                separator=True,
+                collapsible=True,
+                items=[
+                    NavigationItem(title="Payments", icon=Icons.ACCOUNT_BALANCE, link="/admin/django_cfg_payments/universalpayment/"),
+                    NavigationItem(title="Subscriptions", icon=Icons.PERSON_ADD, link="/admin/django_cfg_payments/subscription/"),
+                    NavigationItem(title="API Keys", icon=Icons.KEY, link="/admin/django_cfg_payments/apikey/"),
+                    NavigationItem(title="Balances", icon=Icons.ACCOUNT_BALANCE_WALLET, link="/admin/django_cfg_payments/userbalance/"),
+                    NavigationItem(title="Transactions", icon=Icons.DESCRIPTION, link="/admin/django_cfg_payments/transaction/"),
+                    NavigationItem(title="Currencies", icon=Icons.ACCOUNT_CIRCLE, link="/admin/django_cfg_payments/currency/"),
+                    NavigationItem(title="Currency Networks", icon=Icons.LINK, link="/admin/django_cfg_payments/currencynetwork/"),
+                    NavigationItem(title="Endpoint Groups", icon=Icons.GROUP, link="/admin/django_cfg_payments/endpointgroup/"),
+                    NavigationItem(title="Tariffs", icon=Icons.SETTINGS, link="/admin/django_cfg_payments/tariff/"),
+                ]
+            ))
+        
         # Convert all NavigationSection objects to dictionaries
         return [section.to_dict() for section in navigation_sections]
+        
     
     
     def get_unfold_config(self) -> Dict[str, Any]:

{django_cfg-1.2.22.dist-info → django_cfg-1.2.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.2.22
+Version: 1.2.23
 Summary: 🚀 Next-gen Django configuration: type-safety, AI features, blazing-fast setup, and automated best practices — all in one.
 Project-URL: Homepage, https://djangocfg.com
 Project-URL: Documentation, https://docs.djangocfg.com
@@ -146,6 +146,7 @@ Description-Content-Type: text/markdown
 
 # 🚀 Django-CFG: Enterprise Django Configuration Framework
 
+
 [![Python Version](https://img.shields.io/pypi/pyversions/django-cfg.svg?style=flat-square&logo=python&logoColor=white)](https://pypi.org/project/django-cfg/)
 [![Django Version](https://img.shields.io/pypi/djversions/django-cfg.svg?style=flat-square&logo=django&logoColor=white)](https://pypi.org/project/django-cfg/)
 [![PyPI Version](https://img.shields.io/pypi/v/django-cfg.svg?style=flat-square&logo=pypi&logoColor=white)](https://pypi.org/project/django-cfg/)