django-cfg 1.2.31__py3-none-any.whl → 1.3.3__py3-none-any.whl

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/base.py → cache_service/interfaces.py}

@@ -1,5 +1,7 @@
 """
-Base cache interface for payments module.
+Cache interfaces for the Universal Payment System v2.0.
+
+Abstract interfaces for cache implementations.
 """
 
 from abc import ABC, abstractmethod

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/__init__.py

@@ -1,17 +1,21 @@
 """
-Core payment services.
+Core services for the Universal Payment System v2.0.
 
-Main business logic services for the payment system.
+Business logic services with Pydantic validation.
 """
 
+from .base import BaseService
 from .payment_service import PaymentService
 from .balance_service import BalanceService
 from .subscription_service import SubscriptionService
-# Core services only - no legacy adapters
+from .currency_service import CurrencyService
+from .webhook_service import WebhookService
 
 __all__ = [
+    'BaseService',
     'PaymentService',
-    'BalanceService',
-    'SubscriptionService', 
-    # No legacy services
+    'BalanceService', 
+    'SubscriptionService',
+    'CurrencyService',
+    'WebhookService',
 ]