django-cfg 1.3.9__py3-none-any.whl → 1.3.11__py3-none-any.whl

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

@@ -4,13 +4,44 @@ Payment managers for the Universal Payment System v2.0.
 Optimized querysets and managers for payment operations.
 """
 
+from typing import Optional, Dict, Any
+from decimal import Decimal
+from datetime import datetime
 from django.db import models
 from django.utils import timezone
+from pydantic import BaseModel, Field, ConfigDict
 from django_cfg.modules.django_logger import get_logger
 
 logger = get_logger("payment_managers")
 
 
+class PaymentStatusUpdateFields(BaseModel):
+    """
+    Typed model for extra fields when updating payment status.
+    
+    Ensures type safety and validation for payment status updates.
+    """
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid",
+        str_strip_whitespace=True
+    )
+    
+    # Transaction related fields
+    transaction_hash: Optional[str] = Field(None, min_length=1, max_length=200, description="Blockchain transaction hash")
+    confirmations_count: Optional[int] = Field(None, ge=0, description="Number of blockchain confirmations")
+    
+    # Amount related fields  
+    actual_amount_usd: Optional[Decimal] = Field(None, gt=0, description="Actual amount received in USD")
+    fee_amount_usd: Optional[Decimal] = Field(None, ge=0, description="Fee amount in USD")
+    
+    # Provider data
+    provider_data: Optional[Dict[str, Any]] = Field(None, description="Provider-specific data")
+    
+    # Completion timestamp (auto-set by manager for completed status)
+    completed_at: Optional[datetime] = Field(None, description="Completion timestamp")
+
+
 class PaymentQuerySet(models.QuerySet):
     """
     Optimized queryset for payment operations.
@@ -392,17 +423,15 @@ class PaymentManager(models.Manager):
                 })
                 return False
             
-            # Update payment
-            payment.status = 'completed'
-            payment.completed_at = timezone.now()
-            if actual_amount_usd:
-                payment.actual_amount_usd = actual_amount_usd
-            if transaction_hash:
-                payment.transaction_hash = transaction_hash
+            # Update payment using centralized status update method
+            extra_fields = PaymentStatusUpdateFields(
+                actual_amount_usd=actual_amount_usd,
+                transaction_hash=transaction_hash
+            )
             
-            payment.save(update_fields=[
-                'status', 'completed_at', 'actual_amount_usd', 'transaction_hash', 'updated_at'
-            ])
+            success = self.update_payment_status(payment, 'completed', extra_fields)
+            if not success:
+                return False
             
             logger.info(f"Payment marked as completed", extra={
                 'payment_id': str(payment.id),
@@ -438,18 +467,25 @@ class PaymentManager(models.Manager):
             else:
                 payment = payment_id
             
-            # Update payment
-            payment.status = 'failed'
+            # Prepare error info
+            provider_data = payment.provider_data.copy() if payment.provider_data else {}
             if reason or error_code:
-                if 'error_info' not in payment.provider_data:
-                    payment.provider_data['error_info'] = {}
+                if 'error_info' not in provider_data:
+                    provider_data['error_info'] = {}
                 if reason:
-                    payment.provider_data['error_info']['reason'] = reason
+                    provider_data['error_info']['reason'] = reason
                 if error_code:
-                    payment.provider_data['error_info']['code'] = error_code
-                payment.provider_data['error_info']['failed_at'] = timezone.now().isoformat()
+                    provider_data['error_info']['code'] = error_code
+                provider_data['error_info']['failed_at'] = timezone.now().isoformat()
             
-            payment.save(update_fields=['status', 'provider_data', 'updated_at'])
+            # Update payment using centralized status update method
+            extra_fields = PaymentStatusUpdateFields(
+                provider_data=provider_data if provider_data != payment.provider_data else None
+            )
+            
+            success = self.update_payment_status(payment, 'failed', extra_fields)
+            if not success:
+                return False
             
             logger.warning(f"Payment marked as failed", extra={
                 'payment_id': str(payment.id),
@@ -491,15 +527,22 @@ class PaymentManager(models.Manager):
                 })
                 return False
             
-            # Update payment
-            payment.status = 'cancelled'
+            # Prepare cancellation info
+            provider_data = payment.provider_data.copy() if payment.provider_data else {}
             if reason:
-                if 'cancellation_info' not in payment.provider_data:
-                    payment.provider_data['cancellation_info'] = {}
-                payment.provider_data['cancellation_info']['reason'] = reason
-                payment.provider_data['cancellation_info']['cancelled_at'] = timezone.now().isoformat()
+                if 'cancellation_info' not in provider_data:
+                    provider_data['cancellation_info'] = {}
+                provider_data['cancellation_info']['reason'] = reason
+                provider_data['cancellation_info']['cancelled_at'] = timezone.now().isoformat()
             
-            payment.save(update_fields=['status', 'provider_data', 'updated_at'])
+            # Update payment using centralized status update method
+            extra_fields = PaymentStatusUpdateFields(
+                provider_data=provider_data if provider_data != payment.provider_data else None
+            )
+            
+            success = self.update_payment_status(payment, 'cancelled', extra_fields)
+            if not success:
+                return False
             
             logger.info(f"Payment cancelled", extra={
                 'payment_id': str(payment.id),
@@ -514,3 +557,77 @@ class PaymentManager(models.Manager):
                 'payment_id': str(payment_id) if hasattr(payment_id, 'id') else payment_id
             })
             return False
+    
+    def update_payment_status(
+        self, 
+        payment, 
+        new_status: str, 
+        extra_fields: Optional[PaymentStatusUpdateFields] = None
+    ) -> bool:
+        """
+        Update payment status with automatic status_changed_at tracking.
+        
+        Args:
+            payment: Payment instance
+            new_status: New status value
+            extra_fields: Typed extra fields to update
+            
+        Returns:
+            bool: True if status was updated
+        """
+        try:
+            old_status = payment.status
+            
+            # Only update if status actually changed
+            if old_status != new_status:
+                payment.status = new_status
+                payment.status_changed_at = timezone.now()
+                
+                # Set completed_at if status changed to completed
+                if new_status == 'completed' and not payment.completed_at:
+                    payment.completed_at = timezone.now()
+                
+                # Update fields list for save()
+                update_fields = ['status', 'status_changed_at', 'updated_at']
+                
+                # Apply extra fields if provided
+                if extra_fields:
+                    # Validate extra fields
+                    if isinstance(extra_fields, dict):
+                        extra_fields = PaymentStatusUpdateFields(**extra_fields)
+                    
+                    # Apply non-None fields
+                    for field_name, field_value in extra_fields.model_dump(exclude_none=True).items():
+                        if hasattr(payment, field_name):
+                            setattr(payment, field_name, field_value)
+                            update_fields.append(field_name)
+                        else:
+                            logger.warning(f"Unknown field {field_name} ignored", extra={
+                                'payment_id': str(payment.id),
+                                'field_name': field_name
+                            })
+                
+                payment.save(update_fields=update_fields)
+                
+                logger.info(f"Payment status updated", extra={
+                    'payment_id': str(payment.id),
+                    'old_status': old_status,
+                    'new_status': new_status,
+                    'updated_fields': update_fields
+                })
+                
+                return True
+            else:
+                logger.debug(f"Payment status unchanged", extra={
+                    'payment_id': str(payment.id),
+                    'status': new_status
+                })
+                return False
+                
+        except Exception as e:
+            logger.error(f"Failed to update payment status: {e}", extra={
+                'payment_id': str(payment.id),
+                'old_status': old_status if 'old_status' in locals() else 'unknown',
+                'new_status': new_status
+            })
+            return False

django_cfg/apps/payments/models/payments.py

@@ -181,6 +181,13 @@ class UniversalPayment(UUIDTimestampedModel):
         help_text="When this payment was completed"
     )
     
+    status_changed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        db_index=True,
+        help_text="When the payment status was last changed"
+    )
+    
     # Metadata and description
     description = models.TextField(
         blank=True,
@@ -243,6 +250,91 @@ class UniversalPayment(UUIDTimestampedModel):
     def __str__(self):
         return f"Payment {self.internal_payment_id} - ${self.amount_usd:.2f} {self.currency.code}"
     
+    @property
+    def qr_data(self) -> str:
+        """Generate QR code data for payment."""
+        if not self.pay_address:
+            return None
+        
+        # For crypto payments, use proper URI format
+        if self.currency and self.currency.currency_type == 'crypto':
+            currency_code = self.currency.code.lower()
+            
+            if currency_code == 'btc' and self.pay_amount:
+                return f"bitcoin:{self.pay_address}?amount={self.pay_amount}"
+            elif currency_code == 'eth' and self.pay_amount:
+                return f"ethereum:{self.pay_address}?value={self.pay_amount}"
+            elif currency_code == 'ltc' and self.pay_amount:
+                return f"litecoin:{self.pay_address}?amount={self.pay_amount}"
+        
+        # Default: just return the address
+        return self.pay_address
+    
+    @property
+    def formatted_pay_amount(self) -> str:
+        """Format cryptocurrency amount with proper precision."""
+        if not self.pay_amount or not self.currency:
+            return "0"
+        
+        try:
+            amount = float(self.pay_amount)
+            currency_code = self.currency.code.upper()
+            
+            # Different precision for different currencies
+            if currency_code in ['BTC', 'LTC', 'DOGE']:
+                # Bitcoin-like currencies - 8 decimal places
+                formatted = f"{amount:.8f}".rstrip('0').rstrip('.')
+            elif currency_code in ['ETH', 'BNB', 'MATIC']:
+                # Ethereum-like currencies - 6 decimal places typically
+                formatted = f"{amount:.6f}".rstrip('0').rstrip('.')
+            else:
+                # Other currencies - 4 decimal places
+                formatted = f"{amount:.4f}".rstrip('0').rstrip('.')
+            
+            return formatted if formatted else "0"
+            
+        except (ValueError, TypeError):
+            return "0"
+    
+    def get_qr_code_url(self, size=200) -> str:
+        """Generate QR code URL using external service."""
+        if not self.qr_data:
+            return None
+        
+        from urllib.parse import quote
+        
+        # Using QR Server API (free service)
+        qr_data_encoded = quote(self.qr_data)
+        return f"https://api.qrserver.com/v1/create-qr-code/?size={size}x{size}&data={qr_data_encoded}"
+    
+    def get_payment_explorer_link(self) -> str:
+        """Generate blockchain explorer link for transaction."""
+        if not self.transaction_hash or not self.network:
+            return ""
+        
+        # Explorer URL templates for different networks
+        explorer_templates = {
+            'bitcoin': 'https://blockstream.info/tx/{txid}',
+            'ethereum': 'https://etherscan.io/tx/{txid}',
+            'tron': 'https://tronscan.org/#/transaction/{txid}',
+            'polygon': 'https://polygonscan.com/tx/{txid}',
+            'bsc': 'https://bscscan.com/tx/{txid}',
+            'binance smart chain': 'https://bscscan.com/tx/{txid}',
+            'litecoin': 'https://blockchair.com/litecoin/transaction/{txid}',
+            'dogecoin': 'https://blockchair.com/dogecoin/transaction/{txid}',
+            'arbitrum': 'https://arbiscan.io/tx/{txid}',
+            'optimism': 'https://optimistic.etherscan.io/tx/{txid}',
+            'avalanche c-chain': 'https://snowtrace.io/tx/{txid}',
+            'base': 'https://basescan.org/tx/{txid}',
+        }
+        
+        network_name = self.network.name.lower() if hasattr(self.network, 'name') else str(self.network).lower()
+        template = explorer_templates.get(network_name)
+        if template:
+            return template.format(txid=self.transaction_hash)
+        
+        return ""
+    
     def save(self, *args, **kwargs):
         """Override save to generate internal payment ID."""
         if not self.internal_payment_id:
@@ -360,3 +452,5 @@ class UniversalPayment(UUIDTimestampedModel):
     def cancel(self, reason: str = None):
         """Cancel payment (delegates to manager)."""
         return self.__class__.objects.cancel_payment(self, reason)
+    
+    

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

@@ -8,8 +8,9 @@ from abc import ABC
 from typing import Optional, Dict, Any, Type
 from django.db import transaction
 from django_cfg.modules.django_logger import get_logger
-from ..types import ServiceOperationResult
 
+from ..types import ServiceOperationResult
+from ...config.django_cfg_integration import PaymentsConfigManager
 
 class BaseService(ABC):
     """
@@ -23,9 +24,8 @@ class BaseService(ABC):
         self.logger = get_logger(f"services.{self.__class__.__name__.lower()}")
         self._cache = {}
         
-        # Initialize config service
-        from ...config.constance import get_payment_config_service
-        self.config_service = get_payment_config_service()
+        # Initialize config manager
+        self.config_manager = PaymentsConfigManager
     
     def _create_success_result(
         self,