django-cfg 1.2.27__py3-none-any.whl → 1.2.31__py3-none-any.whl

django_cfg/apps/payments/models/currencies.py

@@ -1,138 +1,254 @@
 """
-Currency models for the universal payments system.
+Currency models for the universal payments system - KISS version.
 """
 
 from django.db import models
 from .base import TimestampedModel
 
+# Currency converter import moved inside methods to avoid circular imports
 
 class Currency(TimestampedModel):
-    """Supported currencies for payments."""
+    """Base currencies - clean, no provider-specific codes."""
     
     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="Currency code (e.g., USD, BTC, ETH)"
+        help_text="Clean currency code: BTC, USDT, ETH, USD (NO network suffixes)"
     )
     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="Currency name: Bitcoin, Tether USD, Ethereum"
     )
     currency_type = models.CharField(
         max_length=10,
         choices=CurrencyType.choices,
-        help_text="Type of currency"
-    )
-    decimal_places = models.PositiveSmallIntegerField(
-        default=2,
-        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="fiat or crypto"
     )
     
-    # 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)"
+    # USD rate caching - updated once per day
+    usd_rate = models.DecimalField(
+        max_digits=20,
+        decimal_places=8,
+        null=True,
+        blank=True,
+        help_text="Cached USD exchange rate (1 CURRENCY = X USD)"
     )
+    
     rate_updated_at = models.DateTimeField(
         null=True,
         blank=True,
-        help_text="When the exchange rate was last updated"
+        help_text="When the USD rate was last updated"
     )
     
-    # Import and assign manager
-    from ..managers import CurrencyManager
+    # Import manager
+    from ..managers.currency_manager import CurrencyManager
     objects = CurrencyManager()
     
     class Meta:
         db_table = 'payment_currencies'
         verbose_name = "Currency"
         verbose_name_plural = "Currencies"
-        indexes = [
-            models.Index(fields=['code']),
-            models.Index(fields=['currency_type']),
-            models.Index(fields=['is_active']),
-        ]
-        ordering = ['code']
+        ordering = ['currency_type', 'code']
     
     def __str__(self):
         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
     
     @property
     def is_crypto(self) -> bool:
-        """Check if this is a cryptocurrency."""
         return self.currency_type == self.CurrencyType.CRYPTO
+
+
+class Network(TimestampedModel):
+    """Blockchain networks - code and name only."""
     
-    def to_usd(self, amount: float) -> float:
-        """Convert amount of this currency to USD."""
-        return amount * self.usd_rate
+    code = models.CharField(
+        max_length=20,
+        unique=True,
+        help_text="Network code: ethereum, bitcoin, tron, bsc"
+    )
+    name = models.CharField(
+        max_length=100,
+        help_text="Network name: Ethereum, Bitcoin, TRON, BSC"
+    )
     
-    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
+    # Import manager
+    from ..managers.currency_manager import NetworkManager
+    objects = NetworkManager()
+    
+    class Meta:
+        db_table = 'payment_networks'
+        verbose_name = "Network"
+        verbose_name_plural = "Networks"
+        ordering = ['name']
+    
+    def __str__(self):
+        return f"{self.name} ({self.code})"
 
 
-class CurrencyNetwork(TimestampedModel):
-    """Networks/blockchains for cryptocurrencies."""
+class ProviderCurrency(TimestampedModel):
+    """Provider-currency-network mapping - minimal."""
     
-    currency = models.ForeignKey(
+    # Identification
+    provider_name = 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"
+    )
+    
+    # Links to clean models
+    base_currency = models.ForeignKey(
         Currency,
         on_delete=models.CASCADE,
-        related_name='networks',
-        help_text="Currency this network supports"
+        related_name='provider_mappings',
+        help_text="Base currency: BTC, USDT, ETH"
     )
-    network_name = models.CharField(
-        max_length=50,
-        help_text="Network name (e.g., mainnet, polygon, bsc)"
+    network = models.ForeignKey(
+        Network,
+        on_delete=models.CASCADE,
+        null=True,
+        blank=True,
+        related_name='provider_currencies',
+        help_text="Network for crypto (null for fiat)"
     )
-    network_code = models.CharField(
-        max_length=20,
-        help_text="Network code for API integration"
+    
+    # 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"
     )
-    is_active = models.BooleanField(
+    max_amount = models.DecimalField(
+        max_digits=20,
+        decimal_places=8,
+        null=True,
+        blank=True,
+        help_text="Maximum payment amount (null = no limit)"
+    )
+    
+    # Status and availability
+    is_enabled = models.BooleanField(
         default=True,
-        help_text="Whether this network is active"
+        help_text="Enabled by provider"
     )
-    confirmation_blocks = models.PositiveIntegerField(
-        default=1,
-        help_text="Number of confirmations required"
+    available_for_payment = models.BooleanField(
+        default=True,
+        help_text="Can receive payments"
+    )
+    available_for_payout = models.BooleanField(
+        default=True,
+        help_text="Can send payouts"
     )
     
-    # Import and assign manager
-    from ..managers import CurrencyNetworkManager
-    objects = CurrencyNetworkManager()
+    # 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(
+        default=0,
+        help_text="Display priority (higher = shown first)"
+    )
+    logo_url = models.URLField(
+        blank=True,
+        help_text="Currency logo/icon URL from provider"
+    )
+    
+    # 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."
+    )
+    
+    # Import manager
+    from ..managers.currency_manager import ProviderCurrencyManager
+    objects = ProviderCurrencyManager()
     
     class Meta:
-        db_table = 'payment_currency_networks'
-        verbose_name = "Currency Network"
-        verbose_name_plural = "Currency Networks"
-        unique_together = [['currency', 'network_code']]
-        indexes = [
-            models.Index(fields=['currency', 'is_active']),
-            models.Index(fields=['network_code']),
+        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')
         ]
+        ordering = ['-priority', 'provider_name', 'base_currency__code']
     
     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_name}: {self.base_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 = []
+        
+        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
+    
+    @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)
+

django_cfg/apps/payments/models/payments.py

@@ -13,6 +13,7 @@ User = get_user_model()
 
 
 
+
 class UniversalPayment(UUIDTimestampedModel):
     """Universal payment model for all providers."""
     
@@ -208,8 +209,8 @@ class UniversalPayment(UUIDTimestampedModel):
         help_text="When the payment was processed and funds added to balance"
     )
 
-    # Import and assign manager
-    from ..managers import UniversalPaymentManager
+    # Custom managers for optimized queries
+    from ..managers.payment_manager import UniversalPaymentManager
     objects = UniversalPaymentManager()
 
     class Meta:

django_cfg/apps/payments/serializers/__init__.py

@@ -16,7 +16,7 @@ from .api_keys import (
     APIKeySerializer, APIKeyCreateSerializer, APIKeyListSerializer
 )
 from .currencies import (
-    CurrencySerializer, CurrencyNetworkSerializer, CurrencyListSerializer
+    CurrencySerializer, NetworkSerializer, ProviderCurrencySerializer, CurrencyListSerializer
 )
 from .tariffs import (
     TariffSerializer, TariffEndpointGroupSerializer, TariffListSerializer
@@ -46,7 +46,8 @@ __all__ = [
     
     # Currencies
     'CurrencySerializer',
-    'CurrencyNetworkSerializer',
+    'NetworkSerializer',
+    'ProviderCurrencySerializer',
     'CurrencyListSerializer',
     
     # Tariffs

django_cfg/apps/payments/serializers/currencies.py

@@ -3,7 +3,7 @@ Currency serializers.
 """
 
 from rest_framework import serializers
-from ..models import Currency, CurrencyNetwork
+from ..models import Currency, Network, ProviderCurrency
 
 
 class CurrencySerializer(serializers.ModelSerializer):
@@ -16,9 +16,8 @@ class CurrencySerializer(serializers.ModelSerializer):
     class Meta:
         model = Currency
         fields = [
-            'id', 'code', 'name', 'symbol', 'currency_type', 'currency_type_display',
-            'is_crypto', 'is_fiat', 'decimal_places', 'usd_rate', 'rate_updated_at',
-            'is_active', 'min_payment_amount'
+            'id', 'code', 'name', 'currency_type', 'currency_type_display',
+            'is_crypto', 'is_fiat', 'usd_rate', 'rate_updated_at'
         ]
         read_only_fields = ['rate_updated_at']
     
@@ -31,17 +30,26 @@ class CurrencySerializer(serializers.ModelSerializer):
         return obj.is_fiat
 
 
-class CurrencyNetworkSerializer(serializers.ModelSerializer):
-    """Currency network with status."""
+class NetworkSerializer(serializers.ModelSerializer):
+    """Network information."""
     
-    currency_code = serializers.CharField(source='currency.code', read_only=True)
-    currency_name = serializers.CharField(source='currency.name', read_only=True)
+    class Meta:
+        model = Network
+        fields = ['id', 'code', 'name']
+
+
+class ProviderCurrencySerializer(serializers.ModelSerializer):
+    """Provider currency with base currency and network info."""
+    
+    base_currency = CurrencySerializer(read_only=True)
+    network = NetworkSerializer(read_only=True)
     
     class Meta:
-        model = CurrencyNetwork
+        model = ProviderCurrency
         fields = [
-            'id', 'currency', 'currency_code', 'currency_name', 'network_code',
-            'network_name', 'is_active', 'confirmation_blocks'
+            'id', 'provider_name', 'provider_currency_code', 'base_currency', 'network',
+            'is_enabled', 'available_for_payment', 'available_for_payout', 
+            'is_popular', 'is_stable', 'min_amount', 'max_amount', 'logo_url'
         ]
 
 
@@ -52,4 +60,4 @@ class CurrencyListSerializer(serializers.ModelSerializer):
     
     class Meta:
         model = Currency
-        fields = ['id', 'code', 'name', 'currency_type', 'currency_type_display', 'is_active']
+        fields = ['id', 'code', 'name', 'currency_type', 'currency_type_display']

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

@@ -3,14 +3,14 @@ Simple cache implementation for API keys and rate limiting.
 ONLY for API access control - NOT payment data!
 """
 
-import logging
+from django_cfg.modules.django_logger import get_logger
 from typing import Optional, Any
 from django.core.cache import cache
 
 from .base import CacheInterface
 from ...utils.config_utils import CacheConfigHelper
 
-logger = logging.getLogger(__name__)
+logger = get_logger("simple_cache")
 
 
 class SimpleCache(CacheInterface):

django_cfg/apps/payments/services/core/balance_service.py

@@ -5,8 +5,8 @@ This service handles user balance operations, transaction recording,
 and balance validation with atomic operations.
 """
 
-import logging
 from typing import Dict, Any, Optional, List
+from django_cfg.modules.django_logger import get_logger
 from decimal import Decimal
 from datetime import timezone
 
@@ -18,7 +18,7 @@ from ...models import UserBalance, Transaction
 from ..internal_types import ServiceOperationResult, BalanceUpdateRequest, UserBalanceResult, TransactionInfo
 
 User = get_user_model()
-logger = logging.getLogger(__name__)
+logger = get_logger("balance_service")
 
 
 class BalanceOperation(BaseModel):

django_cfg/apps/payments/services/core/fallback_service.py

@@ -5,7 +5,7 @@ Handles automatic provider switching when providers become unavailable,
 ensuring payment system resilience and high availability.
 """
 
-import logging
+from django_cfg.modules.django_logger import get_logger
 from typing import Optional, List, Dict, Any
 from dataclasses import dataclass
 from enum import Enum
@@ -18,7 +18,7 @@ from ..monitoring.provider_health import get_health_monitor, HealthStatus
 from ..providers.registry import ProviderRegistry
 from ...models.events import PaymentEvent
 
-logger = logging.getLogger(__name__)
+logger = get_logger("fallback_service")
 
 
 class FallbackStrategy(Enum):

django_cfg/apps/payments/services/core/payment_service.py

@@ -5,7 +5,6 @@ This service handles universal payment operations, provider orchestration,
 and payment lifecycle management.
 """
 
-import logging
 from typing import Optional, List
 from decimal import Decimal
 from django.db import transaction
@@ -18,6 +17,7 @@ from .fallback_service import get_fallback_service
 from ...models import UniversalPayment, UserBalance, Transaction
 from ...utils.config_utils import get_payments_config
 from ..providers.registry import ProviderRegistry
+from django_cfg.modules.django_logger import get_logger
 from ..monitoring.provider_health import get_health_monitor
 from ..internal_types import (
     ProviderResponse, WebhookData, ServiceOperationResult,
@@ -28,9 +28,10 @@ from ..internal_types import (
 
 # Import django_currency module for currency conversion
 from django_cfg.modules.django_currency import convert_currency, CurrencyError
+from ...models.events import PaymentEvent
 
 User = get_user_model()
-logger = logging.getLogger(__name__)
+logger = get_logger("payment_service")
 
 
 class PaymentRequest(BaseModel):
@@ -501,8 +502,6 @@ class PaymentService:
             data: Event data
         """
         try:
-            from ...models.events import PaymentEvent
-            
             # Get next sequence number
             last_event = PaymentEvent.objects.filter(
                 payment_id=str(payment.id)
@@ -534,8 +533,6 @@ class PaymentService:
             List of payment events
         """
         try:
-            from ...models.events import PaymentEvent
-            
             events = PaymentEvent.objects.filter(
                 payment_id=payment_id
             ).order_by('sequence_number')

django_cfg/apps/payments/services/core/subscription_service.py

@@ -5,21 +5,21 @@ This service handles subscription creation, renewal, access validation,
 and usage tracking with Redis caching.
 """
 
-import logging
 from typing import Dict, Any, Optional, List
+from django_cfg.modules.django_logger import get_logger
 from datetime import datetime, timedelta, timezone as dt_timezone
 
 from django.db import transaction
 from django.contrib.auth import get_user_model
 from django.utils import timezone
 from pydantic import BaseModel, Field, ValidationError
-
+from decimal import Decimal
 
 from ...models import Subscription, EndpointGroup, Tariff
-from ..internal_types import ServiceOperationResult
+from ..internal_types import ServiceOperationResult, SubscriptionInfo, EndpointGroupInfo
 
 User = get_user_model()
-logger = logging.getLogger(__name__)
+logger = get_logger("subscription_service")
 
 
 class SubscriptionRequest(BaseModel):
@@ -276,9 +276,6 @@ class SubscriptionService:
                 'endpoint_group'
             ).order_by('-created_at')
             
-            from ..internal_types import SubscriptionInfo, EndpointGroupInfo
-            from decimal import Decimal
-            
             result = [
                 SubscriptionInfo(
                     id=str(sub.id),