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

django_cfg/apps/payments/admin_interface/views/payment_views.py

@@ -1,259 +0,0 @@
-"""
-Payment Template Views for Universal Payment System v2.0.
-
-Django template views for payment forms and status pages.
-"""
-
-from django.views.generic import TemplateView, DetailView
-from django.contrib.auth.mixins import LoginRequiredMixin
-from django.shortcuts import get_object_or_404
-from django.http import JsonResponse
-from django.utils import timezone
-
-from ...models import UniversalPayment
-from ...services.core.payment_service import PaymentService
-from ...services.core.currency_service import CurrencyService
-from ...services.integrations.providers_config import get_all_providers_info
-
-
-class PaymentFormView(LoginRequiredMixin, TemplateView):
-    """
-    Payment creation form view.
-    
-    Displays a form for creating new payments with provider selection
-    and real-time currency conversion.
-    """
-    template_name = 'payments/payment_form.html'
-    
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        
-        # Add form data
-        context.update({
-            'page_title': 'Create Payment',
-            'page_subtitle': 'Process a payment through our universal payment system',
-        })
-        
-        return context
-    
-    def post(self, request, *args, **kwargs):
-        """Handle AJAX payment creation."""
-        if not request.headers.get('Content-Type', '').startswith('application/json'):
-            return super().get(request, *args, **kwargs)
-        
-        try:
-            import json
-            data = json.loads(request.body)
-            
-            # Create payment using service
-            payment_service = PaymentService()
-            result = payment_service.create_payment(
-                user_id=request.user.id,
-                amount_usd=float(data.get('amount', 0)),
-                currency_code=data.get('currency', 'USD'),
-                provider=data.get('provider'),
-                callback_url=data.get('callback_url')
-            )
-            
-            if result.success:
-                return JsonResponse({
-                    'success': True,
-                    'payment': {
-                        'id': str(result.data.id),
-                        'external_id': result.data.external_id,
-                        'status': result.data.status,
-                        'amount_usd': result.data.amount_usd,
-                        'currency_code': result.data.currency_code,
-                        'provider': result.data.provider,
-                        'payment_url': result.data.payment_url,
-                        'qr_code_url': result.data.qr_code_url,
-                    }
-                })
-            else:
-                return JsonResponse({
-                    'success': False,
-                    'error': result.error_message
-                }, status=400)
-                
-        except Exception as e:
-            return JsonResponse({
-                'success': False,
-                'error': str(e)
-            }, status=500)
-
-
-class PaymentStatusView(DetailView):
-    """
-    Payment status tracking view.
-    
-    Displays payment status with real-time updates and timeline.
-    """
-    model = UniversalPayment
-    template_name = 'payments/payment_status.html'
-    context_object_name = 'payment'
-    
-    def get_object(self, queryset=None):
-        """Get payment by ID with optimized query."""
-        if queryset is None:
-            queryset = self.get_queryset()
-        
-        # Get payment ID from URL
-        payment_id = self.kwargs.get('pk')
-        
-        return get_object_or_404(
-            queryset.select_related('currency', 'user')
-                   .prefetch_related('transactions'),
-            id=payment_id
-        )
-    
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        payment = self.object
-        
-        # Add page metadata
-        context.update({
-            'page_title': f'Payment #{payment.external_id or str(payment.id)[:8]}',
-            'page_subtitle': 'Track your payment progress in real-time',
-        })
-        
-        return context
-    
-    def get(self, request, *args, **kwargs):
-        """Handle both template and AJAX requests."""
-        self.object = self.get_object()
-        
-        # Handle AJAX requests for status updates
-        if request.headers.get('Accept') == 'application/json':
-            payment = self.object
-            
-            return JsonResponse({
-                'id': str(payment.id),
-                'external_id': payment.external_id,
-                'status': payment.status,
-                'status_display': payment.get_status_display(),
-                'amount_usd': payment.amount_usd,
-                'amount_crypto': str(payment.amount_crypto) if payment.amount_crypto else None,
-                'currency_code': payment.currency.code,
-                'provider': payment.provider,
-                'network': payment.network,
-                'created_at': payment.created_at.isoformat(),
-                'updated_at': payment.updated_at.isoformat(),
-                'confirmed_at': payment.confirmed_at.isoformat() if payment.confirmed_at else None,
-                'payment_url': payment.payment_url,
-                'qr_code_url': payment.qr_code_url,
-                'exchange_rate': str(payment.exchange_rate) if payment.exchange_rate else None,
-            })
-        
-        # Regular template response
-        return super().get(request, *args, **kwargs)
-
-
-class PaymentListView(LoginRequiredMixin, TemplateView):
-    """
-    Payment list view with filtering and search.
-    
-    Displays a paginated list of payments with advanced filtering options.
-    """
-    template_name = 'payments/payment_list.html'
-    
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        
-        # Add page metadata
-        context.update({
-            'page_title': 'Payment History',
-            'page_subtitle': 'View and manage your payment transactions',
-        })
-        
-        return context
-
-
-class PaymentDashboardView(LoginRequiredMixin, TemplateView):
-    """
-    Main payment dashboard view.
-    
-    Displays payment statistics, recent activity, and quick actions.
-    """
-    template_name = 'payments/payment_dashboard.html'
-    
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        
-        # Get payment statistics
-        user_payments = UniversalPayment.objects.filter(user=self.request.user)
-        
-        stats = {
-            'total_payments': user_payments.count(),
-            'completed_payments': user_payments.filter(status='completed').count(),
-            'pending_payments': user_payments.filter(status__in=['pending', 'processing']).count(),
-            'failed_payments': user_payments.filter(status__in=['failed', 'cancelled']).count(),
-            'total_amount': sum(p.amount_usd for p in user_payments.filter(status='completed')),
-            'recent_payments': user_payments.order_by('-created_at')[:5],
-        }
-        
-        # Add page metadata
-        context.update({
-            'page_title': 'Payment Dashboard',
-            'page_subtitle': 'Overview of your payment activity',
-            'stats': stats,
-        })
-        
-        return context
-
-
-class CurrencyConverterView(TemplateView):
-    """
-    Currency conversion tool view.
-    
-    Provides real-time currency conversion rates and calculator.
-    """
-    template_name = 'payments/currency_converter.html'
-    
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        
-        # Add page metadata
-        context.update({
-            'page_title': 'Currency Converter',
-            'page_subtitle': 'Real-time currency conversion rates',
-        })
-        
-        return context
-    
-    def post(self, request, *args, **kwargs):
-        """Handle AJAX conversion requests."""
-        if not request.headers.get('Content-Type', '').startswith('application/json'):
-            return super().get(request, *args, **kwargs)
-        
-        try:
-            import json
-            data = json.loads(request.body)
-            
-            # Use currency service for conversion
-            currency_service = CurrencyService()
-            result = currency_service.convert_currency(
-                amount=float(data.get('amount', 0)),
-                from_currency=data.get('from_currency', 'USD'),
-                to_currency=data.get('to_currency', 'BTC')
-            )
-            
-            if result.success:
-                return JsonResponse({
-                    'success': True,
-                    'converted_amount': result.data.converted_amount,
-                    'exchange_rate': result.data.exchange_rate,
-                    'from_currency': result.data.from_currency,
-                    'to_currency': result.data.to_currency,
-                    'timestamp': timezone.now().isoformat(),
-                })
-            else:
-                return JsonResponse({
-                    'success': False,
-                    'error': result.error_message
-                }, status=400)
-                
-        except Exception as e:
-            return JsonResponse({
-                'success': False,
-                'error': str(e)
-            }, status=500)

django_cfg/apps/payments/admin_interface/views/webhook_dashboard.py

@@ -1,37 +0,0 @@
-"""
-Webhook dashboard template view.
-
-Simple dashboard for monitoring webhook activity and provider status.
-"""
-
-from django.views.generic import TemplateView
-from django.contrib.admin.views.decorators import staff_member_required
-from django.utils.decorators import method_decorator
-from django.http import JsonResponse
-
-
-@method_decorator(staff_member_required, name='dispatch')
-class WebhookDashboardView(TemplateView):
-    """
-    Webhook dashboard for monitoring and management.
-    
-    Provides a simple interface for:
-    - Viewing webhook provider configurations
-    - Monitoring webhook activity
-    - Testing webhook endpoints
-    - Checking ngrok status
-    """
-    
-    template_name = 'payments/webhook_dashboard.html'
-    
-    def get_context_data(self, **kwargs):
-        """Add dashboard context data."""
-        context = super().get_context_data(**kwargs)
-        
-        # Basic context - the real data comes from API endpoints
-        context.update({
-            'page_title': 'Webhook Dashboard',
-            'auto_refresh': True,  # Enable auto-refresh
-        })
-        
-        return context

django_cfg/apps/payments/services/cache/cache_service.py

@@ -1,235 +0,0 @@
-"""
-Cache services for the Universal Payment System v2.0.
-
-Based on proven solutions from payments_old with improvements.
-ONLY for API access control - NOT payment data!
-"""
-
-from abc import ABC, abstractmethod
-from typing import Optional, Any, Dict
-from django.core.cache import cache
-from django_cfg.modules.django_logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class CacheInterface(ABC):
-    """Abstract cache interface."""
-    
-    @abstractmethod
-    def get(self, key: str) -> Optional[Any]:
-        """Get value from cache."""
-        pass
-    
-    @abstractmethod
-    def set(self, key: str, value: Any, timeout: Optional[int] = None) -> bool:
-        """Set value in cache."""
-        pass
-    
-    @abstractmethod
-    def delete(self, key: str) -> bool:
-        """Delete value from cache."""
-        pass
-    
-    @abstractmethod
-    def exists(self, key: str) -> bool:
-        """Check if key exists in cache."""
-        pass
-
-
-class SimpleCache(CacheInterface):
-    """
-    Simple cache implementation using Django's cache framework.
-    
-    Falls back gracefully when cache is unavailable.
-    Based on proven solution from payments_old.
-    """
-    
-    def __init__(self, prefix: str = "payments"):
-        self.prefix = prefix
-        self.enabled = self._is_cache_enabled()
-    
-    def _is_cache_enabled(self) -> bool:
-        """Check if cache is enabled via PaymentsConfig."""
-        try:
-            from django_cfg.models.payments import PaymentsConfig
-            config = PaymentsConfig.get_current_config()
-            return config.enabled  # Cache enabled if payments enabled
-        except Exception:
-            return True  # Default to enabled with graceful fallback
-        
-    def _make_key(self, key: str) -> str:
-        """Create prefixed cache key."""
-        return f"{self.prefix}:{key}"
-    
-    def get(self, key: str) -> Optional[Any]:
-        """Get value from cache."""
-        if not self.enabled:
-            return None
-            
-        try:
-            cache_key = self._make_key(key)
-            return cache.get(cache_key)
-        except Exception as e:
-            logger.warning(f"Cache get failed for key {key}: {e}")
-            return None
-    
-    def set(self, key: str, value: Any, timeout: Optional[int] = None) -> bool:
-        """Set value in cache."""
-        if not self.enabled:
-            return False
-            
-        try:
-            cache_key = self._make_key(key)
-            cache.set(cache_key, value, timeout)
-            return True
-        except Exception as e:
-            logger.warning(f"Cache set failed for key {key}: {e}")
-            return False
-    
-    def delete(self, key: str) -> bool:
-        """Delete value from cache."""
-        if not self.enabled:
-            return False
-            
-        try:
-            cache_key = self._make_key(key)
-            cache.delete(cache_key)
-            return True
-        except Exception as e:
-            logger.warning(f"Cache delete failed for key {key}: {e}")
-            return False
-    
-    def exists(self, key: str) -> bool:
-        """Check if key exists in cache."""
-        if not self.enabled:
-            return False
-            
-        try:
-            cache_key = self._make_key(key)
-            return cache.get(cache_key) is not None
-        except Exception as e:
-            logger.warning(f"Cache exists check failed for key {key}: {e}")
-            return False
-
-
-class ApiKeyCache:
-    """Specialized cache for API key operations."""
-    
-    def __init__(self):
-        self.cache = SimpleCache("api_keys")
-        self.default_timeout = self._get_cache_timeout('api_key')
-    
-    def _get_cache_timeout(self, cache_type: str) -> int:
-        """Get cache timeout from PaymentsConfig."""
-        try:
-            from django_cfg.models.payments import PaymentsConfig
-            config = PaymentsConfig.get_current_config()
-            return config.cache_timeouts.get(cache_type, 300)
-        except Exception:
-            return 300  # 5 minutes default
-    
-    def get_api_key_data(self, api_key: str) -> Optional[dict]:
-        """Get cached API key data."""
-        return self.cache.get(f"key:{api_key}")
-    
-    def cache_api_key_data(self, api_key: str, data: dict) -> bool:
-        """Cache API key data."""
-        return self.cache.set(f"key:{api_key}", data, self.default_timeout)
-    
-    def invalidate_api_key(self, api_key: str) -> bool:
-        """Invalidate cached API key."""
-        return self.cache.delete(f"key:{api_key}")
-
-
-class RateLimitCache:
-    """Specialized cache for rate limiting."""
-    
-    def __init__(self):
-        self.cache = SimpleCache("rate_limit")
-    
-    def get_usage_count(self, user_id: int, endpoint_group: str, window: str = "hour") -> int:
-        """Get current usage count for rate limiting."""
-        key = f"usage:{user_id}:{endpoint_group}:{window}"
-        count = self.cache.get(key)
-        return count if count is not None else 0
-    
-    def increment_usage(self, user_id: int, endpoint_group: str, window: str = "hour", ttl: Optional[int] = None) -> int:
-        """Increment usage count and return new count."""
-        key = f"usage:{user_id}:{endpoint_group}:{window}"
-        
-        # Get current count
-        current = self.get_usage_count(user_id, endpoint_group, window)
-        new_count = current + 1
-        
-        # Get TTL from config or use defaults
-        if ttl is None:
-            try:
-                from django_cfg.models.payments import PaymentsConfig
-                config = PaymentsConfig.get_current_config()
-                ttl = config.cache_timeouts.get('rate_limit', 3600)
-            except Exception:
-                ttl = 3600 if window == "hour" else 86400  # 1 hour or 1 day
-        
-        # Set new count with TTL
-        self.cache.set(key, new_count, ttl)
-        return new_count
-    
-    def reset_usage(self, user_id: int, endpoint_group: str, window: str = "hour") -> bool:
-        """Reset usage count."""
-        key = f"usage:{user_id}:{endpoint_group}:{window}"
-        return self.cache.delete(key)
-
-
-class CacheService:
-    """
-    Main cache service providing access to specialized caches.
-    
-    Provides centralized access to different cache types.
-    """
-    
-    def __init__(self):
-        """Initialize cache service with specialized caches."""
-        self.simple_cache = SimpleCache()
-        self.api_key_cache = ApiKeyCache()
-        self.rate_limit_cache = RateLimitCache()
-    
-    def health_check(self) -> Dict[str, Any]:
-        """Check cache health."""
-        try:
-            test_key = "health_check"
-            test_value = "ok"
-            
-            # Test set/get/delete
-            self.simple_cache.set(test_key, test_value, 10)
-            retrieved = self.simple_cache.get(test_key)
-            self.simple_cache.delete(test_key)
-            
-            is_healthy = retrieved == test_value
-            
-            return {
-                'healthy': is_healthy,
-                'backend': cache.__class__.__name__,
-                'simple_cache': True,
-                'api_key_cache': True,
-                'rate_limit_cache': True
-            }
-        except Exception as e:
-            logger.error(f"Cache health check failed: {e}")
-            return {
-                'healthy': False,
-                'error': str(e),
-                'backend': cache.__class__.__name__
-            }
-
-
-# Global cache service instance
-_cache_service = None
-
-
-def get_cache_service() -> CacheService:
-    """Get global cache service instance."""
-    global _cache_service
-    if _cache_service is None:
-        _cache_service = CacheService()
-    return _cache_service