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

django_cfg/apps/payments/models/base.py

@@ -1,30 +1,83 @@
 """
-Base model classes for the universal payments system.
+Base models for the Universal Payment System v2.0.
+
+Provides common functionality for all payment-related models.
 """
 
 import uuid
 from django.db import models
-
-
-class TimestampedModel(models.Model):
-    """Base model with automatic timestamps."""
-    created_at = models.DateTimeField(auto_now_add=True, db_index=True)
-    updated_at = models.DateTimeField(auto_now=True)
-    
-    class Meta:
-        abstract = True
+from django.utils import timezone
 
 
 class UUIDTimestampedModel(models.Model):
-    """Base model with UUID primary key and automatic timestamps."""
+    """
+    Abstract base model with UUID primary key and timestamps.
+    
+    Provides:
+    - UUID primary key for security and scalability
+    - Created/updated timestamps with timezone awareness
+    - Common functionality for all payment models
+    """
+    
     id = models.UUIDField(
         primary_key=True,
         default=uuid.uuid4,
         editable=False,
-        help_text="Unique identifier"
+        help_text="Unique identifier for this record"
+    )
+    
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+        db_index=True,
+        help_text="When this record was created"
+    )
+    
+    updated_at = models.DateTimeField(
+        auto_now=True,
+        help_text="When this record was last updated"
     )
-    created_at = models.DateTimeField(auto_now_add=True, db_index=True)
-    updated_at = models.DateTimeField(auto_now=True)
     
     class Meta:
-        abstract = True
+        abstract = True
+        ordering = ['-created_at']
+    
+    def __str__(self):
+        """String representation showing ID and creation time."""
+        return f"{self.__class__.__name__}({str(self.id)[:8]}...)"
+    
+    def __repr__(self):
+        """Developer-friendly representation."""
+        return f"<{self.__class__.__name__}: {str(self.id)}>"
+    
+    @property
+    def age_in_seconds(self) -> int:
+        """Get age of this record in seconds."""
+        return int((timezone.now() - self.created_at).total_seconds())
+    
+    @property
+    def is_recent(self) -> bool:
+        """Check if record was created in the last hour."""
+        return self.age_in_seconds < 3600
+
+
+class TimestampedModel(models.Model):
+    """
+    Abstract base model with auto-incrementing ID and timestamps.
+    
+    Use this for models that don't need UUID (like configuration models).
+    """
+    
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+        db_index=True,
+        help_text="When this record was created"
+    )
+    
+    updated_at = models.DateTimeField(
+        auto_now=True,
+        help_text="When this record was last updated"
+    )
+    
+    class Meta:
+        abstract = True
+        ordering = ['-created_at']

django_cfg/apps/payments/models/currencies.py

@@ -1,13 +1,21 @@
 """
-Currency models for the universal payments system.
+Currency models for the Universal Payment System v2.0.
+
+Handles multi-provider currency support with integration to django_currency module.
 """
 
 from django.db import models
+from django.core.validators import MinLengthValidator, MaxLengthValidator
+from django.core.exceptions import ValidationError
 from .base import TimestampedModel
 
 
 class Currency(TimestampedModel):
-    """Supported currencies for payments."""
+    """
+    Universal currency model supporting both fiat and crypto.
+    
+    Integrates with django_currency module for rate conversion.
+    """
     
     class CurrencyType(models.TextChoices):
         FIAT = "fiat", "Fiat Currency"
@@ -16,123 +24,255 @@ class Currency(TimestampedModel):
     code = models.CharField(
         max_length=10,
         unique=True,
-        help_text="Currency code (e.g., USD, BTC, ETH)"
+        validators=[MinLengthValidator(3), MaxLengthValidator(10)],
+        help_text="Currency code (e.g., BTC, USD, ETH)"
     )
+    
     name = models.CharField(
         max_length=100,
-        help_text="Full currency name"
-    )
-    symbol = models.CharField(
-        max_length=10,
-        help_text="Currency symbol (e.g., $, ₿, Ξ)"
+        help_text="Full currency name (e.g., Bitcoin, US Dollar)"
     )
+    
     currency_type = models.CharField(
         max_length=10,
         choices=CurrencyType.choices,
         help_text="Type of currency"
     )
+    
+    symbol = models.CharField(
+        max_length=10,
+        blank=True,
+        help_text="Currency symbol (e.g., $, ₿, Ξ)"
+    )
+    
     decimal_places = models.PositiveSmallIntegerField(
-        default=2,
+        default=8,
         help_text="Number of decimal places for this currency"
     )
+    
     is_active = models.BooleanField(
         default=True,
-        help_text="Whether this currency is active for payments"
-    )
-    min_payment_amount = models.FloatField(
-        default=1.0,
-        help_text="Minimum payment amount for this currency"
+        help_text="Whether this currency is available for payments"
     )
     
-    # Exchange rate to USD (base currency)
-    usd_rate = models.FloatField(
-        default=1.0,
-        help_text="Exchange rate to USD (1 unit of this currency = X USD)"
-    )
-    rate_updated_at = models.DateTimeField(
-        null=True,
+    # Integration with django_currency
+    exchange_rate_source = models.CharField(
+        max_length=50,
         blank=True,
-        help_text="When the exchange rate was last updated"
+        help_text="Source for exchange rates (auto-detected by django_currency)"
     )
     
-    # Import and assign manager
-    from ..managers import CurrencyManager
+    # Manager
+    from .managers.currency_managers import CurrencyManager
     objects = CurrencyManager()
     
     class Meta:
-        db_table = 'payment_currencies'
-        verbose_name = "Currency"
-        verbose_name_plural = "Currencies"
+        db_table = 'payments_currencies'
+        verbose_name = 'Currency'
+        verbose_name_plural = 'Currencies'
+        ordering = ['currency_type', 'code']
         indexes = [
+            models.Index(fields=['currency_type', 'is_active']),
             models.Index(fields=['code']),
-            models.Index(fields=['currency_type']),
-            models.Index(fields=['is_active']),
         ]
-        ordering = ['code']
     
     def __str__(self):
-        return f"{self.code} - {self.name}"
+        return f"{self.code} ({self.name})"
     
-    @property
-    def is_fiat(self) -> bool:
-        """Check if this is a fiat currency."""
-        return self.currency_type == self.CurrencyType.FIAT
+    def clean(self):
+        """Validate currency data."""
+        if self.code:
+            self.code = self.code.upper()
+        
+        # Validate decimal places based on currency type
+        if self.currency_type == self.CurrencyType.FIAT and self.decimal_places > 4:
+            raise ValidationError("Fiat currencies should not have more than 4 decimal places")
+        
+        if self.currency_type == self.CurrencyType.CRYPTO and self.decimal_places > 18:
+            raise ValidationError("Crypto currencies should not have more than 18 decimal places")
     
     @property
     def is_crypto(self) -> bool:
         """Check if this is a cryptocurrency."""
         return self.currency_type == self.CurrencyType.CRYPTO
     
-    def to_usd(self, amount: float) -> float:
-        """Convert amount of this currency to USD."""
-        return amount * self.usd_rate
+    @property
+    def is_fiat(self) -> bool:
+        """Check if this is a fiat currency."""
+        return self.currency_type == self.CurrencyType.FIAT
+
+
+class Network(TimestampedModel):
+    """
+    Blockchain network model for cryptocurrency payments.
+    
+    Represents different networks like Ethereum, Bitcoin, Polygon, etc.
+    """
+    
+    name = models.CharField(
+        max_length=50,
+        unique=True,
+        help_text="Network name (e.g., Ethereum, Bitcoin, Polygon)"
+    )
+    
+    code = models.CharField(
+        max_length=20,
+        unique=True,
+        help_text="Network code (e.g., ETH, BTC, MATIC)"
+    )
+    
+    native_currency = models.ForeignKey(
+        Currency,
+        on_delete=models.PROTECT,
+        related_name='native_networks',
+        help_text="Native currency of this network"
+    )
+    
+    block_explorer_url = models.URLField(
+        blank=True,
+        help_text="Block explorer URL template (use {tx} for transaction hash)"
+    )
     
-    def from_usd(self, usd_amount: float) -> float:
-        """Convert USD amount to this currency."""
-        if self.usd_rate == 0:
-            return 0
-        return usd_amount / self.usd_rate
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Whether this network is available for payments"
+    )
+    
+    # Network-specific settings
+    confirmation_blocks = models.PositiveIntegerField(
+        default=1,
+        help_text="Number of confirmations required for this network"
+    )
+    
+    average_block_time = models.PositiveIntegerField(
+        default=600,  # 10 minutes in seconds
+        help_text="Average block time in seconds"
+    )
+    
+    class Meta:
+        db_table = 'payments_networks'
+        verbose_name = 'Network'
+        verbose_name_plural = 'Networks'
+        ordering = ['name']
+        indexes = [
+            models.Index(fields=['is_active']),
+            models.Index(fields=['code']),
+        ]
+    
+    def __str__(self):
+        return f"{self.name} ({self.code})"
+    
+    def clean(self):
+        """Validate network data."""
+        if self.code:
+            self.code = self.code.upper()
+    
+    @property
+    def estimated_confirmation_time(self) -> int:
+        """Estimated time for confirmations in seconds."""
+        return self.confirmation_blocks * self.average_block_time
 
 
-class CurrencyNetwork(TimestampedModel):
-    """Networks/blockchains for cryptocurrencies."""
+class ProviderCurrency(TimestampedModel):
+    """
+    Provider-specific currency configuration.
+    
+    Maps currencies to specific providers and networks.
+    """
+    
+    provider = models.CharField(
+        max_length=50,
+        help_text="Payment provider name (e.g., nowpayments)"
+    )
     
     currency = models.ForeignKey(
         Currency,
         on_delete=models.CASCADE,
-        related_name='networks',
-        help_text="Currency this network supports"
+        related_name='provider_configs'
     )
-    network_name = models.CharField(
-        max_length=50,
-        help_text="Network name (e.g., mainnet, polygon, bsc)"
+    
+    network = models.ForeignKey(
+        Network,
+        on_delete=models.CASCADE,
+        related_name='provider_configs',
+        null=True,
+        blank=True,
+        help_text="Network for crypto currencies (null for fiat)"
     )
-    network_code = models.CharField(
+    
+    # Provider-specific settings
+    provider_currency_code = models.CharField(
         max_length=20,
-        help_text="Network code for API integration"
+        help_text="Currency code as used by the provider"
     )
-    is_active = models.BooleanField(
+    
+    min_amount = models.DecimalField(
+        max_digits=20,
+        decimal_places=8,
+        null=True,
+        blank=True,
+        help_text="Minimum payment amount for this currency"
+    )
+    
+    max_amount = models.DecimalField(
+        max_digits=20,
+        decimal_places=8,
+        null=True,
+        blank=True,
+        help_text="Maximum payment amount for this currency"
+    )
+    
+    is_enabled = models.BooleanField(
         default=True,
-        help_text="Whether this network is active"
+        help_text="Whether this currency is enabled for this provider"
     )
-    confirmation_blocks = models.PositiveIntegerField(
-        default=1,
-        help_text="Number of confirmations required"
+    
+    # Fee configuration
+    fee_percentage = models.DecimalField(
+        max_digits=5,
+        decimal_places=4,
+        default=0,
+        help_text="Fee percentage (0.0250 = 2.5%)"
     )
     
-    # Import and assign manager
-    from ..managers import CurrencyNetworkManager
-    objects = CurrencyNetworkManager()
+    fixed_fee = models.DecimalField(
+        max_digits=20,
+        decimal_places=8,
+        default=0,
+        help_text="Fixed fee amount in this currency"
+    )
     
     class Meta:
-        db_table = 'payment_currency_networks'
-        verbose_name = "Currency Network"
-        verbose_name_plural = "Currency Networks"
-        unique_together = [['currency', 'network_code']]
+        db_table = 'payments_provider_currencies'
+        verbose_name = 'Provider Currency'
+        verbose_name_plural = 'Provider Currencies'
+        unique_together = [['provider', 'currency', 'network']]
+        ordering = ['provider', 'currency__code']
         indexes = [
-            models.Index(fields=['currency', 'is_active']),
-            models.Index(fields=['network_code']),
+            models.Index(fields=['provider', 'is_enabled']),
+            models.Index(fields=['currency', 'is_enabled']),
         ]
     
     def __str__(self):
-        return f"{self.currency.code} - {self.network_name}"
+        network_part = f" ({self.network.code})" if self.network else ""
+        return f"{self.provider}: {self.currency.code}{network_part}"
+    
+    def clean(self):
+        """Validate provider currency configuration."""
+        # Crypto currencies must have a network
+        if self.currency and self.currency.is_crypto and not self.network:
+            raise ValidationError("Crypto currencies must specify a network")
+        
+        # Fiat currencies should not have a network
+        if self.currency and self.currency.is_fiat and self.network:
+            raise ValidationError("Fiat currencies should not specify a network")
+        
+        # Validate amount limits
+        if self.min_amount and self.max_amount and self.min_amount > self.max_amount:
+            raise ValidationError("Minimum amount cannot be greater than maximum amount")
+    
+    @property
+    def display_name(self) -> str:
+        """Human-readable display name."""
+        network_part = f" on {self.network.name}" if self.network else ""
+        return f"{self.currency.name}{network_part}"

django_cfg/apps/payments/models/managers/__init__.py

@@ -0,0 +1,44 @@
+"""
+Django ORM Managers for the Universal Payment System v2.0.
+
+Optimized managers and querysets for all payment-related models.
+Follows the data typing requirements: Django ORM for database layer.
+"""
+
+# Payment managers
+from .payment_managers import PaymentQuerySet, PaymentManager
+
+# Balance managers  
+from .balance_managers import UserBalanceManager, TransactionQuerySet, TransactionManager
+
+# Subscription managers
+from .subscription_managers import SubscriptionQuerySet, SubscriptionManager
+
+# Currency managers
+from .currency_managers import CurrencyQuerySet, CurrencyManager
+
+# API Key managers
+from .api_key_managers import APIKeyQuerySet, APIKeyManager
+
+__all__ = [
+    # Payment managers
+    'PaymentQuerySet',
+    'PaymentManager',
+    
+    # Balance managers
+    'UserBalanceManager',
+    'TransactionQuerySet', 
+    'TransactionManager',
+    
+    # Subscription managers
+    'SubscriptionQuerySet',
+    'SubscriptionManager',
+    
+    # Currency managers
+    'CurrencyQuerySet',
+    'CurrencyManager',
+    
+    # API Key managers
+    'APIKeyQuerySet',
+    'APIKeyManager',
+]