django-cfg 1.2.22__py3-none-any.whl → 1.2.25__py3-none-any.whl

django_cfg/apps/payments/models/payments.py

@@ -7,13 +7,13 @@ from django.contrib.auth import get_user_model
 from django.core.validators import MinValueValidator
 from django.core.exceptions import ValidationError
 from django.utils import timezone
-from .base import TimestampedModel
+from .base import UUIDTimestampedModel
 
 User = get_user_model()
 
 
 
-class UniversalPayment(TimestampedModel):
+class UniversalPayment(UUIDTimestampedModel):
     """Universal payment model for all providers."""
     
     class PaymentStatus(models.TextChoices):
@@ -28,6 +28,8 @@ class UniversalPayment(TimestampedModel):
     
     class PaymentProvider(models.TextChoices):
         NOWPAYMENTS = "nowpayments", "NowPayments"
+        CRYPTAPI = "cryptapi", "CryptAPI"
+        CRYPTOMUS = "cryptomus", "Cryptomus"
         STRIPE = "stripe", "Stripe"
         INTERNAL = "internal", "Internal"
     
@@ -138,6 +140,57 @@ class UniversalPayment(TimestampedModel):
         help_text="Raw webhook data from provider"
     )
     
+    # Universal Security fields (used by all providers)
+    security_nonce = models.CharField(
+        max_length=64,
+        null=True,
+        blank=True,
+        db_index=True,
+        help_text="Security nonce for replay attack protection (CryptAPI, Cryptomus, etc.)"
+    )
+    provider_callback_url = models.CharField(
+        max_length=512,
+        null=True,
+        blank=True,
+        help_text="Full callback URL with security parameters"
+    )
+    
+    # Universal Transaction fields (crypto providers)
+    transaction_hash = models.CharField(
+        max_length=256,
+        null=True,
+        blank=True,
+        db_index=True,
+        help_text="Main transaction hash/ID (txid_in for CryptAPI, hash for Cryptomus)"
+    )
+    confirmation_hash = models.CharField(
+        max_length=256,
+        null=True,
+        blank=True,
+        help_text="Secondary transaction hash (txid_out for CryptAPI, confirmation for others)"
+    )
+    sender_address = models.CharField(
+        max_length=200,
+        null=True,
+        blank=True,
+        help_text="Sender address (address_in for CryptAPI, from_address for Cryptomus)"
+    )
+    receiver_address = models.CharField(
+        max_length=200,
+        null=True,
+        blank=True,
+        help_text="Receiver address (address_out for CryptAPI, to_address for Cryptomus)"
+    )
+    crypto_amount = models.FloatField(
+        null=True,
+        blank=True,
+        help_text="Amount in cryptocurrency units (value_coin for CryptAPI, amount for Cryptomus)"
+    )
+    confirmations_count = models.PositiveIntegerField(
+        default=0,
+        help_text="Number of blockchain confirmations"
+    )
+    
     # Timestamps
     expires_at = models.DateTimeField(
         null=True,
@@ -172,6 +225,11 @@ class UniversalPayment(TimestampedModel):
             models.Index(fields=['currency_code']),
             models.Index(fields=['created_at']),
             models.Index(fields=['processed_at']),
+            # Universal crypto provider indexes
+            models.Index(fields=['security_nonce']),
+            models.Index(fields=['transaction_hash']),
+            models.Index(fields=['confirmations_count']),
+            models.Index(fields=['provider', 'status', 'confirmations_count']),
         ]
         ordering = ['-created_at']
 
@@ -207,6 +265,28 @@ class UniversalPayment(TimestampedModel):
         """Check if this is a cryptocurrency payment."""
         return self.provider == self.PaymentProvider.NOWPAYMENTS
 
+    @property
+    def is_crypto_provider_payment(self) -> bool:
+        """Check if this is a crypto provider payment (CryptAPI, Cryptomus, etc.)."""
+        crypto_providers = ['cryptapi', 'cryptomus', 'nowpayments']
+        return self.provider in crypto_providers or (self.security_nonce is not None)
+
+    @property
+    def has_sufficient_confirmations(self) -> bool:
+        """Check if payment has sufficient confirmations (3+ for most cryptos)."""
+        required_confirmations = 3  # Can be made configurable per currency
+        return self.confirmations_count >= required_confirmations
+
+    @property
+    def is_security_nonce_valid(self) -> bool:
+        """Check if security nonce is present for crypto provider payments."""
+        return bool(self.security_nonce) if self.is_crypto_provider_payment else True
+
+    @property
+    def has_transaction_hash(self) -> bool:
+        """Check if payment has a transaction hash."""
+        return bool(self.transaction_hash)
+
     def get_payment_url(self) -> str:
         """Get payment URL for QR code or direct payment."""
         if self.pay_address and self.pay_amount:
@@ -243,6 +323,36 @@ class UniversalPayment(TimestampedModel):
         
         if 'payment_id' in webhook_data:
             self.provider_payment_id = webhook_data['payment_id']
+            
+        # Universal crypto provider webhook fields
+        # CryptAPI format
+        if 'txid_in' in webhook_data:
+            self.transaction_hash = webhook_data['txid_in']
+        if 'txid_out' in webhook_data:
+            self.confirmation_hash = webhook_data['txid_out']
+        if 'address_in' in webhook_data:
+            self.sender_address = webhook_data['address_in']
+        if 'address_out' in webhook_data:
+            self.receiver_address = webhook_data['address_out']
+        if 'value_coin' in webhook_data:
+            self.crypto_amount = float(str(webhook_data['value_coin']))
+            
+        # Cryptomus format
+        if 'hash' in webhook_data:
+            self.transaction_hash = webhook_data['hash']
+        if 'from_address' in webhook_data:
+            self.sender_address = webhook_data['from_address']
+        if 'to_address' in webhook_data:
+            self.receiver_address = webhook_data['to_address']
+        if 'amount' in webhook_data and isinstance(webhook_data['amount'], (int, float, str)):
+            try:
+                self.crypto_amount = float(str(webhook_data['amount']))
+            except (ValueError, TypeError):
+                pass
+            
+        # Universal confirmations field
+        if 'confirmations' in webhook_data:
+            self.confirmations_count = int(webhook_data['confirmations'])
         
         self.save()
 

django_cfg/apps/payments/models/subscriptions.py

@@ -7,7 +7,7 @@ from django.contrib.auth import get_user_model
 from django.core.validators import MinValueValidator
 from django.utils import timezone
 from datetime import timedelta
-from .base import TimestampedModel
+from .base import UUIDTimestampedModel, TimestampedModel
 
 User = get_user_model()
 
@@ -106,7 +106,7 @@ class EndpointGroup(TimestampedModel):
         return tier_limits.get(tier, 0)
 
 
-class Subscription(TimestampedModel):
+class Subscription(UUIDTimestampedModel):
     """User subscriptions to endpoint groups."""
     
     class SubscriptionStatus(models.TextChoices):

django_cfg/apps/payments/services/__init__.py

@@ -1,14 +1,71 @@
 """
-Universal payment services.
+Universal Payment Services.
+
+Modular architecture with minimal Pydantic typing for inter-service communication.
+Uses Django ORM for data persistence and DRF for API responses.
 """
 
-from .base import PaymentProvider, PaymentService
-from .nowpayments import NowPaymentsProvider
-from .redis_service import RedisService
+# Core services
+from .core.payment_service import PaymentService
+from .core.balance_service import BalanceService
+from .core.subscription_service import SubscriptionService
+
+# Provider services
+from .providers.registry import ProviderRegistry
+from .providers.nowpayments import NowPaymentsProvider
+from .providers.cryptapi import CryptAPIProvider
+
+# Cache services
+from .cache import SimpleCache, ApiKeyCache, RateLimitCache
+
+# Internal types for inter-service communication
+from .internal_types import (
+    ProviderResponse, WebhookData, ServiceOperationResult,
+    BalanceUpdateRequest, AccessCheckRequest, AccessCheckResult,
+    # Service response models
+    PaymentCreationResult, WebhookProcessingResult, PaymentStatusResult,
+    UserBalanceResult, TransferResult, TransactionInfo,
+    EndpointGroupInfo, SubscriptionInfo, SubscriptionAnalytics,
+    # Additional response models
+    PaymentHistoryItem, ProviderInfo
+)
 
 __all__ = [
-    'PaymentProvider',
-    'PaymentService', 
+    # Core services
+    'PaymentService',
+    'BalanceService', 
+    'SubscriptionService',
+    
+    # Provider services
+    'ProviderRegistry',
     'NowPaymentsProvider',
-    'RedisService',
+    'CryptAPIProvider',
+    
+    # Cache services
+    'SimpleCache',
+    'ApiKeyCache', 
+    'RateLimitCache',
+    
+    # Internal types
+    'ProviderResponse',
+    'WebhookData', 
+    'ServiceOperationResult',
+    'BalanceUpdateRequest',
+    'AccessCheckRequest',
+    'AccessCheckResult',
+    
+    # Service response models
+    'PaymentCreationResult',
+    'WebhookProcessingResult', 
+    'PaymentStatusResult',
+    'UserBalanceResult',
+    'TransferResult',
+    'TransactionInfo',
+    'EndpointGroupInfo',
+    'SubscriptionInfo',
+    'SubscriptionAnalytics',
+    
+    # Additional response models
+    'PaymentHistoryItem',
+    'ProviderInfo',
 ]

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

@@ -0,0 +1,8 @@
+"""
+Billing services for payments module.
+
+TODO: Implement billing services when needed.
+"""
+
+# Placeholder for future billing services
+__all__ = []

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

@@ -0,0 +1,15 @@
+"""
+Simple caching for API key access control and rate limiting.
+
+ONLY for API key caching - NOT for payment data!
+"""
+
+from .base import CacheInterface
+from .simple_cache import SimpleCache, ApiKeyCache, RateLimitCache
+
+__all__ = [
+    'CacheInterface',
+    'SimpleCache', 
+    'ApiKeyCache',
+    'RateLimitCache',
+]

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

@@ -0,0 +1,30 @@
+"""
+Base cache interface for payments module.
+"""
+
+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/simple_cache.py

@@ -0,0 +1,135 @@
+"""
+Simple cache implementation for API keys and rate limiting.
+ONLY for API access control - NOT payment data!
+"""
+
+import logging
+from typing import Optional, Any
+from django.core.cache import cache
+
+from .base import CacheInterface
+from ...utils.config_utils import CacheConfigHelper
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleCache(CacheInterface):
+    """
+    Simple cache implementation using Django's cache framework.
+    
+    Falls back gracefully when cache is unavailable.
+    """
+    
+    def __init__(self, prefix: str = "payments"):
+        self.prefix = prefix
+        # Use config helper to check if cache is enabled
+        self.enabled = CacheConfigHelper.is_cache_enabled()
+        
+    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")
+        # Get timeout from config
+        self.default_timeout = CacheConfigHelper.get_cache_timeout('api_key')
+    
+    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
+        
+        # Use config helper for TTL if not provided
+        if ttl is None:
+            ttl = CacheConfigHelper.get_cache_timeout('rate_limit')
+        
+        # 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/core/__init__.py

@@ -0,0 +1,17 @@
+"""
+Core payment services.
+
+Main business logic services for the payment system.
+"""
+
+from .payment_service import PaymentService
+from .balance_service import BalanceService
+from .subscription_service import SubscriptionService
+# Core services only - no legacy adapters
+
+__all__ = [
+    'PaymentService',
+    'BalanceService',
+    'SubscriptionService', 
+    # No legacy services
+]