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

django_cfg/apps/payments/models/payments.py

@@ -0,0 +1,301 @@
+"""
+Payment models for the universal payments system.
+"""
+
+from django.db import models
+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
+
+User = get_user_model()
+
+
+
+class UniversalPayment(TimestampedModel):
+    """Universal payment model for all providers."""
+    
+    class PaymentStatus(models.TextChoices):
+        PENDING = "pending", "Pending"
+        CONFIRMING = "confirming", "Confirming"
+        CONFIRMED = "confirmed", "Confirmed"
+        COMPLETED = "completed", "Completed"
+        FAILED = "failed", "Failed"
+        EXPIRED = "expired", "Expired"
+        CANCELLED = "cancelled", "Cancelled"
+        REFUNDED = "refunded", "Refunded"
+    
+    class PaymentProvider(models.TextChoices):
+        NOWPAYMENTS = "nowpayments", "NowPayments"
+        STRIPE = "stripe", "Stripe"
+        INTERNAL = "internal", "Internal"
+    
+    user = models.ForeignKey(
+        User,
+        on_delete=models.CASCADE,
+        related_name='universal_payments',
+        help_text="User who initiated this payment"
+    )
+    
+    # Financial data
+    amount_usd = models.FloatField(
+        validators=[MinValueValidator(1.0)],
+        help_text="Payment amount in USD"
+    )
+    currency_code = models.CharField(
+        max_length=10,
+        help_text="Currency used for payment"
+    )
+    
+    # Actual received amount (may differ from requested)
+    actual_amount_usd = models.FloatField(
+        null=True,
+        blank=True,
+        help_text="Actual received amount in USD"
+    )
+    actual_currency_code = models.CharField(
+        max_length=10,
+        null=True,
+        blank=True,
+        help_text="Actual received currency"
+    )
+    
+    # Fee information
+    fee_amount_usd = models.FloatField(
+        null=True,
+        blank=True,
+        validators=[MinValueValidator(0.0)],
+        help_text="Fee amount in USD"
+    )
+    
+    # Payment details
+    provider = models.CharField(
+        max_length=50,
+        choices=PaymentProvider.choices,
+        help_text="Payment provider"
+    )
+    status = models.CharField(
+        max_length=20,
+        choices=PaymentStatus.choices,
+        default=PaymentStatus.PENDING,
+        help_text="Payment status"
+    )
+    
+    # Provider-specific fields
+    provider_payment_id = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        unique=True,
+        help_text="Provider's payment ID"
+    )
+    internal_payment_id = models.CharField(
+        max_length=100,
+        unique=True,
+        help_text="Internal payment identifier"
+    )
+    
+    # Crypto payment specific
+    pay_address = models.CharField(
+        max_length=200,
+        null=True,
+        blank=True,
+        help_text="Cryptocurrency payment address"
+    )
+    pay_amount = models.FloatField(
+        null=True,
+        blank=True,
+        help_text="Amount to pay in cryptocurrency"
+    )
+    network = models.CharField(
+        max_length=50,
+        null=True,
+        blank=True,
+        help_text="Blockchain network (mainnet, testnet, etc.)"
+    )
+    
+    # Metadata
+    description = models.TextField(
+        blank=True,
+        help_text="Payment description"
+    )
+    order_id = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        help_text="Order reference ID"
+    )
+    metadata = models.JSONField(
+        default=dict,
+        help_text="Additional metadata"
+    )
+    
+    # Provider webhook data
+    webhook_data = models.JSONField(
+        null=True,
+        blank=True,
+        help_text="Raw webhook data from provider"
+    )
+    
+    # Timestamps
+    expires_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Payment expiration time"
+    )
+    completed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Payment completion time"
+    )
+    processed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="When the payment was processed and funds added to balance"
+    )
+
+    # Import and assign manager
+    from ..managers import UniversalPaymentManager
+    objects = UniversalPaymentManager()
+
+    class Meta:
+        db_table = 'universal_payments'
+        verbose_name = "Universal Payment"
+        verbose_name_plural = "Universal Payments"
+        indexes = [
+            models.Index(fields=['user', 'status']),
+            models.Index(fields=['provider_payment_id']),
+            models.Index(fields=['internal_payment_id']),
+            models.Index(fields=['status']),
+            models.Index(fields=['provider']),
+            models.Index(fields=['currency_code']),
+            models.Index(fields=['created_at']),
+            models.Index(fields=['processed_at']),
+        ]
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f"{self.user.email} - ${self.amount_usd} ({self.currency_code}) - {self.get_status_display()}"
+
+    @property
+    def is_pending(self) -> bool:
+        """Check if payment is still pending."""
+        return self.status in [
+            self.PaymentStatus.PENDING,
+            self.PaymentStatus.CONFIRMING,
+            self.PaymentStatus.CONFIRMED
+        ]
+
+    @property
+    def is_completed(self) -> bool:
+        """Check if payment is completed."""
+        return self.status == self.PaymentStatus.COMPLETED
+
+    @property
+    def is_failed(self) -> bool:
+        """Check if payment failed."""
+        return self.status in [self.PaymentStatus.FAILED, self.PaymentStatus.EXPIRED]
+
+    @property
+    def needs_processing(self) -> bool:
+        """Check if payment needs to be processed (completed but not processed)."""
+        return self.is_completed and not self.processed_at
+
+    @property
+    def is_crypto_payment(self) -> bool:
+        """Check if this is a cryptocurrency payment."""
+        return self.provider == self.PaymentProvider.NOWPAYMENTS
+
+    def get_payment_url(self) -> str:
+        """Get payment URL for QR code or direct payment."""
+        if self.pay_address and self.pay_amount:
+            return f"{self.currency_code.lower()}:{self.pay_address}?amount={self.pay_amount}"
+        return ""
+
+    def get_qr_code_url(self, size: int = 200) -> str:
+        """Get QR code URL for payment."""
+        payment_url = self.get_payment_url()
+        if payment_url:
+            return f"https://api.qrserver.com/v1/create-qr-code/?size={size}x{size}&data={payment_url}"
+        return ""
+
+    def mark_as_processed(self):
+        """Mark payment as processed."""
+        if not self.processed_at:
+            self.processed_at = timezone.now()
+            self.save(update_fields=['processed_at'])
+
+    def update_from_webhook(self, webhook_data: dict):
+        """Update payment from provider webhook data."""
+        self.webhook_data = webhook_data
+        
+        # Update status if provided
+        if 'payment_status' in webhook_data:
+            self.status = webhook_data['payment_status']
+        
+        # Update payment details if provided
+        if 'pay_address' in webhook_data:
+            self.pay_address = webhook_data['pay_address']
+        
+        if 'pay_amount' in webhook_data:
+            self.pay_amount = float(str(webhook_data['pay_amount']))
+        
+        if 'payment_id' in webhook_data:
+            self.provider_payment_id = webhook_data['payment_id']
+        
+        self.save()
+
+    def can_be_refunded(self) -> bool:
+        """Check if payment can be refunded."""
+        return self.is_completed and self.processed_at
+
+    def get_currency_display_name(self) -> str:
+        """Get human-readable currency name."""
+        # This could be enhanced to lookup from Currency model
+        currency_names = {
+            'BTC': 'Bitcoin',
+            'ETH': 'Ethereum',
+            'USD': 'US Dollar',
+            'EUR': 'Euro',
+        }
+        return currency_names.get(self.currency_code, self.currency_code)
+
+    def get_status_color(self) -> str:
+        """Get color for status display."""
+        status_colors = {
+            self.PaymentStatus.PENDING: '#6c757d',
+            self.PaymentStatus.CONFIRMING: '#fd7e14',
+            self.PaymentStatus.CONFIRMED: '#20c997',
+            self.PaymentStatus.COMPLETED: '#198754',
+            self.PaymentStatus.FAILED: '#dc3545',
+            self.PaymentStatus.REFUNDED: '#6f42c1',
+            self.PaymentStatus.EXPIRED: '#dc3545',
+            self.PaymentStatus.CANCELLED: '#6c757d'
+        }
+        return status_colors.get(self.status, '#6c757d')
+
+    def clean(self):
+        """Validate payment data."""
+        
+        # Validate minimum amount
+        if self.amount_usd < 1.0:
+            raise ValidationError("Minimum payment amount is $1.00")
+        
+        # Validate crypto address for crypto payments
+        if self.is_crypto_payment and self.status != self.PaymentStatus.PENDING:
+            if not self.pay_address:
+                raise ValidationError("Payment address is required for crypto payments")
+
+    def save(self, *args, **kwargs):
+        """Override save to run validation."""
+        if self.currency_code:
+            self.currency_code = self.currency_code.upper()
+        
+        # Generate internal payment ID if not set
+        if not self.internal_payment_id:
+            import uuid
+            self.internal_payment_id = f"pay_{str(uuid.uuid4())[:8]}"
+        
+        self.clean()
+        super().save(*args, **kwargs)

django_cfg/apps/payments/models/subscriptions.py

@@ -0,0 +1,270 @@
+"""
+Subscription models for the universal payments system.
+"""
+
+from django.db import models
+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
+
+User = get_user_model()
+
+
+class EndpointGroup(TimestampedModel):
+    """API endpoint groups for subscription management."""
+    
+    name = models.CharField(
+        max_length=100,
+        unique=True,
+        help_text="Endpoint group name"
+    )
+    display_name = models.CharField(
+        max_length=200,
+        help_text="Human-readable name"
+    )
+    description = models.TextField(
+        blank=True,
+        help_text="Group description"
+    )
+    
+    # Pricing tiers
+    basic_price = models.FloatField(
+        default=0.0,
+        validators=[MinValueValidator(0.0)],
+        help_text="Basic tier monthly price"
+    )
+    premium_price = models.FloatField(
+        default=0.0,
+        validators=[MinValueValidator(0.0)],
+        help_text="Premium tier monthly price"
+    )
+    enterprise_price = models.FloatField(
+        default=0.0,
+        validators=[MinValueValidator(0.0)],
+        help_text="Enterprise tier monthly price"
+    )
+    
+    # Usage limits per tier
+    basic_limit = models.PositiveIntegerField(
+        default=1000,
+        help_text="Basic tier monthly usage limit"
+    )
+    premium_limit = models.PositiveIntegerField(
+        default=10000,
+        help_text="Premium tier monthly usage limit"
+    )
+    enterprise_limit = models.PositiveIntegerField(
+        default=0,  # 0 = unlimited
+        help_text="Enterprise tier monthly usage limit (0 = unlimited)"
+    )
+    
+    # Settings
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Is this endpoint group active"
+    )
+    require_api_key = models.BooleanField(
+        default=True,
+        help_text="Require API key for access"
+    )
+    
+    # Import and assign manager
+    from ..managers import EndpointGroupManager
+    objects = EndpointGroupManager()
+    
+    class Meta:
+        db_table = 'endpoint_groups'
+        verbose_name = "Endpoint Group"
+        verbose_name_plural = "Endpoint Groups"
+        indexes = [
+            models.Index(fields=['name']),
+            models.Index(fields=['is_active']),
+        ]
+        ordering = ['name']
+    
+    def __str__(self):
+        return self.display_name
+    
+    def get_price_for_tier(self, tier: str) -> float:
+        """Get price for specific tier."""
+        tier_prices = {
+            'basic': self.basic_price,
+            'premium': self.premium_price,
+            'enterprise': self.enterprise_price,
+        }
+        return tier_prices.get(tier, 0.0)
+    
+    def get_limit_for_tier(self, tier: str) -> int:
+        """Get usage limit for specific tier."""
+        tier_limits = {
+            'basic': self.basic_limit,
+            'premium': self.premium_limit,
+            'enterprise': self.enterprise_limit,
+        }
+        return tier_limits.get(tier, 0)
+
+
+class Subscription(TimestampedModel):
+    """User subscriptions to endpoint groups."""
+    
+    class SubscriptionStatus(models.TextChoices):
+        ACTIVE = "active", "Active"
+        INACTIVE = "inactive", "Inactive"
+        EXPIRED = "expired", "Expired"
+        CANCELLED = "cancelled", "Cancelled"
+        SUSPENDED = "suspended", "Suspended"
+    
+    class SubscriptionTier(models.TextChoices):
+        BASIC = "basic", "Basic"
+        PREMIUM = "premium", "Premium"
+        ENTERPRISE = "enterprise", "Enterprise"
+    
+    user = models.ForeignKey(
+        User,
+        on_delete=models.CASCADE,
+        related_name='subscriptions',
+        help_text="Subscriber"
+    )
+    endpoint_group = models.ForeignKey(
+        EndpointGroup,
+        on_delete=models.CASCADE,
+        related_name='subscriptions',
+        help_text="Endpoint group"
+    )
+    
+    # Subscription details
+    tier = models.CharField(
+        max_length=20,
+        choices=SubscriptionTier.choices,
+        default=SubscriptionTier.BASIC,
+        help_text="Subscription tier"
+    )
+    status = models.CharField(
+        max_length=20,
+        choices=SubscriptionStatus.choices,
+        default=SubscriptionStatus.ACTIVE,
+        help_text="Subscription status"
+    )
+    
+    # Pricing
+    monthly_price = models.FloatField(
+        validators=[MinValueValidator(0.0)],
+        help_text="Monthly subscription price"
+    )
+    
+    # Usage tracking
+    usage_limit = models.PositiveIntegerField(
+        default=1000,
+        help_text="Monthly usage limit (0 = unlimited)"
+    )
+    usage_current = models.PositiveIntegerField(
+        default=0,
+        help_text="Current month usage"
+    )
+    
+    # Billing
+    last_billed = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Last billing date"
+    )
+    next_billing = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Next billing date"
+    )
+    
+    # Lifecycle
+    expires_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Subscription expiration"
+    )
+    cancelled_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Cancellation date"
+    )
+    
+    # Metadata
+    metadata = models.JSONField(
+        default=dict,
+        help_text="Additional subscription metadata"
+    )
+    
+    # Import and assign manager
+    from ..managers import SubscriptionManager
+    objects = SubscriptionManager()
+    
+    class Meta:
+        db_table = 'user_subscriptions'
+        verbose_name = "Subscription"
+        verbose_name_plural = "Subscriptions"
+        indexes = [
+            models.Index(fields=['user', 'status']),
+            models.Index(fields=['endpoint_group', 'status']),
+            models.Index(fields=['status', 'expires_at']),
+            models.Index(fields=['next_billing']),
+            models.Index(fields=['created_at']),
+        ]
+        unique_together = [['user', 'endpoint_group']]  # One subscription per user per group
+        ordering = ['-created_at']
+    
+    def __str__(self):
+        return f"{self.user.email} - {self.endpoint_group.name} ({self.tier})"
+    
+    def is_active(self) -> bool:
+        """Check if subscription is currently active."""
+        now = timezone.now()
+        
+        return (
+            self.status == self.SubscriptionStatus.ACTIVE and
+            (self.expires_at is None or self.expires_at > now)
+        )
+    
+    def is_usage_exceeded(self) -> bool:
+        """Check if usage limit is exceeded."""
+        return self.usage_limit > 0 and self.usage_current >= self.usage_limit
+    
+    def get_usage_percentage(self) -> float:
+        """Get usage as percentage (0-100)."""
+        if self.usage_limit == 0:
+            return 0.0  # Unlimited
+        
+        return min((self.usage_current / self.usage_limit) * 100, 100.0)
+    
+    def can_use_api(self) -> bool:
+        """Check if user can use API (active and not exceeded)."""
+        return self.is_active() and not self.is_usage_exceeded()
+    
+    def increment_usage(self, count: int = 1):
+        """Increment usage counter."""
+        self.usage_current += count
+        self.save(update_fields=['usage_current'])
+    
+    def reset_usage(self):
+        """Reset usage counter (for new billing period)."""
+        self.usage_current = 0
+        self.save(update_fields=['usage_current'])
+    
+    def cancel(self):
+        """Cancel subscription."""
+        self.status = self.SubscriptionStatus.CANCELLED
+        self.cancelled_at = timezone.now()
+        self.save(update_fields=['status', 'cancelled_at'])
+    
+    def extend_billing_period(self):
+        """Extend billing period by one month."""
+        if self.next_billing:
+            self.next_billing += timedelta(days=30)
+        else:
+            self.next_billing = timezone.now() + timedelta(days=30)
+        
+        if self.expires_at:
+            self.expires_at += timedelta(days=30)
+        else:
+            self.expires_at = timezone.now() + timedelta(days=30)
+        
+        self.save(update_fields=['next_billing', 'expires_at'])

django_cfg/apps/payments/models/tariffs.py

@@ -0,0 +1,102 @@
+"""
+Tariff models for the universal payments system.
+"""
+
+from django.db import models
+from django.core.validators import MinValueValidator
+from .base import TimestampedModel
+
+
+class Tariff(TimestampedModel):
+    """Simple tariff plans for API access."""
+    
+    name = models.CharField(
+        max_length=100,
+        unique=True,
+        help_text="Tariff name"
+    )
+    display_name = models.CharField(
+        max_length=200,
+        help_text="Human-readable tariff name"
+    )
+    description = models.TextField(
+        blank=True,
+        help_text="Tariff description"
+    )
+    
+    # Pricing
+    monthly_price = models.FloatField(
+        default=0.0,
+        validators=[MinValueValidator(0.0)],
+        help_text="Monthly price in USD"
+    )
+    
+    # Limits
+    request_limit = models.PositiveIntegerField(
+        default=1000,
+        help_text="Monthly request limit (0 = unlimited)"
+    )
+    
+    # Settings
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Is this tariff active"
+    )
+    
+    # Import and assign manager
+    from ..managers import TariffManager
+    objects = TariffManager()
+    
+    class Meta:
+        db_table = 'tariffs'
+        verbose_name = "Tariff"
+        verbose_name_plural = "Tariffs"
+        indexes = [
+            models.Index(fields=['is_active']),
+            models.Index(fields=['monthly_price']),
+        ]
+        ordering = ['monthly_price']
+    
+    def __str__(self):
+        return f"{self.display_name} (${self.monthly_price}/month)"
+    
+    @property
+    def is_free(self) -> bool:
+        """Check if this is a free tariff."""
+        return self.monthly_price == 0
+
+
+class TariffEndpointGroup(TimestampedModel):
+    """Simple association between tariffs and endpoint groups."""
+    
+    tariff = models.ForeignKey(
+        Tariff,
+        on_delete=models.CASCADE,
+        related_name='endpoint_groups',
+        help_text="Tariff plan"
+    )
+    from .subscriptions import EndpointGroup
+    endpoint_group = models.ForeignKey(
+        EndpointGroup,
+        on_delete=models.CASCADE,
+        related_name='tariffs',
+        help_text="Endpoint group"
+    )
+    
+    is_enabled = models.BooleanField(
+        default=True,
+        help_text="Is this endpoint group 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"
+        unique_together = [['tariff', 'endpoint_group']]
+    
+    def __str__(self):
+        return f"{self.tariff.name} - {self.endpoint_group.name}"