django-cfg 1.2.29__py3-none-any.whl → 1.3.1__py3-none-any.whl

django_cfg/apps/payments/views/templates/utils.py

@@ -1,181 +0,0 @@
-"""
-Utility views for payment dashboard.
-
-Provides testing, debugging, and development functionality.
-"""
-
-from django.views.generic import TemplateView
-from django.utils import timezone
-from datetime import timedelta
-from .base import (
-    SuperuserRequiredMixin,
-    PaymentContextMixin,
-    log_view_access
-)
-
-
-class PaymentTestView(
-    SuperuserRequiredMixin,
-    PaymentContextMixin,
-    TemplateView
-):
-    """Test view for development and debugging purposes."""
-    
-    template_name = 'payments/test.html'
-    page_title = 'Payment System Test'
-    
-    def get_breadcrumbs(self):
-        return [
-            {'name': 'Dashboard', 'url': '/payments/admin/'},
-            {'name': 'System Test', 'url': ''},
-        ]
-    
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        
-        # Log access for audit
-        log_view_access('payment_test', self.request.user)
-        
-        # Create sample data for testing templates
-        sample_data = self._generate_sample_data()
-        
-        # Get system information
-        system_info = self._get_system_info()
-        
-        # Get test scenarios
-        test_scenarios = self._get_test_scenarios()
-        
-        # Get common context
-        common_context = self.get_common_context()
-        
-        context.update({
-            'sample_data': sample_data,
-            'system_info': system_info,
-            'test_scenarios': test_scenarios,
-            'test_mode': True,
-            **common_context
-        })
-        
-        return context
-    
-    def _generate_sample_data(self):
-        """Generate sample payment data for testing."""
-        sample_payments = []
-        statuses = ['pending', 'confirming', 'completed', 'failed']
-        providers = ['nowpayments', 'cryptapi', 'cryptomus', 'stripe']
-        
-        for i in range(12):
-            sample_payments.append({
-                'id': f'sample-{i}',
-                'internal_payment_id': f'PAY-{1000 + i}',
-                'provider_payment_id': f'PROV-{2000 + i}',
-                'amount_usd': 50.0 + (i * 25),
-                'currency_code': 'USD',
-                'status': statuses[i % len(statuses)],
-                'provider': providers[i % len(providers)],
-                'user_email': f'user{i}@example.com',
-                'created_at': timezone.now() - timedelta(hours=i),
-                'updated_at': timezone.now() - timedelta(minutes=i * 10),
-                'pay_address': f'1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa{i}' if i % 2 == 0 else None,
-                'pay_amount': 0.001 + (i * 0.0001) if i % 2 == 0 else None,
-            })
-        
-        return {
-            'payments': sample_payments,
-            'stats': {
-                'total_count': len(sample_payments),
-                'pending_count': len([p for p in sample_payments if p['status'] == 'pending']),
-                'completed_count': len([p for p in sample_payments if p['status'] == 'completed']),
-                'failed_count': len([p for p in sample_payments if p['status'] == 'failed']),
-                'total_volume': sum(p['amount_usd'] for p in sample_payments),
-            }
-        }
-    
-    def _get_system_info(self):
-        """Get system information for debugging."""
-        import django
-        import sys
-        from django.conf import settings
-        
-        info = {
-            'django_version': django.get_version(),
-            'python_version': sys.version,
-            'debug_mode': settings.DEBUG,
-            'database_engine': settings.DATABASES['default']['ENGINE'],
-            'installed_apps': len(settings.INSTALLED_APPS),
-            'timezone': str(settings.TIME_ZONE),
-            'language': settings.LANGUAGE_CODE,
-        }
-        
-        # Add payment-specific info
-        try:
-            from ...models import UniversalPayment, PaymentEvent
-            info.update({
-                'total_payments': UniversalPayment.objects.count(),
-                'total_events': PaymentEvent.objects.count(),
-                'providers_in_use': list(
-                    UniversalPayment.objects.values_list('provider', flat=True).distinct()
-                ),
-            })
-        except Exception:
-            info.update({
-                'total_payments': 'Unable to query',
-                'total_events': 'Unable to query',
-                'providers_in_use': [],
-            })
-        
-        return info
-    
-    def _get_test_scenarios(self):
-        """Get available test scenarios."""
-        scenarios = [
-            {
-                'name': 'Template Component Test',
-                'description': 'Test all payment template components with sample data',
-                'endpoint': '/payments/test/?test=components',
-                'available': True,
-            },
-            {
-                'name': 'Status Badge Test',
-                'description': 'Test payment status badges for all possible statuses',
-                'endpoint': '/payments/test/?test=status_badges',
-                'available': True,
-            },
-            {
-                'name': 'Progress Bar Test',
-                'description': 'Test payment progress bars with different percentages',
-                'endpoint': '/payments/test/?test=progress_bars',
-                'available': True,
-            },
-            {
-                'name': 'Provider Statistics Test',
-                'description': 'Test provider statistics with sample data',
-                'endpoint': '/payments/test/?test=provider_stats',
-                'available': True,
-            },
-            {
-                'name': 'Real-time Updates Test',
-                'description': 'Test WebSocket connections and real-time updates',
-                'endpoint': '/payments/test/?test=realtime',
-                'available': False,  # Requires WebSocket setup
-            },
-            {
-                'name': 'QR Code Generation Test',
-                'description': 'Test QR code generation for crypto payments',
-                'endpoint': '/payments/test/?test=qr_codes',
-                'available': True,
-            },
-            {
-                'name': 'API Integration Test',
-                'description': 'Test payment provider API integrations',
-                'endpoint': '/payments/test/?test=api_integration',
-                'available': False,  # Requires API keys
-            },
-        ]
-        
-        # Add current test parameter
-        current_test = self.request.GET.get('test', 'overview')
-        for scenario in scenarios:
-            scenario['is_current'] = scenario['endpoint'].endswith(f'test={current_test}')
-        
-        return scenarios

django_cfg/apps/payments/views/webhook_views.py

@@ -1,266 +0,0 @@
-"""
-Webhook processing views with signature validation.
-"""
-
-import json
-import logging
-from typing import Dict, Any
-
-from django.http import JsonResponse, HttpResponse
-from django.views.decorators.csrf import csrf_exempt
-from django.views.decorators.http import require_http_methods
-from django.utils.decorators import method_decorator
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.permissions import AllowAny
-from rest_framework.response import Response
-from rest_framework import status
-
-from ..services.core.payment_service import PaymentService
-from ..tasks.webhook_processing import process_webhook_with_fallback
-from ..services.security.webhook_validator import webhook_validator
-from ..services.security.error_handler import error_handler, SecurityError, ValidationError
-
-logger = logging.getLogger(__name__)
-
-
-@csrf_exempt
-@require_http_methods(["POST"])
-def webhook_handler(request, provider: str):
-    """
-    Main webhook handler with signature validation.
-    
-    Accepts webhooks from payment providers and processes them
-    with proper validation and fallback mechanisms.
-    """
-    try:
-        # Parse webhook data
-        webhook_data = json.loads(request.body.decode('utf-8'))
-        
-        # Extract request headers
-        request_headers = {
-            key: value for key, value in request.META.items()
-            if key.startswith('HTTP_')
-        }
-        
-        # Generate idempotency key for deduplication
-        idempotency_key = _generate_idempotency_key(provider, webhook_data, request_headers)
-        
-        logger.info(f"📥 Received webhook from {provider}, key: {idempotency_key}")
-        
-        # Validate webhook with enhanced security
-        is_valid, validation_error = webhook_validator.validate_webhook(
-            provider=provider,
-            webhook_data=webhook_data,
-            request_headers=request_headers,
-            raw_body=request.body
-        )
-        
-        if not is_valid:
-            security_error = SecurityError(
-                f"Webhook validation failed: {validation_error}",
-                details={'provider': provider, 'validation_error': validation_error}
-            )
-            error_handler.handle_error(security_error, {
-                'provider': provider,
-                'webhook_data_keys': list(webhook_data.keys()),
-                'headers_count': len(request_headers)
-            }, request)
-            
-            return JsonResponse(
-                {'error': 'Webhook validation failed', 'code': 'INVALID_WEBHOOK'}, 
-                status=403
-            )
-        
-        # Process webhook (async with fallback to sync)
-        result = process_webhook_with_fallback(
-            provider=provider,
-            webhook_data=webhook_data,
-            idempotency_key=idempotency_key,
-            request_headers=request_headers
-        )
-        
-        if result.get('success'):
-            logger.info(f"✅ Webhook processed successfully: {idempotency_key}")
-            return JsonResponse({
-                'status': 'success',
-                'idempotency_key': idempotency_key,
-                'processing_mode': result.get('mode', 'unknown')
-            })
-        else:
-            logger.error(f"❌ Webhook processing failed: {result.get('error')}")
-            return JsonResponse({
-                'status': 'error',
-                'error': result.get('error', 'Processing failed'),
-                'idempotency_key': idempotency_key
-            }, status=400)
-            
-    except json.JSONDecodeError as e:
-        validation_error = ValidationError(
-            f"Invalid JSON in webhook from {provider}",
-            details={'provider': provider, 'json_error': str(e)}
-        )
-        error_result = error_handler.handle_error(validation_error, {
-            'provider': provider,
-            'raw_body_length': len(request.body) if request.body else 0
-        }, request)
-        
-        return JsonResponse({
-            'error': 'Invalid JSON',
-            'code': validation_error.error_code
-        }, status=400)
-        
-    except Exception as e:
-        # Handle unexpected errors with centralized error handler
-        error_result = error_handler.handle_error(e, {
-            'provider': provider,
-            'operation': 'webhook_processing',
-            'webhook_data_available': 'webhook_data' in locals()
-        }, request)
-    
-        return JsonResponse({
-            'error': 'Internal server error',
-            'code': error_result.error.error_code
-        }, status=500)
-
-
-@api_view(['POST'])
-@permission_classes([AllowAny])
-def webhook_test(request):
-    """
-    Test webhook endpoint for development.
-    
-    Allows testing webhook processing without requiring
-    actual payment provider signatures.
-    """
-    try:
-        provider = request.data.get('provider', 'test')
-        webhook_data = request.data.get('webhook_data', {})
-        
-        # Add test marker
-        webhook_data['_test_webhook'] = True
-        
-        # Generate test idempotency key
-        import uuid
-        idempotency_key = f"test_{uuid.uuid4().hex[:8]}"
-        
-        logger.info(f"🧪 Processing test webhook: {provider}")
-        
-        # Process with PaymentService directly (sync)
-        payment_service = PaymentService()
-        result = payment_service.process_webhook(
-            provider=provider,
-            webhook_data=webhook_data,
-            request_headers={'HTTP_X_TEST': 'true'}
-        )
-        
-        return Response({
-            'status': 'success',
-            'test_mode': True,
-            'provider': provider,
-            'idempotency_key': idempotency_key,
-            'result': result.dict() if hasattr(result, 'dict') else result
-        })
-        
-    except Exception as e:
-        logger.error(f"❌ Test webhook error: {e}")
-        return Response({
-            'status': 'error',
-            'error': str(e),
-            'test_mode': True
-        }, status=status.HTTP_400_BAD_REQUEST)
-
-
-def _validate_webhook_signature(provider: str, webhook_data: Dict[str, Any], 
-                               request_headers: Dict[str, str]) -> bool:
-    """
-    Validate webhook signature based on provider.
-    
-    Each provider has different signature validation methods.
-    """
-    try:
-        if provider == 'nowpayments':
-            return _validate_nowpayments_signature(webhook_data, request_headers)
-        elif provider == 'cryptapi':
-            return _validate_cryptapi_signature(webhook_data, request_headers)
-        elif provider == 'test':
-            return True  # Allow test webhooks
-        else:
-            logger.warning(f"Unknown provider for signature validation: {provider}")
-            return False
-            
-    except Exception as e:
-        logger.error(f"Signature validation error for {provider}: {e}")
-        return False
-
-
-def _validate_nowpayments_signature(webhook_data: Dict[str, Any], 
-                                  request_headers: Dict[str, str]) -> bool:
-    """Validate NowPayments webhook signature."""
-    import hmac
-    import hashlib
-    from ..utils.config_utils import get_payments_config
-    
-    # Get IPN secret from config
-    config = get_payments_config()
-    if not config or not hasattr(config, 'providers') or 'nowpayments' not in config.providers:
-        logger.warning("NowPayments IPN secret not configured, skipping validation")
-        return True  # Allow if not configured (development mode)
-    
-    nowpayments_config = config.providers['nowpayments']
-    ipn_secret = getattr(nowpayments_config, 'ipn_secret', None)
-    
-    if not ipn_secret:
-        logger.warning("NowPayments IPN secret not configured, skipping validation")
-        return True
-    
-    # Get signature from headers
-    signature = request_headers.get('HTTP_X_NOWPAYMENTS_SIG')
-    if not signature:
-        logger.warning("No NowPayments signature found in headers")
-        return False
-    
-    # Calculate expected signature
-    payload = json.dumps(webhook_data, separators=(',', ':'), sort_keys=True)
-    expected_signature = hmac.new(
-        ipn_secret.encode(),
-        payload.encode(),
-        hashlib.sha512
-    ).hexdigest()
-    
-    return hmac.compare_digest(signature, expected_signature)
-
-
-def _validate_cryptapi_signature(webhook_data: Dict[str, Any], 
-                                request_headers: Dict[str, str]) -> bool:
-    """Validate CryptAPI webhook signature."""
-    # CryptAPI uses different validation method
-    # For now, implement basic validation
-    
-    # Check if required fields are present
-    required_fields = ['address_in', 'address_out', 'txid_in', 'value_coin', 'coin', 'confirmations']
-    for field in required_fields:
-        if field not in webhook_data:
-            logger.warning(f"Missing required field in CryptAPI webhook: {field}")
-            return False
-    
-    return True
-
-
-def _generate_idempotency_key(provider: str, webhook_data: Dict[str, Any], 
-                            request_headers: Dict[str, str]) -> str:
-    """Generate idempotency key for webhook deduplication."""
-    import hashlib
-    
-    # Use provider + payment ID + timestamp for uniqueness
-    payment_id = (
-        webhook_data.get('payment_id') or 
-        webhook_data.get('order_id') or
-        webhook_data.get('id') or
-        'unknown'
-    )
-    
-    timestamp = webhook_data.get('created_at') or webhook_data.get('timestamp')
-    
-    # Create hash from key components
-    key_data = f"{provider}:{payment_id}:{timestamp}"
-    return hashlib.md5(key_data.encode()).hexdigest()[:16]

django_cfg/apps/payments/viewsets.py

@@ -1,65 +0,0 @@
-"""
-Payment system ViewSets router for easy integration.
-"""
-
-from rest_framework.routers import DefaultRouter
-from rest_framework_nested import routers
-
-from .views import (
-    # Balance ViewSets
-    UserBalanceViewSet, TransactionViewSet,
-    
-    # Payment ViewSets
-    UserPaymentViewSet, UniversalPaymentViewSet,
-    
-    # Subscription ViewSets
-    UserSubscriptionViewSet, SubscriptionViewSet, EndpointGroupViewSet,
-    
-    # API Key ViewSets
-    UserAPIKeyViewSet, APIKeyViewSet,
-    
-    # Currency ViewSets
-    CurrencyViewSet, CurrencyNetworkViewSet,
-    
-    # Tariff ViewSets
-    TariffViewSet, TariffEndpointGroupViewSet,
-)
-
-
-class PaymentSystemRouter:
-    """Universal router with all payment endpoints"""
-    
-    def __init__(self):
-        self.router = DefaultRouter()
-        self._setup_main_routes()
-        
-    def _setup_main_routes(self):
-        """Setup main resource routes"""
-        # Core payment resources
-        self.router.register(r'payments', UniversalPaymentViewSet, basename='payment')
-        self.router.register(r'balances', UserBalanceViewSet, basename='balance')
-        self.router.register(r'transactions', TransactionViewSet, basename='transaction')
-        
-        # Subscription management
-        self.router.register(r'subscriptions', SubscriptionViewSet, basename='subscription')
-        self.router.register(r'endpoint-groups', EndpointGroupViewSet, basename='endpoint-group')
-        
-        # API key management
-        self.router.register(r'api-keys', APIKeyViewSet, basename='api-key')
-        
-        # Currency and pricing
-        self.router.register(r'currencies', CurrencyViewSet, basename='currency')
-        self.router.register(r'currency-networks', CurrencyNetworkViewSet, basename='currency-network')
-        self.router.register(r'tariffs', TariffViewSet, basename='tariff')
-        self.router.register(r'tariff-groups', TariffEndpointGroupViewSet, basename='tariff-group')
-    
-    @property
-    def urls(self):
-        """Get all URLs"""
-        return self.router.urls
-
-
-# Create default router instance
-payment_router = PaymentSystemRouter()
-
-__all__ = ['PaymentSystemRouter', 'payment_router']

django_cfg/core/integration.py

@@ -1,160 +0,0 @@
-"""
-Django CFG URL integration utilities.
-
-Provides automatic URL registration for django_cfg endpoints and integrations.
-"""
-
-from typing import List
-from django.urls import path, include, URLPattern
-from django_cfg.core.environment import EnvironmentDetector
-from django.conf import settings
-
-
-def add_django_cfg_urls(urlpatterns: List[URLPattern], cfg_prefix: str = "cfg/") -> List[URLPattern]:
-    """
-    Automatically add django_cfg URLs and all integrations to the main URL configuration.
-    
-    This function adds:
-    - Django CFG management URLs (cfg/)
-    - Django Revolution URLs (if available)
-    - Debug output (if development environment)
-    
-    Args:
-        urlpatterns: Existing URL patterns list
-        cfg_prefix: URL prefix for django_cfg endpoints (default: "cfg/")
-        
-    Returns:
-        Updated URL patterns list with all URLs added
-        
-    Example:
-        # In your main urls.py
-        from django_cfg import add_django_cfg_urls
-        
-        urlpatterns = [
-            path("", home_view, name="home"),
-            path("admin/", admin.site.urls),
-        ]
-        
-        # Automatically adds:
-        # - path("cfg/", include("django_cfg.apps.urls"))
-        # - Django Revolution URLs (if available)
-        # - Debug output (if development environment)
-        urlpatterns = add_django_cfg_urls(urlpatterns)
-    """
-    # Add django_cfg API URLs
-    new_patterns = urlpatterns + [
-        path(cfg_prefix, include("django_cfg.apps.urls")),
-    ]
-    
-    # Try to add Django Revolution URLs if available
-    try:
-        from django_revolution import add_revolution_urls
-        new_patterns = add_revolution_urls(new_patterns)
-    except ImportError:
-        # Django Revolution not available - skip
-        pass
-    
-    # Show debug output if in development environment
-    try:
-        if EnvironmentDetector.is_development():
-            _print_url_integration_info()
-    except ImportError:
-        # Fallback to Django DEBUG setting
-        try:
-            if getattr(settings, 'DEBUG', False):
-                _print_url_integration_info()
-        except ImportError:
-            pass
-    
-    return new_patterns
-
-
-def get_django_cfg_urls_info() -> dict:
-    """
-    Get information about django_cfg URL integration and all integrations.
-    
-    Returns:
-        Dictionary with complete URL integration info
-    """
-    try:
-        from django_cfg import __version__
-        version = __version__
-    except ImportError:
-        version = "unknown"
-    
-    # Get enabled endpoints based on configuration
-    endpoints = [
-        "cfg/commands/",
-        "cfg/health/",
-    ]
-    
-    try:
-        from django_cfg.modules.base import BaseCfgModule
-        base_module = BaseCfgModule()
-        
-        # All business logic apps are handled by Django Revolution zones
-        # if base_module.is_support_enabled():
-        #     endpoints.append("cfg/support/")
-        # if base_module.is_accounts_enabled():
-        #     endpoints.append("cfg/accounts/")
-        # Newsletter and Leads are handled by Django Revolution zones
-        # if base_module.is_newsletter_enabled():
-        #     endpoints.append("cfg/newsletter/")
-        # if base_module.is_leads_enabled():
-        #     endpoints.append("cfg/leads/")
-    except Exception:
-        # Fallback: show all possible endpoints
-        endpoints.extend([
-            "cfg/support/",
-            "cfg/accounts/",
-            "cfg/newsletter/",
-            "cfg/leads/",
-        ])
-    
-    info = {
-        "django_cfg": {
-            "version": version,
-            "prefix": "cfg/",
-            "endpoints": endpoints,
-            "description": "Django CFG management endpoints",
-        }
-    }
-    
-    # Add Django Revolution info if available
-    try:
-        from django_revolution import get_revolution_urls_info
-        revolution_info = get_revolution_urls_info()
-        if revolution_info:
-            info["django_revolution"] = revolution_info
-    except ImportError:
-        pass
-    
-    return info
-
-
-def _print_url_integration_info():
-    """Print URL integration debug information."""
-    integration_info = get_django_cfg_urls_info()
-    
-    print("=" * 60)
-    
-    # Django CFG info
-    if "django_cfg" in integration_info:
-        cfg_info = integration_info["django_cfg"]
-        print("⚙️  Django CFG URL Integration")
-        print(f"📦 Version: {cfg_info.get('version', 'unknown')}")
-        print(f"🔗 Prefix: /{cfg_info.get('prefix', 'cfg/')}")
-        print(f"📋 Endpoints: {len(cfg_info.get('endpoints', []))}")
-        for endpoint in cfg_info.get('endpoints', []):
-            print(f"   • {endpoint}")
-        print("=" * 60)
-    
-    # Django Revolution info
-    if "django_revolution" in integration_info:
-        revolution_info = integration_info["django_revolution"]
-        print("🚀 Django Revolution URL Integration")
-        print(f"📦 Version: {revolution_info.get('version', 'unknown')}")
-        print(f"📊 Zones: {revolution_info.get('total_zones', 0)}")
-        print(f"📱 Apps: {revolution_info.get('total_apps', 0)}")
-        print(f"🔗 API Prefix: /{revolution_info.get('api_prefix', 'apix')}/")
-        print("=" * 60)