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

django_cfg/apps/payments/models/tariffs.py

@@ -1,102 +1,209 @@
 """
-Tariff models for the universal payments system.
+Tariff models for the Universal Payment System v2.0.
+
+Handles pricing tiers and endpoint group associations.
 """
 
 from django.db import models
-from django.core.validators import MinValueValidator
+from django.core.validators import MinValueValidator, MaxValueValidator
+from django.core.exceptions import ValidationError
 from .base import TimestampedModel
+from .subscriptions import EndpointGroup
 
 
 class Tariff(TimestampedModel):
-    """Simple tariff plans for API access."""
+    """
+    Tariff model for subscription pricing tiers.
+    
+    Defines pricing and limits for different subscription levels.
+    """
     
     name = models.CharField(
         max_length=100,
         unique=True,
-        help_text="Tariff name"
+        help_text="Tariff name (e.g., 'Free', 'Basic', 'Pro')"
     )
-    display_name = models.CharField(
-        max_length=200,
-        help_text="Human-readable tariff name"
+    
+    code = models.CharField(
+        max_length=50,
+        unique=True,
+        help_text="Tariff code (e.g., 'free', 'basic', 'pro')"
     )
+    
     description = models.TextField(
         blank=True,
-        help_text="Tariff description"
+        help_text="Detailed description of what this tariff includes"
     )
     
     # Pricing
-    monthly_price = models.FloatField(
-        default=0.0,
+    monthly_price_usd = models.FloatField(
         validators=[MinValueValidator(0.0)],
         help_text="Monthly price in USD"
     )
     
-    # Limits
-    request_limit = models.PositiveIntegerField(
+    yearly_price_usd = models.FloatField(
+        null=True,
+        blank=True,
+        validators=[MinValueValidator(0.0)],
+        help_text="Yearly price in USD (optional discount)"
+    )
+    
+    # Rate limits
+    requests_per_hour = models.PositiveIntegerField(
+        default=100,
+        validators=[MinValueValidator(1), MaxValueValidator(100000)],
+        help_text="API requests allowed per hour"
+    )
+    
+    requests_per_day = models.PositiveIntegerField(
         default=1000,
-        help_text="Monthly request limit (0 = unlimited)"
+        validators=[MinValueValidator(1), MaxValueValidator(1000000)],
+        help_text="API requests allowed per day"
+    )
+    
+    requests_per_month = models.PositiveIntegerField(
+        default=30000,
+        validators=[MinValueValidator(1), MaxValueValidator(10000000)],
+        help_text="API requests allowed per month"
+    )
+    
+    # Features
+    max_api_keys = models.PositiveIntegerField(
+        default=1,
+        validators=[MinValueValidator(1), MaxValueValidator(100)],
+        help_text="Maximum number of API keys allowed"
+    )
+    
+    supports_webhooks = models.BooleanField(
+        default=True,
+        help_text="Whether webhooks are supported"
+    )
+    
+    priority_support = models.BooleanField(
+        default=False,
+        help_text="Whether priority support is included"
     )
     
-    # Settings
+    # Availability
     is_active = models.BooleanField(
         default=True,
-        help_text="Is this tariff active"
+        help_text="Whether this tariff is available for new subscriptions"
     )
     
-    # Import and assign manager
-    from ..managers import TariffManager
-    objects = TariffManager()
+    is_public = models.BooleanField(
+        default=True,
+        help_text="Whether this tariff is publicly visible"
+    )
+    
+    # Ordering
+    sort_order = models.PositiveIntegerField(
+        default=0,
+        help_text="Sort order for display (lower numbers first)"
+    )
     
     class Meta:
-        db_table = 'tariffs'
-        verbose_name = "Tariff"
-        verbose_name_plural = "Tariffs"
+        db_table = 'payments_tariffs'
+        verbose_name = 'Tariff'
+        verbose_name_plural = 'Tariffs'
+        ordering = ['sort_order', 'monthly_price_usd']
         indexes = [
-            models.Index(fields=['is_active']),
-            models.Index(fields=['monthly_price']),
+            models.Index(fields=['is_active', 'is_public']),
+            models.Index(fields=['sort_order']),
         ]
-        ordering = ['monthly_price']
     
     def __str__(self):
-        return f"{self.display_name} (${self.monthly_price}/month)"
+        return f"{self.name} - ${self.monthly_price_usd:.2f}/month"
+    
+    def clean(self):
+        """Validate tariff data."""
+        if self.code:
+            self.code = self.code.lower().replace(' ', '_')
+        
+        # Validate rate limits hierarchy
+        if self.requests_per_day < self.requests_per_hour:
+            raise ValidationError("Daily limit cannot be less than hourly limit")
+        
+        if self.requests_per_month < self.requests_per_day:
+            raise ValidationError("Monthly limit cannot be less than daily limit")
+        
+        # Validate yearly pricing
+        if self.yearly_price_usd and self.yearly_price_usd >= (self.monthly_price_usd * 12):
+            raise ValidationError("Yearly price should be less than 12x monthly price")
     
     @property
     def is_free(self) -> bool:
         """Check if this is a free tariff."""
-        return self.monthly_price == 0
+        return self.monthly_price_usd == 0.0
+    
+    @property
+    def yearly_discount_percentage(self) -> float:
+        """Calculate yearly discount percentage."""
+        if not self.yearly_price_usd or self.monthly_price_usd == 0:
+            return 0.0
+        
+        yearly_equivalent = self.monthly_price_usd * 12
+        discount = yearly_equivalent - self.yearly_price_usd
+        return (discount / yearly_equivalent) * 100
+    
+    @property
+    def price_display(self) -> str:
+        """Formatted price display."""
+        if self.is_free:
+            return "Free"
+        return f"${self.monthly_price_usd:.2f}/month"
+    
+    @property
+    def yearly_price_display(self) -> str:
+        """Formatted yearly price display."""
+        if not self.yearly_price_usd:
+            return "N/A"
+        if self.yearly_price_usd == 0:
+            return "Free"
+        return f"${self.yearly_price_usd:.2f}/year"
 
 
 class TariffEndpointGroup(TimestampedModel):
-    """Simple association between tariffs and endpoint groups."""
+    """
+    Association between tariffs and endpoint groups.
+    
+    Defines which API endpoints are available for each tariff.
+    """
     
     tariff = models.ForeignKey(
         Tariff,
         on_delete=models.CASCADE,
-        related_name='endpoint_groups',
-        help_text="Tariff plan"
+        related_name='endpoint_groups'
     )
-    from .subscriptions import EndpointGroup
+    
     endpoint_group = models.ForeignKey(
         EndpointGroup,
         on_delete=models.CASCADE,
-        related_name='tariffs',
-        help_text="Endpoint group"
+        related_name='tariffs'
+    )
+    
+    # Override default rate limits for this specific combination
+    custom_rate_limit = models.PositiveIntegerField(
+        null=True,
+        blank=True,
+        help_text="Custom rate limit for this endpoint group (overrides tariff default)"
     )
     
     is_enabled = models.BooleanField(
         default=True,
-        help_text="Is this endpoint group enabled for this tariff"
+        help_text="Whether this endpoint group is enabled for this tariff"
     )
     
-    # Import and assign manager
-    from ..managers import TariffEndpointGroupManager
-    objects = TariffEndpointGroupManager()
-    
     class Meta:
-        db_table = 'tariff_endpoint_groups'
-        verbose_name = "Tariff Endpoint Group"
-        verbose_name_plural = "Tariff Endpoint Groups"
+        db_table = 'payments_tariff_endpoint_groups'
+        verbose_name = 'Tariff Endpoint Group'
+        verbose_name_plural = 'Tariff Endpoint Groups'
         unique_together = [['tariff', 'endpoint_group']]
+        ordering = ['tariff__sort_order', 'endpoint_group__name']
     
     def __str__(self):
         return f"{self.tariff.name} - {self.endpoint_group.name}"
+    
+    @property
+    def effective_rate_limit(self) -> int:
+        """Get effective rate limit (custom or tariff default)."""
+        return self.custom_rate_limit or self.tariff.requests_per_hour

django_cfg/apps/payments/services/__init__.py

@@ -1,71 +1,224 @@
 """
-Universal Payment Services.
+Services package for the Universal Payment System v2.0.
 
-Modular architecture with minimal Pydantic typing for inter-service communication.
-Uses Django ORM for data persistence and DRF for API responses.
+Business logic services with Pydantic validation and type safety.
 """
 
 # 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
+from .core import (
+    BaseService,
+    PaymentService,
+    BalanceService,
+    SubscriptionService,
+    WebhookService,
+    CurrencyService,
+)
+
+# Service types
+from .types import (
+    # Request types
+    PaymentCreateRequest,
+    PaymentStatusRequest,
+    BalanceUpdateRequest,
+    SubscriptionCreateRequest,
+    SubscriptionUpdateRequest,
+    CurrencyConversionRequest,
+    
+    # Response types
+    PaymentResult,
+    BalanceResult,
+    SubscriptionResult,
+    CurrencyConversionResult,
+    ServiceOperationResult,
+    
+    # Data types
+    PaymentData,
+    BalanceData,
+    SubscriptionData,
+    TransactionData,
+    CurrencyData,
+    
+    # Webhook types
+    WebhookData,
+    NowPaymentsWebhook,
+    WebhookProcessingResult,
 )
 
 __all__ = [
     # Core services
+    'BaseService',
     'PaymentService',
-    'BalanceService', 
+    'BalanceService',
     'SubscriptionService',
+    'WebhookService',
+    'CurrencyService',
     
-    # Provider services
-    'ProviderRegistry',
-    'NowPaymentsProvider',
-    'CryptAPIProvider',
-    
-    # Cache services
-    'SimpleCache',
-    'ApiKeyCache', 
-    'RateLimitCache',
+    # Request types
+    'PaymentCreateRequest',
+    'PaymentStatusRequest',
+    'BalanceUpdateRequest',
+    'SubscriptionCreateRequest',
+    'SubscriptionUpdateRequest',
+    'CurrencyConversionRequest',
     
-    # Internal types
-    'ProviderResponse',
-    'WebhookData', 
+    # Response types
+    'PaymentResult',
+    'BalanceResult',
+    'SubscriptionResult',
+    'CurrencyConversionResult',
     'ServiceOperationResult',
-    'BalanceUpdateRequest',
-    'AccessCheckRequest',
-    'AccessCheckResult',
-    
-    # Service response models
-    'PaymentCreationResult',
-    'WebhookProcessingResult', 
-    'PaymentStatusResult',
-    'UserBalanceResult',
-    'TransferResult',
-    'TransactionInfo',
-    'EndpointGroupInfo',
-    'SubscriptionInfo',
-    'SubscriptionAnalytics',
-    
-    # Additional response models
-    'PaymentHistoryItem',
-    'ProviderInfo',
+    
+    # Data types
+    'PaymentData',
+    'BalanceData',
+    'SubscriptionData',
+    'TransactionData',
+    'CurrencyData',
+    
+    # Webhook types
+    'WebhookData',
+    'NowPaymentsWebhook',
+    'WebhookProcessingResult',
 ]
+
+
+# Service registry for dependency injection and health checks
+class ServiceRegistry:
+    """
+    Service registry for managing service instances.
+    
+    Provides singleton access to services and health monitoring.
+    """
+    
+    _instances = {}
+    
+    @classmethod
+    def get_payment_service(cls) -> PaymentService:
+        """Get PaymentService instance."""
+        if 'payment' not in cls._instances:
+            cls._instances['payment'] = PaymentService()
+        return cls._instances['payment']
+    
+    @classmethod
+    def get_balance_service(cls) -> BalanceService:
+        """Get BalanceService instance."""
+        if 'balance' not in cls._instances:
+            cls._instances['balance'] = BalanceService()
+        return cls._instances['balance']
+    
+    @classmethod
+    def get_subscription_service(cls) -> SubscriptionService:
+        """Get SubscriptionService instance."""
+        if 'subscription' not in cls._instances:
+            cls._instances['subscription'] = SubscriptionService()
+        return cls._instances['subscription']
+    
+    @classmethod
+    def get_webhook_service(cls) -> WebhookService:
+        """Get WebhookService instance."""
+        if 'webhook' not in cls._instances:
+            cls._instances['webhook'] = WebhookService()
+        return cls._instances['webhook']
+    
+    @classmethod
+    def get_currency_service(cls) -> CurrencyService:
+        """Get CurrencyService instance."""
+        if 'currency' not in cls._instances:
+            cls._instances['currency'] = CurrencyService()
+        return cls._instances['currency']
+    
+    @classmethod
+    def get_all_services(cls) -> dict:
+        """Get all service instances."""
+        return {
+            'payment': cls.get_payment_service(),
+            'balance': cls.get_balance_service(),
+            'subscription': cls.get_subscription_service(),
+            'webhook': cls.get_webhook_service(),
+            'currency': cls.get_currency_service(),
+        }
+    
+    @classmethod
+    def health_check_all(cls) -> dict:
+        """Perform health check on all services."""
+        services = cls.get_all_services()
+        results = {}
+        
+        for name, service in services.items():
+            try:
+                health_result = service.health_check()
+                results[name] = {
+                    'healthy': health_result.success,
+                    'message': health_result.message,
+                    'data': health_result.data
+                }
+            except Exception as e:
+                results[name] = {
+                    'healthy': False,
+                    'message': f"Health check failed: {e}",
+                    'data': {}
+                }
+        
+        return results
+    
+    @classmethod
+    def clear_cache_all(cls):
+        """Clear cache for all services."""
+        for service in cls._instances.values():
+            if hasattr(service, '_cache_clear'):
+                service._cache_clear()
+    
+    @classmethod
+    def get_stats_all(cls) -> dict:
+        """Get statistics from all services."""
+        services = cls.get_all_services()
+        stats = {}
+        
+        for name, service in services.items():
+            try:
+                service_stats = service.get_service_stats()
+                stats[name] = service_stats
+            except Exception as e:
+                stats[name] = {
+                    'error': str(e),
+                    'service_name': service.__class__.__name__
+                }
+        
+        return stats
+
+
+# Convenience functions for direct service access
+def get_payment_service() -> PaymentService:
+    """Get PaymentService instance."""
+    return ServiceRegistry.get_payment_service()
+
+
+def get_balance_service() -> BalanceService:
+    """Get BalanceService instance."""
+    return ServiceRegistry.get_balance_service()
+
+
+def get_subscription_service() -> SubscriptionService:
+    """Get SubscriptionService instance."""
+    return ServiceRegistry.get_subscription_service()
+
+
+def get_webhook_service() -> WebhookService:
+    """Get WebhookService instance."""
+    return ServiceRegistry.get_webhook_service()
+
+
+def get_currency_service() -> CurrencyService:
+    """Get CurrencyService instance."""
+    return ServiceRegistry.get_currency_service()
+
+
+# Add convenience functions to __all__
+__all__.extend([
+    'ServiceRegistry',
+    'get_payment_service',
+    'get_balance_service',
+    'get_subscription_service',
+    'get_webhook_service',
+    'get_currency_service',
+])

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

@@ -1,15 +1,15 @@
 """
-Simple caching for API key access control and rate limiting.
+Cache services for the Universal Payment System v2.0.
 
-ONLY for API key caching - NOT for payment data!
+Redis-backed caching with type safety and automatic key management.
 """
 
-from .base import CacheInterface
-from .simple_cache import SimpleCache, ApiKeyCache, RateLimitCache
+from .cache_service import CacheService, get_cache_service, SimpleCache, ApiKeyCache, RateLimitCache
 
 __all__ = [
-    'CacheInterface',
-    'SimpleCache', 
+    'CacheService',
+    'get_cache_service',
     'ApiKeyCache',
     'RateLimitCache',
+    'SimpleCache',
 ]