django-cfg 1.2.31__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,254 +1,278 @@
 """
-Currency models for the universal payments system - KISS version.
+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
 
-# Currency converter import moved inside methods to avoid circular imports
 
 class Currency(TimestampedModel):
-    """Base currencies - clean, no provider-specific codes."""
+    """
+    Universal currency model supporting both fiat and crypto.
+    
+    Integrates with django_currency module for rate conversion.
+    """
     
     class CurrencyType(models.TextChoices):
         FIAT = "fiat", "Fiat Currency"
         CRYPTO = "crypto", "Cryptocurrency"
     
-    # Core fields - only essentials
     code = models.CharField(
         max_length=10,
         unique=True,
-        help_text="Clean currency code: BTC, USDT, ETH, USD (NO network suffixes)"
+        validators=[MinLengthValidator(3), MaxLengthValidator(10)],
+        help_text="Currency code (e.g., BTC, USD, ETH)"
     )
+    
     name = models.CharField(
         max_length=100,
-        help_text="Currency name: Bitcoin, Tether USD, Ethereum"
+        help_text="Full currency name (e.g., Bitcoin, US Dollar)"
     )
+    
     currency_type = models.CharField(
         max_length=10,
         choices=CurrencyType.choices,
-        help_text="fiat or crypto"
+        help_text="Type of currency"
     )
     
-    # USD rate caching - updated once per day
-    usd_rate = models.DecimalField(
-        max_digits=20,
-        decimal_places=8,
-        null=True,
+    symbol = models.CharField(
+        max_length=10,
         blank=True,
-        help_text="Cached USD exchange rate (1 CURRENCY = X USD)"
+        help_text="Currency symbol (e.g., $, ₿, Ξ)"
     )
     
-    rate_updated_at = models.DateTimeField(
-        null=True,
+    decimal_places = models.PositiveSmallIntegerField(
+        default=8,
+        help_text="Number of decimal places for this currency"
+    )
+    
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Whether this currency is available for payments"
+    )
+    
+    # Integration with django_currency
+    exchange_rate_source = models.CharField(
+        max_length=50,
         blank=True,
-        help_text="When the USD rate was last updated"
+        help_text="Source for exchange rates (auto-detected by django_currency)"
     )
     
-    # Import manager
-    from ..managers.currency_manager 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']),
+        ]
     
     def __str__(self):
-        return f"{self.code} - {self.name}"
+        return f"{self.code} ({self.name})"
     
-    @property
-    def is_fiat(self) -> bool:
-        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
+    
+    @property
+    def is_fiat(self) -> bool:
+        """Check if this is a fiat currency."""
+        return self.currency_type == self.CurrencyType.FIAT
 
 
 class Network(TimestampedModel):
-    """Blockchain networks - code and name only."""
+    """
+    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: ethereum, bitcoin, tron, bsc"
+        help_text="Network code (e.g., ETH, BTC, MATIC)"
     )
-    name = models.CharField(
-        max_length=100,
-        help_text="Network name: Ethereum, Bitcoin, TRON, BSC"
+    
+    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)"
     )
     
-    # Import manager
-    from ..managers.currency_manager import NetworkManager
-    objects = NetworkManager()
+    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 = 'payment_networks'
-        verbose_name = "Network"
-        verbose_name_plural = "Networks"
+        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 ProviderCurrency(TimestampedModel):
-    """Provider-currency-network mapping - minimal."""
+    """
+    Provider-specific currency configuration.
     
-    # Identification
-    provider_name = models.CharField(
+    Maps currencies to specific providers and networks.
+    """
+    
+    provider = models.CharField(
         max_length=50,
-        help_text="Provider: nowpayments, stripe, cryptomus"
-    )
-    provider_currency_code = models.CharField(
-        max_length=20,
-        help_text="Provider code: USDTERC20, USDTBSC, usd"
+        help_text="Payment provider name (e.g., nowpayments)"
     )
     
-    # Links to clean models
-    base_currency = models.ForeignKey(
+    currency = models.ForeignKey(
         Currency,
         on_delete=models.CASCADE,
-        related_name='provider_mappings',
-        help_text="Base currency: BTC, USDT, ETH"
+        related_name='provider_configs'
     )
+    
     network = models.ForeignKey(
         Network,
         on_delete=models.CASCADE,
+        related_name='provider_configs',
         null=True,
         blank=True,
-        related_name='provider_currencies',
-        help_text="Network for crypto (null for fiat)"
+        help_text="Network for crypto currencies (null for fiat)"
+    )
+    
+    # Provider-specific settings
+    provider_currency_code = models.CharField(
+        max_length=20,
+        help_text="Currency code as used by the provider"
     )
     
-    # Universal provider fields - common across providers
     min_amount = models.DecimalField(
         max_digits=20,
         decimal_places=8,
         null=True,
         blank=True,
-        help_text="Minimum payment amount"
+        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 (null = no limit)"
+        help_text="Maximum payment amount for this currency"
     )
     
-    # Status and availability
     is_enabled = models.BooleanField(
         default=True,
-        help_text="Enabled by provider"
-    )
-    available_for_payment = models.BooleanField(
-        default=True,
-        help_text="Can receive payments"
-    )
-    available_for_payout = models.BooleanField(
-        default=True,
-        help_text="Can send payouts"
+        help_text="Whether this currency is enabled for this provider"
     )
     
-    # Classification for UI
-    is_popular = models.BooleanField(
-        default=False,
-        help_text="Popular/recommended by provider"
-    )
-    is_stable = models.BooleanField(
-        default=False,
-        help_text="Stable coin (USDT, USDC, etc.)"
-    )
-    priority = models.IntegerField(
+    # Fee configuration
+    fee_percentage = models.DecimalField(
+        max_digits=5,
+        decimal_places=4,
         default=0,
-        help_text="Display priority (higher = shown first)"
-    )
-    logo_url = models.URLField(
-        blank=True,
-        help_text="Currency logo/icon URL from provider"
+        help_text="Fee percentage (0.0250 = 2.5%)"
     )
     
-    # Raw provider data - everything else goes here
-    metadata = models.JSONField(
-        default=dict,
-        blank=True,
-        help_text="All provider-specific data: logo_url, smart_contract, wallet_regex, commission_percent, etc."
+    fixed_fee = models.DecimalField(
+        max_digits=20,
+        decimal_places=8,
+        default=0,
+        help_text="Fixed fee amount in this currency"
     )
     
-    # Import manager
-    from ..managers.currency_manager import ProviderCurrencyManager
-    objects = ProviderCurrencyManager()
-    
     class Meta:
-        db_table = 'payment_provider_currencies'
-        verbose_name = "Provider Currency"
-        verbose_name_plural = "Provider Currencies"
-        unique_together = [
-            ('provider_name', 'provider_currency_code'),
-            ('provider_name', 'base_currency', 'network')
+        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=['provider', 'is_enabled']),
+            models.Index(fields=['currency', 'is_enabled']),
         ]
-        ordering = ['-priority', 'provider_name', 'base_currency__code']
     
     def __str__(self):
         network_part = f" ({self.network.code})" if self.network else ""
-        return f"{self.provider_name}: {self.base_currency.code}{network_part}"
+        return f"{self.provider}: {self.currency.code}{network_part}"
     
-    @property
-    def display_name(self) -> str:
-        """Human-readable name."""
-        if self.network:
-            return f"{self.base_currency.name} ({self.network.name})"
-        return self.base_currency.name
-    
-    # Metadata helper properties
-    
-    def is_amount_valid(self, amount) -> bool:
-        """Check if amount is within provider limits."""
-        if not amount:
-            return False
-            
-        if self.min_amount and amount < self.min_amount:
-            return False
-            
-        if self.max_amount and amount > self.max_amount:
-            return False
-            
-        return True
-    
-    def get_validation_errors(self, amount) -> list:
-        """Get validation errors for amount."""
-        errors = []
+    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")
         
-        if not amount:
-            errors.append("Amount is required")
-            return errors
-            
-        if self.min_amount and amount < self.min_amount:
-            errors.append(f"Amount must be at least {self.min_amount}")
-            
-        if self.max_amount and amount > self.max_amount:
-            errors.append(f"Amount must not exceed {self.max_amount}")
-            
-        return errors
+        # 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 usd_rate(self) -> float:
-        """Get USD rate for base currency (1 CURRENCY = X USD)."""
-        return Currency.objects.get_usd_rate(self.base_currency.code)
-    
-    @property 
-    def tokens_per_usd(self) -> float:
-        """Get how many tokens you can buy for 1 USD."""
-        return Currency.objects.get_tokens_per_usd(self.base_currency.code)
-    
-    def convert_to_usd(self, amount: float) -> float:
-        """Convert amount of this currency to USD."""
-        return Currency.objects.convert_to_usd(amount, self.base_currency.code)
-    
-    def convert_from_usd(self, usd_amount: float) -> float:
-        """Convert USD amount to this currency."""
-        return Currency.objects.convert_from_usd(usd_amount, self.base_currency.code)
-
+    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',
+]