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

django_cfg/apps/payments/models/payments.py

@@ -1,21 +1,28 @@
 """
-Payment models for the universal payments system.
+Payment models for the Universal Payment System v2.0.
+
+Core payment model with simplified architecture focused on NowPayments.
 """
 
+from decimal import Decimal
 from django.db import models
 from django.contrib.auth import get_user_model
-from django.core.validators import MinValueValidator
+from django.core.validators import MinValueValidator, MaxValueValidator
 from django.core.exceptions import ValidationError
 from django.utils import timezone
 from .base import UUIDTimestampedModel
+from .currencies import Currency, Network
 
 User = get_user_model()
 
 
-
-
 class UniversalPayment(UUIDTimestampedModel):
-    """Universal payment model for all providers."""
+    """
+    Universal payment model supporting all providers.
+    
+    Simplified v2.0 architecture focused on NowPayments with extensible design.
+    Uses float for USD amounts as per requirements for performance and API compatibility.
+    """
     
     class PaymentStatus(models.TextChoices):
         PENDING = "pending", "Pending"
@@ -29,384 +36,327 @@ class UniversalPayment(UUIDTimestampedModel):
     
     class PaymentProvider(models.TextChoices):
         NOWPAYMENTS = "nowpayments", "NowPayments"
-        CRYPTAPI = "cryptapi", "CryptAPI"
-        CRYPTOMUS = "cryptomus", "Cryptomus"
-        STRIPE = "stripe", "Stripe"
-        INTERNAL = "internal", "Internal"
+        # Future providers can be added here
+        
+        @classmethod
+        def get_crypto_providers(cls):
+            """Get list of crypto provider values."""
+            return [cls.NOWPAYMENTS]
+        
+        @classmethod
+        def is_crypto_provider(cls, provider_name: str) -> bool:
+            """Check if provider handles cryptocurrency."""
+            return provider_name in cls.get_crypto_providers()
     
+    # User and identification
     user = models.ForeignKey(
         User,
         on_delete=models.CASCADE,
-        related_name='universal_payments',
-        help_text="User who initiated this payment"
+        related_name='payments',
+        help_text="User who created this payment"
     )
     
-    # Financial data
+    internal_payment_id = models.CharField(
+        max_length=100,
+        unique=True,
+        db_index=True,
+        help_text="Internal payment identifier"
+    )
+    
+    # Financial information (USD as float per requirements)
     amount_usd = models.FloatField(
-        validators=[MinValueValidator(1.0)],
-        help_text="Payment amount in USD"
+        validators=[MinValueValidator(1.0), MaxValueValidator(50000.0)],
+        help_text="Payment amount in USD (float for performance)"
     )
-    currency_code = models.CharField(
-        max_length=10,
-        help_text="Currency used for payment"
+    
+    # Cryptocurrency information
+    currency = models.ForeignKey(
+        Currency,
+        on_delete=models.PROTECT,
+        related_name='payments',
+        help_text="Payment currency"
     )
     
-    # Actual received amount (may differ from requested)
-    actual_amount_usd = models.FloatField(
+    network = models.ForeignKey(
+        Network,
+        on_delete=models.PROTECT,
+        related_name='payments',
         null=True,
         blank=True,
-        help_text="Actual received amount in USD"
+        help_text="Blockchain network (for crypto payments)"
     )
-    actual_currency_code = models.CharField(
-        max_length=10,
+    
+    # Crypto amounts use Decimal for precision
+    pay_amount = models.DecimalField(
+        max_digits=20,
+        decimal_places=8,
         null=True,
         blank=True,
-        help_text="Actual received currency"
+        help_text="Amount to pay in cryptocurrency (Decimal for precision)"
+    )
+    
+    actual_amount_usd = models.FloatField(
+        null=True,
+        blank=True,
+        help_text="Actual amount received in USD"
     )
     
-    # Fee information
     fee_amount_usd = models.FloatField(
         null=True,
         blank=True,
-        validators=[MinValueValidator(0.0)],
         help_text="Fee amount in USD"
     )
     
-    # Payment details
+    # Provider information
     provider = models.CharField(
         max_length=50,
         choices=PaymentProvider.choices,
+        default=PaymentProvider.NOWPAYMENTS,
         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,
+        db_index=True,
         help_text="Provider's payment ID"
     )
-    internal_payment_id = models.CharField(
-        max_length=100,
-        unique=True,
-        help_text="Internal payment identifier"
+    
+    # Payment details
+    status = models.CharField(
+        max_length=20,
+        choices=PaymentStatus.choices,
+        default=PaymentStatus.PENDING,
+        db_index=True,
+        help_text="Current payment status"
     )
     
-    # Crypto payment specific
     pay_address = models.CharField(
-        max_length=200,
+        max_length=255,
         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,
+    
+    payment_url = models.URLField(
         null=True,
         blank=True,
-        help_text="Blockchain network (mainnet, testnet, etc.)"
+        help_text="Payment page URL"
     )
     
-    # Metadata
-    description = models.TextField(
-        blank=True,
-        help_text="Payment description"
-    )
-    order_id = models.CharField(
-        max_length=255,
+    # Transaction information
+    transaction_hash = models.CharField(
+        max_length=256,
         null=True,
         blank=True,
-        help_text="Order reference ID"
-    )
-    metadata = models.JSONField(
-        default=dict,
-        help_text="Additional metadata"
+        db_index=True,
+        help_text="Blockchain transaction hash"
     )
     
-    # Provider webhook data
-    webhook_data = models.JSONField(
-        null=True,
-        blank=True,
-        help_text="Raw webhook data from provider"
+    confirmations_count = models.PositiveIntegerField(
+        default=0,
+        help_text="Number of blockchain confirmations"
     )
     
-    # Universal Security fields (used by all providers)
+    # Security and validation
     security_nonce = models.CharField(
         max_length=64,
         null=True,
         blank=True,
         db_index=True,
-        help_text="Security nonce for replay attack protection (CryptAPI, Cryptomus, etc.)"
-    )
-    provider_callback_url = models.CharField(
-        max_length=512,
-        null=True,
-        blank=True,
-        help_text="Full callback URL with security parameters"
+        help_text="Security nonce for validation"
     )
     
-    # Universal Transaction fields (crypto providers)
-    transaction_hash = models.CharField(
-        max_length=256,
-        null=True,
-        blank=True,
-        db_index=True,
-        help_text="Main transaction hash/ID (txid_in for CryptAPI, hash for Cryptomus)"
-    )
-    confirmation_hash = models.CharField(
-        max_length=256,
+    # Timestamps
+    expires_at = models.DateTimeField(
         null=True,
         blank=True,
-        help_text="Secondary transaction hash (txid_out for CryptAPI, confirmation for others)"
+        help_text="When this payment expires"
     )
-    sender_address = models.CharField(
-        max_length=200,
+    
+    completed_at = models.DateTimeField(
         null=True,
         blank=True,
-        help_text="Sender address (address_in for CryptAPI, from_address for Cryptomus)"
+        help_text="When this payment was completed"
     )
-    receiver_address = models.CharField(
-        max_length=200,
-        null=True,
+    
+    # Metadata and description
+    description = models.TextField(
         blank=True,
-        help_text="Receiver address (address_out for CryptAPI, to_address for Cryptomus)"
+        help_text="Payment description"
     )
-    crypto_amount = models.FloatField(
+    
+    callback_url = models.URLField(
         null=True,
         blank=True,
-        help_text="Amount in cryptocurrency units (value_coin for CryptAPI, amount for Cryptomus)"
-    )
-    confirmations_count = models.PositiveIntegerField(
-        default=0,
-        help_text="Number of blockchain confirmations"
+        help_text="Success callback URL"
     )
     
-    # Timestamps
-    expires_at = models.DateTimeField(
+    cancel_url = models.URLField(
         null=True,
         blank=True,
-        help_text="Payment expiration time"
+        help_text="Cancellation URL"
     )
-    completed_at = models.DateTimeField(
-        null=True,
+    
+    # Structured metadata (validated by Pydantic in services)
+    provider_data = models.JSONField(
+        default=dict,
         blank=True,
-        help_text="Payment completion time"
+        help_text="Provider-specific data (validated by Pydantic)"
     )
-    processed_at = models.DateTimeField(
-        null=True,
+    
+    webhook_data = models.JSONField(
+        default=dict,
         blank=True,
-        help_text="When the payment was processed and funds added to balance"
+        help_text="Webhook data (validated by Pydantic)"
     )
-
-    # Custom managers for optimized queries
-    from ..managers.payment_manager import UniversalPaymentManager
-    objects = UniversalPaymentManager()
-
+    
+    # Manager
+    from .managers.payment_managers import PaymentManager
+    objects = PaymentManager()
+    
     class Meta:
-        db_table = 'universal_payments'
-        verbose_name = "Universal Payment"
-        verbose_name_plural = "Universal Payments"
+        db_table = 'payments_universal'
+        verbose_name = 'Universal Payment'
+        verbose_name_plural = 'Universal Payments'
+        ordering = ['-created_at']
         indexes = [
             models.Index(fields=['user', 'status']),
+            models.Index(fields=['provider', 'status']),
+            models.Index(fields=['status', 'created_at']),
             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']),
-            # Universal crypto provider indexes
-            models.Index(fields=['security_nonce']),
             models.Index(fields=['transaction_hash']),
-            models.Index(fields=['confirmations_count']),
-            models.Index(fields=['provider', 'status', 'confirmations_count']),
+            models.Index(fields=['expires_at']),
         ]
-        ordering = ['-created_at']
-
+        constraints = [
+            models.CheckConstraint(
+                check=models.Q(amount_usd__gte=1.0),
+                name='payments_min_amount_check'
+            ),
+            models.CheckConstraint(
+                check=models.Q(amount_usd__lte=50000.0),
+                name='payments_max_amount_check'
+            ),
+        ]
+    
     def __str__(self):
-        return f"{self.user.email} - ${self.amount_usd} ({self.currency_code}) - {self.get_status_display()}"
-
+        return f"Payment {self.internal_payment_id} - ${self.amount_usd:.2f} {self.currency.code}"
+    
+    def save(self, *args, **kwargs):
+        """Override save to generate internal payment ID."""
+        if not self.internal_payment_id:
+            # Generate internal payment ID
+            timestamp = timezone.now().strftime('%Y%m%d%H%M%S')
+            self.internal_payment_id = f"PAY_{timestamp}_{str(self.id)[:8]}"
+        
+        super().save(*args, **kwargs)
+    
+    def clean(self):
+        """Model validation."""
+        # Crypto payments must have network
+        if self.currency and self.currency.is_crypto and not self.network:
+            raise ValidationError("Cryptocurrency payments must specify a network")
+        
+        # Fiat payments should not have network
+        if self.currency and self.currency.is_fiat and self.network:
+            raise ValidationError("Fiat payments should not specify a network")
+        
+        # Validate amount limits
+        if self.amount_usd and (self.amount_usd < 1.0 or self.amount_usd > 50000.0):
+            raise ValidationError("Payment amount must be between $1.00 and $50,000.00")
+        
+        # Validate expiration
+        if self.expires_at and self.expires_at <= timezone.now():
+            raise ValidationError("Expiration time must be in the future")
+    
+    # Status properties
     @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
-        ]
-
+        """Check if payment is pending."""
+        return self.status == self.PaymentStatus.PENDING
+    
     @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
-
+        return self.status in [
+            self.PaymentStatus.FAILED,
+            self.PaymentStatus.EXPIRED,
+            self.PaymentStatus.CANCELLED
+        ]
+    
     @property
-    def is_crypto_payment(self) -> bool:
-        """Check if this is a cryptocurrency payment."""
-        return self.provider == self.PaymentProvider.NOWPAYMENTS
-
+    def is_expired(self) -> bool:
+        """Check if payment is expired."""
+        if not self.expires_at:
+            return False
+        return timezone.now() > self.expires_at
+    
     @property
-    def is_crypto_provider_payment(self) -> bool:
-        """Check if this is a crypto provider payment (CryptAPI, Cryptomus, etc.)."""
-        crypto_providers = ['cryptapi', 'cryptomus', 'nowpayments']
-        return self.provider in crypto_providers or (self.security_nonce is not None)
-
+    def requires_confirmation(self) -> bool:
+        """Check if payment requires blockchain confirmation."""
+        return self.status in [
+            self.PaymentStatus.CONFIRMING,
+            self.PaymentStatus.CONFIRMED
+        ]
+    
+    # Display properties
     @property
-    def has_sufficient_confirmations(self) -> bool:
-        """Check if payment has sufficient confirmations (3+ for most cryptos)."""
-        required_confirmations = 3  # Can be made configurable per currency
-        return self.confirmations_count >= required_confirmations
-
+    def status_color(self) -> str:
+        """Get color for status display."""
+        colors = {
+            self.PaymentStatus.PENDING: 'warning',
+            self.PaymentStatus.CONFIRMING: 'info',
+            self.PaymentStatus.CONFIRMED: 'primary',
+            self.PaymentStatus.COMPLETED: 'success',
+            self.PaymentStatus.FAILED: 'danger',
+            self.PaymentStatus.EXPIRED: 'secondary',
+            self.PaymentStatus.CANCELLED: 'secondary',
+            self.PaymentStatus.REFUNDED: 'warning',
+        }
+        return colors.get(self.status, 'secondary')
+    
     @property
-    def is_security_nonce_valid(self) -> bool:
-        """Check if security nonce is present for crypto provider payments."""
-        return bool(self.security_nonce) if self.is_crypto_provider_payment else True
-
+    def amount_display(self) -> str:
+        """Formatted amount display."""
+        return f"${self.amount_usd:.2f} USD"
+    
     @property
-    def has_transaction_hash(self) -> bool:
-        """Check if payment has a transaction hash."""
-        return bool(self.transaction_hash)
-
-    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']
-            
-        # Universal crypto provider webhook fields
-        # CryptAPI format
-        if 'txid_in' in webhook_data:
-            self.transaction_hash = webhook_data['txid_in']
-        if 'txid_out' in webhook_data:
-            self.confirmation_hash = webhook_data['txid_out']
-        if 'address_in' in webhook_data:
-            self.sender_address = webhook_data['address_in']
-        if 'address_out' in webhook_data:
-            self.receiver_address = webhook_data['address_out']
-        if 'value_coin' in webhook_data:
-            self.crypto_amount = float(str(webhook_data['value_coin']))
-            
-        # Cryptomus format
-        if 'hash' in webhook_data:
-            self.transaction_hash = webhook_data['hash']
-        if 'from_address' in webhook_data:
-            self.sender_address = webhook_data['from_address']
-        if 'to_address' in webhook_data:
-            self.receiver_address = webhook_data['to_address']
-        if 'amount' in webhook_data and isinstance(webhook_data['amount'], (int, float, str)):
-            try:
-                self.crypto_amount = float(str(webhook_data['amount']))
-            except (ValueError, TypeError):
-                pass
-            
-        # Universal confirmations field
-        if 'confirmations' in webhook_data:
-            self.confirmations_count = int(webhook_data['confirmations'])
-        
-        self.save()
-
+    def crypto_amount_display(self) -> str:
+        """Formatted crypto amount display."""
+        if not self.pay_amount:
+            return "N/A"
+        return f"{self.pay_amount:.8f} {self.currency.code}"
+    
+    # Business logic methods
+    def can_be_cancelled(self) -> bool:
+        """Check if payment can be cancelled."""
+        return self.status in [
+            self.PaymentStatus.PENDING,
+            self.PaymentStatus.CONFIRMING
+        ]
+    
     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)
+        return self.status == self.PaymentStatus.COMPLETED
+    
+    def mark_completed(self, actual_amount_usd: float = None, transaction_hash: str = None):
+        """Mark payment as completed (delegates to manager)."""
+        return self.__class__.objects.mark_payment_completed(
+            self, actual_amount_usd, transaction_hash
+        )
+    
+    def mark_failed(self, reason: str = None, error_code: str = None):
+        """Mark payment as failed (delegates to manager)."""
+        return self.__class__.objects.mark_payment_failed(
+            self, reason, error_code
+        )
+    
+    def cancel(self, reason: str = None):
+        """Cancel payment (delegates to manager)."""
+        return self.__class__.objects.cancel_payment(self, reason)