django-cfg 1.3.7__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, 

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

@@ -4,10 +4,9 @@ Currency service for the Universal Payment System v2.0.
 Handles currency conversion and rate management using django_currency module.
 """
 
-from typing import Optional, Dict, Any, List
-from decimal import Decimal
+from typing import Optional, List
 from django.utils import timezone
-from datetime import timedelta
+from django.db import models
 
 from .base import BaseService
 from ..types import (
@@ -161,29 +160,35 @@ class CurrencyService(BaseService):
                 quote_currency=quote_currency
             )
     
-    def get_supported_currencies(self, provider: Optional[str] = None) -> ServiceOperationResult:
+    def get_supported_currencies(self, provider: Optional[str] = None, currency_type: str = 'all') -> ServiceOperationResult:
         """
         Get list of supported currencies.
         
         Args:
             provider: Filter by provider (optional)
+            currency_type: Filter by currency type ('all', 'crypto', 'fiat')
             
         Returns:
             ServiceOperationResult: List of supported currencies
         """
         try:
             self.logger.debug("Getting supported currencies", extra={
-                'provider': provider
+                'provider': provider,
+                'currency_type': currency_type
             })
             
             # Get currencies from database
-            queryset = Currency.objects.filter(is_enabled=True)
+            queryset = Currency.objects.filter(is_active=True)
+            
+            # Filter by currency type
+            if currency_type and currency_type != 'all':
+                queryset = queryset.filter(currency_type=currency_type)
             
             if provider:
                 # Filter by provider support
                 queryset = queryset.filter(
-                    providercurrency__provider=provider,
-                    providercurrency__is_enabled=True
+                    provider_configs__provider=provider,
+                    provider_configs__is_enabled=True
                 ).distinct()
             
             currencies = queryset.order_by('code')
@@ -197,18 +202,20 @@ class CurrencyService(BaseService):
                 # Add provider-specific info if requested
                 if provider:
                     try:
-                        provider_currency = ProviderCurrency.objects.get(
+                        provider_currency = ProviderCurrency.objects.filter(
                             currency=currency,
                             provider=provider,
                             is_enabled=True
-                        )
-                        currency_info['provider_info'] = {
-                            'min_amount': float(provider_currency.min_amount) if provider_currency.min_amount else None,
-                            'max_amount': float(provider_currency.max_amount) if provider_currency.max_amount else None,
-                            'network_fee': float(provider_currency.network_fee) if provider_currency.network_fee else None,
-                            'confirmation_blocks': provider_currency.confirmation_blocks
-                        }
-                    except ProviderCurrency.DoesNotExist:
+                        ).first()
+                        if provider_currency:
+                            currency_info['provider_info'] = {
+                                'min_amount': provider_currency.provider_min_amount_usd,
+                                'max_amount': provider_currency.provider_max_amount_usd,
+                                'fee_percentage': provider_currency.provider_fee_percentage,
+                                'fixed_fee_usd': provider_currency.provider_fixed_fee_usd,
+                                'confirmation_blocks': provider_currency.provider_confirmation_blocks
+                            }
+                    except Exception:
                         pass
                 
                 currency_data.append(currency_info)
@@ -245,7 +252,7 @@ class CurrencyService(BaseService):
             
             # Get currency
             try:
-                currency = Currency.objects.get(code=currency_code, is_enabled=True)
+                currency = Currency.objects.get(code=currency_code, is_active=True)
             except Currency.DoesNotExist:
                 return self._create_error_result(
                     f"Currency {currency_code} not found or disabled",
@@ -255,7 +262,7 @@ class CurrencyService(BaseService):
             # Get networks
             networks = Network.objects.filter(
                 currency_code=currency_code,
-                is_enabled=True
+                is_active=True
             ).order_by('name')
             
             network_data = []
@@ -305,10 +312,10 @@ class CurrencyService(BaseService):
             if currency_codes:
                 currencies = Currency.objects.filter(
                     code__in=currency_codes,
-                    is_enabled=True
+                    is_active=True
                 )
             else:
-                currencies = Currency.objects.filter(is_enabled=True)
+                currencies = Currency.objects.filter(is_active=True)
             
             updated_count = 0
             failed_count = 0
@@ -369,14 +376,14 @@ class CurrencyService(BaseService):
         try:
             # Currency counts
             total_currencies = Currency.objects.count()
-            enabled_currencies = Currency.objects.filter(is_enabled=True).count()
+            enabled_currencies = Currency.objects.filter(is_active=True).count()
             crypto_currencies = Currency.objects.filter(
                 currency_type=Currency.CurrencyType.CRYPTO,
-                is_enabled=True
+                is_active=True
             ).count()
             fiat_currencies = Currency.objects.filter(
                 currency_type=Currency.CurrencyType.FIAT,
-                is_enabled=True
+                is_active=True
             ).count()
             
             # Provider support
@@ -388,7 +395,7 @@ class CurrencyService(BaseService):
             
             # Network stats
             network_stats = Network.objects.filter(
-                is_enabled=True
+                is_active=True
             ).values('currency_code').annotate(
                 network_count=models.Count('id')
             ).order_by('-network_count')
@@ -415,14 +422,14 @@ class CurrencyService(BaseService):
         """Validate that currencies are supported."""
         try:
             # Check from_currency
-            if not Currency.objects.filter(code=from_currency, is_enabled=True).exists():
+            if not Currency.objects.filter(code=from_currency, is_active=True).exists():
                 return self._create_error_result(
                     f"Currency {from_currency} not supported",
                     "from_currency_not_supported"
                 )
             
             # Check to_currency
-            if not Currency.objects.filter(code=to_currency, is_enabled=True).exists():
+            if not Currency.objects.filter(code=to_currency, is_active=True).exists():
                 return self._create_error_result(
                     f"Currency {to_currency} not supported",
                     "to_currency_not_supported"
@@ -440,7 +447,7 @@ class CurrencyService(BaseService):
         """Perform currency service health check."""
         try:
             # Check database connectivity
-            currency_count = Currency.objects.filter(is_enabled=True).count()
+            currency_count = Currency.objects.filter(is_active=True).count()
             
             # Test currency conversion
             try: