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

django_cfg/apps/payments/models/subscriptions.py

@@ -102,30 +102,6 @@ class SubscriptionQuerySet(models.QuerySet):
         return self.filter(user=user)
 
 
-class SubscriptionManager(models.Manager):
-    """Manager for subscription operations."""
-    
-    def get_queryset(self):
-        """Return optimized queryset by default."""
-        return SubscriptionQuerySet(self.model, using=self._db)
-    
-    def optimized(self):
-        """Get optimized queryset."""
-        return self.get_queryset().optimized()
-    
-    def active(self):
-        """Get active subscriptions."""
-        return self.get_queryset().active()
-    
-    def expired(self):
-        """Get expired subscriptions."""
-        return self.get_queryset().expired()
-    
-    def by_tier(self, tier):
-        """Get subscriptions by tier."""
-        return self.get_queryset().by_tier(tier)
-
-
 class Subscription(UUIDTimestampedModel):
     """
     User subscription model for API access control.

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

@@ -4,7 +4,7 @@ Cache services for the Universal Payment System v2.0.
 Redis-backed caching with type safety and automatic key management.
 """
 
-from .cache_service import CacheService, get_cache_service, SimpleCache, ApiKeyCache, RateLimitCache
+from ..cache_service import CacheService, get_cache_service, SimpleCache, ApiKeyCache, RateLimitCache
 
 __all__ = [
     'CacheService',

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

@@ -0,0 +1,143 @@
+"""
+Cache services for the Universal Payment System v2.0.
+
+Main entry point for cache functionality.
+Based on proven solutions from payments_old with improvements.
+ONLY for API access control - NOT payment data!
+"""
+
+from typing import Dict, Any
+from django.core.cache import cache
+from django_cfg.modules.django_logger import get_logger
+
+from .interfaces import CacheInterface
+from .simple_cache import SimpleCache
+from .api_key_cache import ApiKeyCache
+from .rate_limit_cache import RateLimitCache
+from .keys import CacheKeys
+
+logger = get_logger(__name__)
+
+
+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()
+        # Backward compatibility attributes
+        self.default_timeout = 300
+        self.key_prefix = "payments"
+    
+    # Backward compatibility methods - delegate to simple_cache
+    def get(self, key: str):
+        """Get value from cache."""
+        return self.simple_cache.get(key)
+    
+    def set(self, key: str, value, timeout=None):
+        """Set value in cache."""
+        return self.simple_cache.set(key, value, timeout)
+    
+    def delete(self, key: str):
+        """Delete value from cache."""
+        return self.simple_cache.delete(key)
+    
+    def exists(self, key: str):
+        """Check if key exists in cache."""
+        return self.simple_cache.exists(key)
+    
+    def get_or_set(self, key: str, default, timeout=None):
+        """Get value or set default if not exists."""
+        value = self.get(key)
+        if value is None:
+            if callable(default):
+                value = default()
+            else:
+                value = default
+            self.set(key, value, timeout)
+        return value
+    
+    def set_many(self, data: dict, timeout=None):
+        """Set multiple values."""
+        for key, value in data.items():
+            self.set(key, value, timeout)
+    
+    def get_many(self, keys: list):
+        """Get multiple values."""
+        result = {}
+        for key in keys:
+            value = self.get(key)
+            if value is not None:
+                result[key] = value
+        return result
+    
+    def delete_many(self, keys: list):
+        """Delete multiple values."""
+        for key in keys:
+            self.delete(key)
+    
+    def clear(self):
+        """Clear all cache (not implemented for safety)."""
+        # For safety, we don't implement cache.clear() 
+        # as it would clear the entire cache backend
+        # Instead, we clear Django's cache which is safe for tests
+        from django.core.cache import cache
+        cache.clear()
+    
+    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
+
+
+# Export main classes for backward compatibility
+__all__ = [
+    'CacheService',
+    'CacheInterface', 
+    'SimpleCache',
+    'ApiKeyCache',
+    'RateLimitCache',
+    'CacheKeys',
+    'get_cache_service'
+]

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

@@ -0,0 +1,37 @@
+"""
+API Key cache implementation for the Universal Payment System v2.0.
+
+Specialized caching for API key operations and validation.
+"""
+
+from typing import Optional
+from .simple_cache import SimpleCache
+
+
+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}")

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

@@ -0,0 +1,32 @@
+"""
+Cache interfaces for the Universal Payment System v2.0.
+
+Abstract interfaces for cache implementations.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Any
+
+
+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

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

@@ -0,0 +1,49 @@
+"""
+Cache key generation utilities for the Universal Payment System v2.0.
+
+Centralized cache key generation for consistency and testing.
+"""
+
+
+class CacheKeys:
+    """Cache key generation utilities."""
+    
+    @staticmethod
+    def user_balance(user_id: int) -> str:
+        """Generate cache key for user balance."""
+        return f"payments:user_balance:{user_id}"
+    
+    @staticmethod
+    def payment(payment_id: str) -> str:
+        """Generate cache key for payment data."""
+        return f"payments:payment:{payment_id}"
+    
+    @staticmethod
+    def payment_status(payment_id: str) -> str:
+        """Generate cache key for payment status."""
+        return f"payments:payment_status:{payment_id}"
+    
+    @staticmethod
+    def currency_rates(from_currency: str, to_currency: str) -> str:
+        """Generate cache key for currency exchange rates."""
+        return f"payments:currency_rates:{from_currency}:{to_currency}"
+    
+    @staticmethod
+    def provider_currencies(provider: str) -> str:
+        """Generate cache key for provider supported currencies."""
+        return f"payments:provider_currencies:{provider}"
+    
+    @staticmethod
+    def api_key_validation(api_key: str) -> str:
+        """Generate cache key for API key validation data."""
+        return f"payments:api_key_validation:{api_key}"
+    
+    @staticmethod
+    def user_subscription(user_id: int) -> str:
+        """Generate cache key for user subscription data."""
+        return f"payments:user_subscription:{user_id}"
+    
+    @staticmethod
+    def rate_limit(user_id: int, action: str) -> str:
+        """Generate cache key for rate limiting."""
+        return f"payments:rate_limit:{user_id}:{action}"

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

@@ -0,0 +1,47 @@
+"""
+Rate limiting cache implementation for the Universal Payment System v2.0.
+
+Specialized caching for API rate limiting and usage tracking.
+"""
+
+from typing import Optional
+from .simple_cache import SimpleCache
+
+
+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)

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

@@ -0,0 +1,101 @@
+"""
+Simple cache implementation for the Universal Payment System v2.0.
+
+Basic cache functionality with graceful fallback.
+"""
+
+from typing import Optional, Any
+from django.core.cache import cache
+from django_cfg.modules.django_logger import get_logger
+
+from .interfaces import CacheInterface
+
+logger = get_logger(__name__)
+
+
+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."""
+        from django.conf import settings
+        import sys
+        
+        # For tests, always enable cache (detect test environment)
+        if 'test' in sys.argv or hasattr(settings, 'TESTING'):
+            return True
+            
+        # For development, enable by default
+        if settings.DEBUG:
+            return True
+            
+        try:
+            from django_cfg.models.payments import PaymentsConfig
+            config = PaymentsConfig.get_current_config()
+            return config.enabled  # Cache enabled if payments enabled
+        except Exception as e:
+            logger.debug(f"PaymentsConfig not available, enabling cache by default: {e}")
+            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

django_cfg/apps/payments/services/core/balance_service.py

@@ -5,10 +5,12 @@ Handles user balance operations and transaction management.
 """
 
 from typing import Optional, Dict, Any, List
-from django.contrib.auth.models import User
+from django.contrib.auth import get_user_model
 from django.db import models
 from django.utils import timezone
 
+User = get_user_model()
+
 from .base import BaseService
 from ..types import (
     BalanceUpdateRequest, BalanceResult, TransactionData,
@@ -141,7 +143,16 @@ class BalanceService(BaseService):
             
             # Convert to response data
             balance_data = BalanceData.model_validate(balance)
-            transaction_data = TransactionData.model_validate(transaction)
+            transaction_data = TransactionData(
+                id=str(transaction.id),
+                user_id=transaction.user_id,
+                amount=float(transaction.amount_usd),
+                transaction_type=transaction.transaction_type,
+                description=transaction.description,
+                payment_id=transaction.payment_id,
+                metadata=transaction.metadata or {},
+                created_at=transaction.created_at
+            )
             
             self._log_operation(
                 "update_balance",

django_cfg/apps/payments/services/core/payment_service.py

@@ -6,19 +6,20 @@ Handles payment creation, status checking, and lifecycle management.
 
 from typing import Optional, Dict, Any
 from decimal import Decimal
-from django.contrib.auth.models import User
+from django.contrib.auth import get_user_model
+from django.db import models
 from django.utils import timezone
 
+from django_cfg.modules.django_currency import convert_currency, get_exchange_rate
 from .base import BaseService
 from ..types import (
     PaymentCreateRequest, PaymentStatusRequest, PaymentResult,
     PaymentData, ServiceOperationResult
 )
 from ...models import UniversalPayment, Currency, ProviderCurrency
-from django_cfg.modules.django_currency import convert_currency, get_exchange_rate
-# ConfigService removed - using direct Constance access
 from ..providers import ProviderRegistry, get_provider_registry
 
+User = get_user_model()
 
 class PaymentService(BaseService):
     """
@@ -85,16 +86,17 @@ class PaymentService(BaseService):
             
             # Create payment in database first
             def create_payment_transaction():
+                currency = currency_result.data['currency']
                 payment = UniversalPayment.objects.create(
                     user=user,
                     amount_usd=request.amount_usd,
-                    currency_code=request.currency_code,
+                    currency=currency,
+                    network=currency.native_networks.first(),  # Use first native network
                     provider=request.provider,
                     status=UniversalPayment.PaymentStatus.PENDING,
                     callback_url=request.callback_url,
                     cancel_url=request.cancel_url,
                     description=request.description,
-                    metadata=request.metadata,
                     expires_at=timezone.now() + timezone.timedelta(hours=1)  # 1 hour expiry
                 )
                 return payment
@@ -137,8 +139,8 @@ class PaymentService(BaseService):
                     error_code="provider_creation_failed"
                 )
             
-            # Convert to PaymentData for response
-            payment_data = PaymentData.model_validate(payment)
+            # Convert to PaymentData using our helper method
+            payment_data = self._convert_payment_to_data(payment)
             
             self._log_operation(
                 "create_payment",
@@ -154,8 +156,9 @@ class PaymentService(BaseService):
                 payment_id=str(payment.id),
                 status=payment.status,
                 amount_usd=payment.amount_usd,
-                crypto_amount=payment.crypto_amount,
-                currency_code=payment.currency_code,
+                crypto_amount=payment.pay_amount,
+                currency_code=payment.currency.code,
+                payment_url=payment.payment_url,
                 expires_at=payment.expires_at,
                 data={'payment': payment_data.model_dump()}
             )
@@ -211,8 +214,8 @@ class PaymentService(BaseService):
                     # Reload payment if status was updated
                     payment.refresh_from_db()
             
-            # Convert to PaymentData
-            payment_data = PaymentData.model_validate(payment)
+            # Convert to PaymentData using from_attributes
+            payment_data = self._convert_payment_to_data(payment)
             
             return PaymentResult(
                 success=True,
@@ -220,12 +223,12 @@ class PaymentService(BaseService):
                 payment_id=str(payment.id),
                 status=payment.status,
                 amount_usd=payment.amount_usd,
-                crypto_amount=payment.crypto_amount,
-                currency_code=payment.currency_code,
+                crypto_amount=payment.pay_amount,
+                currency_code=payment.currency.code,
                 provider_payment_id=payment.provider_payment_id,
                 payment_url=payment.payment_url,
-                qr_code_url=payment.qr_code_url,
-                wallet_address=payment.wallet_address,
+                qr_code_url=getattr(payment, 'qr_code_url', None),
+                wallet_address=payment.pay_address,
                 expires_at=payment.expires_at,
                 data={'payment': payment_data.model_dump()}
             )
@@ -279,7 +282,7 @@ class PaymentService(BaseService):
             
             if success:
                 payment.refresh_from_db()
-                payment_data = PaymentData.model_validate(payment)
+                payment_data = self._convert_payment_to_data(payment)
                 
                 self._log_operation(
                     "cancel_payment",
@@ -311,7 +314,7 @@ class PaymentService(BaseService):
     def _validate_currency(self, currency_code: str) -> ServiceOperationResult:
         """Validate currency is supported."""
         try:
-            currency = Currency.objects.get(code=currency_code, is_enabled=True)
+            currency = Currency.objects.get(code=currency_code, is_active=True)
             
             # Check if currency is supported by any provider
             provider_currency = ProviderCurrency.objects.filter(
@@ -327,7 +330,7 @@ class PaymentService(BaseService):
             
             return self._create_success_result(
                 "Currency is valid",
-                {'currency': currency_code}
+                {'currency': currency}  # Wrap in dict for Pydantic
             )
             
         except Currency.DoesNotExist:
@@ -391,10 +394,10 @@ class PaymentService(BaseService):
             total_count = queryset.count()
             payments = queryset.order_by('-created_at')[offset:offset + limit]
             
-            payment_data = [
-                PaymentData.model_validate(payment).model_dump()
-                for payment in payments
-            ]
+            payment_data = []
+            for payment in payments:
+                payment_obj = self._convert_payment_to_data(payment)
+                payment_data.append(payment_obj.model_dump())
             
             return self._create_success_result(
                 f"Retrieved {len(payment_data)} payments",
@@ -413,6 +416,30 @@ class PaymentService(BaseService):
                 user_id=user_id
             )
     
+    def _convert_payment_to_data(self, payment: UniversalPayment) -> PaymentData:
+        """Convert Django UniversalPayment to PaymentData."""
+        return PaymentData(
+            id=str(payment.id),
+            user_id=payment.user_id,
+            amount_usd=float(payment.amount_usd),
+            crypto_amount=payment.pay_amount,
+            currency_code=payment.currency.code,
+            provider=payment.provider,
+            status=payment.status,
+            provider_payment_id=payment.provider_payment_id,
+            payment_url=payment.payment_url,
+            qr_code_url=getattr(payment, 'qr_code_url', None),
+            wallet_address=payment.pay_address,
+            callback_url=payment.callback_url,
+            cancel_url=payment.cancel_url,
+            description=payment.description,
+            metadata={},
+            created_at=payment.created_at,
+            updated_at=payment.updated_at,
+            expires_at=payment.expires_at,
+            completed_at=getattr(payment, 'completed_at', None)
+        )
+    
     def get_payment_stats(self, days: int = 30) -> ServiceOperationResult:
         """Get payment statistics."""
         try:

django_cfg/apps/payments/services/integrations/ngrok_service.py

@@ -39,9 +39,9 @@ def get_api_base_url() -> str:
 
 
 def is_ngrok_available() -> bool:
-    """Check if ngrok tunnel is available."""
+    """Check if ngrok tunnel is actually active."""
     try:
-        from django_cfg.modules.django_ngrok import get_tunnel_url
-        return get_tunnel_url() is not None
+        from django_cfg.modules.django_ngrok import is_tunnel_active
+        return is_tunnel_active()
     except ImportError:
         return False