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

django_cfg/apps/payments/services/cache/{simple_cache.py → cache_service.py}

@@ -1,16 +1,40 @@
 """
-Simple cache implementation for API keys and rate limiting.
+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!
 """
 
-import logging
-from typing import Optional, Any
+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__)
 
-from .base import CacheInterface
-from ...utils.config_utils import CacheConfigHelper
 
-logger = logging.getLogger(__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):
@@ -18,12 +42,21 @@ 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
-        # Use config helper to check if cache is enabled
-        self.enabled = CacheConfigHelper.is_cache_enabled()
+        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."""
@@ -85,8 +118,16 @@ class ApiKeyCache:
     
     def __init__(self):
         self.cache = SimpleCache("api_keys")
-        # Get timeout from config
-        self.default_timeout = CacheConfigHelper.get_cache_timeout('api_key')
+        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."""
@@ -121,9 +162,14 @@ class RateLimitCache:
         current = self.get_usage_count(user_id, endpoint_group, window)
         new_count = current + 1
         
-        # Use config helper for TTL if not provided
+        # Get TTL from config or use defaults
         if ttl is None:
-            ttl = CacheConfigHelper.get_cache_timeout('rate_limit')
+            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)
@@ -133,3 +179,57 @@ class RateLimitCache:
         """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

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',
 ]