django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/apps/payments/models/subscriptions.py

@@ -4,12 +4,14 @@ Subscription models for the Universal Payment System v2.0.
 Handles user subscriptions and API access control.
 """
 
-from django.db import models
+from datetime import timedelta
+
 from django.contrib.auth import get_user_model
-from django.core.validators import MinValueValidator, MaxValueValidator
 from django.core.exceptions import ValidationError
+from django.core.validators import MaxValueValidator, MinValueValidator
+from django.db import models
 from django.utils import timezone
-from datetime import timedelta
+
 from .base import UUIDTimestampedModel
 
 User = get_user_model()
@@ -21,54 +23,54 @@ class EndpointGroup(models.Model):
     
     Groups related API endpoints for subscription-based access control.
     """
-    
+
     name = models.CharField(
         max_length=100,
         unique=True,
         help_text="Endpoint group name (e.g., 'Payment API', 'Balance API')"
     )
-    
+
     code = models.CharField(
         max_length=50,
         unique=True,
         help_text="Endpoint group code (e.g., 'payments', 'balance')"
     )
-    
+
     description = models.TextField(
         blank=True,
         help_text="Description of what this endpoint group provides"
     )
-    
+
     # Access control
     is_enabled = models.BooleanField(
         default=True,
         help_text="Whether this endpoint group is available"
     )
-    
+
     requires_subscription = models.BooleanField(
         default=True,
         help_text="Whether access requires an active subscription"
     )
-    
+
     # Rate limiting defaults
     default_rate_limit = models.PositiveIntegerField(
         default=1000,
         help_text="Default requests per hour for this endpoint group"
     )
-    
+
     # Timestamps
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
-    
+
     class Meta:
         db_table = 'payments_endpoint_groups'
         verbose_name = 'Endpoint Group'
         verbose_name_plural = 'Endpoint Groups'
         ordering = ['name']
-    
+
     def __str__(self):
         return f"{self.name} ({self.code})"
-    
+
     def clean(self):
         """Validate endpoint group data."""
         if self.code:
@@ -77,26 +79,26 @@ class EndpointGroup(models.Model):
 
 class SubscriptionQuerySet(models.QuerySet):
     """Optimized queryset for subscription operations."""
-    
+
     def optimized(self):
         """Prevent N+1 queries."""
         return self.select_related('user').prefetch_related('endpoint_groups')
-    
+
     def active(self):
         """Get active subscriptions."""
         return self.filter(
             status=Subscription.SubscriptionStatus.ACTIVE,
             expires_at__gt=timezone.now()
         )
-    
+
     def expired(self):
         """Get expired subscriptions."""
         return self.filter(expires_at__lte=timezone.now())
-    
+
     def by_tier(self, tier):
         """Filter by subscription tier."""
         return self.filter(tier=tier)
-    
+
     def by_user(self, user):
         """Filter by user."""
         return self.filter(user=user)
@@ -108,41 +110,41 @@ class Subscription(UUIDTimestampedModel):
     
     Manages user subscriptions with different tiers and access levels.
     """
-    
+
     class SubscriptionStatus(models.TextChoices):
         ACTIVE = "active", "Active"
         INACTIVE = "inactive", "Inactive"
         SUSPENDED = "suspended", "Suspended"
         CANCELLED = "cancelled", "Cancelled"
         EXPIRED = "expired", "Expired"
-    
+
     class SubscriptionTier(models.TextChoices):
         FREE = "free", "Free Tier"
         BASIC = "basic", "Basic Tier"
         PRO = "pro", "Pro Tier"
         ENTERPRISE = "enterprise", "Enterprise Tier"
-    
+
     user = models.ForeignKey(
         User,
         on_delete=models.CASCADE,
         related_name='payment_subscriptions',
         help_text="User who owns this subscription"
     )
-    
+
     tier = models.CharField(
         max_length=20,
         choices=SubscriptionTier.choices,
         default=SubscriptionTier.FREE,
         help_text="Subscription tier"
     )
-    
+
     status = models.CharField(
         max_length=20,
         choices=SubscriptionStatus.choices,
         default=SubscriptionStatus.ACTIVE,
         help_text="Subscription status"
     )
-    
+
     # Access control
     endpoint_groups = models.ManyToManyField(
         EndpointGroup,
@@ -150,59 +152,59 @@ class Subscription(UUIDTimestampedModel):
         blank=True,
         help_text="Endpoint groups accessible with this subscription"
     )
-    
+
     # Rate limiting
     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,
         validators=[MinValueValidator(1), MaxValueValidator(1000000)],
         help_text="API requests allowed per day"
     )
-    
+
     # Subscription period
     starts_at = models.DateTimeField(
         default=timezone.now,
         help_text="When this subscription starts"
     )
-    
+
     expires_at = models.DateTimeField(
         help_text="When this subscription expires"
     )
-    
+
     # Billing information
     monthly_cost_usd = models.FloatField(
         default=0.0,
         validators=[MinValueValidator(0.0)],
         help_text="Monthly cost in USD"
     )
-    
+
     # Usage tracking
     total_requests = models.PositiveIntegerField(
         default=0,
         help_text="Total API requests made with this subscription"
     )
-    
+
     last_request_at = models.DateTimeField(
         null=True,
         blank=True,
         help_text="When the last API request was made"
     )
-    
+
     # Auto-renewal
     auto_renew = models.BooleanField(
         default=False,
         help_text="Whether to automatically renew this subscription"
     )
-    
+
     # Manager
     from .managers.subscription_managers import SubscriptionManager
     objects = SubscriptionManager()
-    
+
     class Meta:
         db_table = 'payments_subscriptions'
         verbose_name = 'Subscription'
@@ -220,26 +222,26 @@ class Subscription(UUIDTimestampedModel):
                 name='one_active_subscription_per_user'
             ),
         ]
-    
+
     def __str__(self):
         return f"{self.user.username} - {self.tier} ({self.status})"
-    
+
     def save(self, *args, **kwargs):
         """Override save to set default expiration."""
         if not self.expires_at:
             # Default to 30 days from start
             self.expires_at = self.starts_at + timedelta(days=30)
-        
+
         super().save(*args, **kwargs)
-    
+
     def clean(self):
         """Validate subscription data."""
         if self.expires_at and self.starts_at and self.expires_at <= self.starts_at:
             raise ValidationError("Expiration date must be after start date")
-        
+
         if self.requests_per_day < self.requests_per_hour:
             raise ValidationError("Daily limit cannot be less than hourly limit")
-    
+
     @property
     def is_active(self) -> bool:
         """Check if subscription is active and not expired."""
@@ -247,12 +249,12 @@ class Subscription(UUIDTimestampedModel):
             self.status == self.SubscriptionStatus.ACTIVE and
             self.expires_at > timezone.now()
         )
-    
+
     @property
     def is_expired(self) -> bool:
         """Check if subscription is expired."""
         return timezone.now() > self.expires_at
-    
+
     @property
     def days_remaining(self) -> int:
         """Get days remaining until expiration."""
@@ -260,19 +262,19 @@ class Subscription(UUIDTimestampedModel):
             return 0
         delta = self.expires_at - timezone.now()
         return max(0, delta.days)
-    
+
     @property
     def usage_percentage(self) -> float:
         """Get usage percentage for current period."""
         # This would need to be calculated based on actual usage tracking
         # For now, return 0.0 as placeholder
         return 0.0
-    
+
     @property
     def tier_display(self) -> str:
         """Get display name for tier."""
         return self.get_tier_display()
-    
+
     @property
     def status_color(self) -> str:
         """Get color for status display."""
@@ -284,42 +286,42 @@ class Subscription(UUIDTimestampedModel):
             self.SubscriptionStatus.EXPIRED: 'danger',
         }
         return colors.get(self.status, 'secondary')
-    
+
     def activate(self):
         """Activate subscription (delegates to manager)."""
         return self.__class__.objects.activate_subscription(self)
-    
+
     def suspend(self, reason=None):
         """Suspend subscription (delegates to manager)."""
         return self.__class__.objects.suspend_subscription(self, reason)
-    
+
     def cancel(self, reason=None):
         """Cancel subscription (delegates to manager)."""
         return self.__class__.objects.cancel_subscription(self, reason)
-    
+
     def renew(self, duration_days: int = 30):
         """Renew subscription (delegates to manager)."""
         return self.__class__.objects.renew_subscription(self, duration_days)
-    
+
     def has_access_to_endpoint_group(self, endpoint_group_code: str) -> bool:
         """Check if subscription has access to specific endpoint group."""
         if not self.is_active:
             return False
-        
+
         return self.endpoint_groups.filter(
             code=endpoint_group_code,
             is_enabled=True
         ).exists()
-    
+
     def increment_usage(self):
         """Increment usage counter (delegates to manager)."""
         return self.__class__.objects.increment_subscription_usage(self)
-    
+
     @classmethod
     def get_active_for_user(cls, user: User) -> 'Subscription':
         """Get active subscription for user (delegates to manager)."""
         return cls.objects.get_active_for_user(user)
-    
+
     @classmethod
     def create_free_subscription(cls, user: User) -> 'Subscription':
         """Create free tier subscription for user (delegates to manager)."""

django_cfg/apps/payments/models/tariffs.py

@@ -4,9 +4,10 @@ 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, MaxValueValidator
 from django.core.exceptions import ValidationError
+from django.core.validators import MaxValueValidator, MinValueValidator
+from django.db import models
+
 from .base import TimestampedModel
 from .subscriptions import EndpointGroup
 
@@ -17,90 +18,90 @@ class Tariff(TimestampedModel):
     
     Defines pricing and limits for different subscription levels.
     """
-    
+
     name = models.CharField(
         max_length=100,
         unique=True,
         help_text="Tariff name (e.g., 'Free', 'Basic', 'Pro')"
     )
-    
+
     code = models.CharField(
         max_length=50,
         unique=True,
         help_text="Tariff code (e.g., 'free', 'basic', 'pro')"
     )
-    
+
     description = models.TextField(
         blank=True,
         help_text="Detailed description of what this tariff includes"
     )
-    
+
     # Pricing
     monthly_price_usd = models.FloatField(
         validators=[MinValueValidator(0.0)],
         help_text="Monthly price in USD"
     )
-    
+
     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,
         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"
     )
-    
+
     # Availability
     is_active = models.BooleanField(
         default=True,
         help_text="Whether this tariff is available for new subscriptions"
     )
-    
+
     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 = 'payments_tariffs'
         verbose_name = 'Tariff'
@@ -110,48 +111,48 @@ class Tariff(TimestampedModel):
             models.Index(fields=['is_active', 'is_public']),
             models.Index(fields=['sort_order']),
         ]
-    
+
     def __str__(self):
         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_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."""
@@ -168,41 +169,41 @@ class TariffEndpointGroup(TimestampedModel):
     
     Defines which API endpoints are available for each tariff.
     """
-    
+
     tariff = models.ForeignKey(
         Tariff,
         on_delete=models.CASCADE,
         related_name='endpoint_groups'
     )
-    
+
     endpoint_group = models.ForeignKey(
         EndpointGroup,
         on_delete=models.CASCADE,
         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="Whether this endpoint group is enabled for this tariff"
     )
-    
+
     class Meta:
         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)."""