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

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

@@ -16,6 +16,7 @@ from ..types import (
     PaymentCreateRequest, PaymentStatusRequest, PaymentResult,
     PaymentData, ServiceOperationResult
 )
+from ...models.managers.payment_managers import PaymentStatusUpdateFields
 from ...models import UniversalPayment, Currency, ProviderCurrency
 from ..providers import ProviderRegistry, get_provider_registry
 
@@ -49,12 +50,6 @@ class PaymentService(BaseService):
             if isinstance(request, dict):
                 request = PaymentCreateRequest(**request)
             
-            self.logger.info("Creating payment", extra={
-                'user_id': request.user_id,
-                'amount_usd': request.amount_usd,
-                'currency_code': request.currency_code,
-                'provider': request.provider
-            })
             
             # Get user
             try:
@@ -94,6 +89,7 @@ class PaymentService(BaseService):
                     network=currency.native_networks.first(),  # Use first native network
                     provider=request.provider,
                     status=UniversalPayment.PaymentStatus.PENDING,
+                    status_changed_at=timezone.now(),  # Track initial status setting
                     callback_url=request.callback_url,
                     cancel_url=request.cancel_url,
                     description=request.description,
@@ -103,12 +99,16 @@ class PaymentService(BaseService):
             
             payment = self._execute_with_transaction(create_payment_transaction)
             
+            
             # Create payment with provider
-            from ..providers.base import PaymentRequest as ProviderPaymentRequest
+            from ..providers.models import PaymentRequest as ProviderPaymentRequest
+            
+            # Use provider_currency_code from metadata if available, otherwise use original currency_code
+            provider_currency_code = request.metadata.get('provider_currency_code', request.currency_code)
             
             provider_request = ProviderPaymentRequest(
                 amount_usd=request.amount_usd,
-                currency_code=request.currency_code,
+                currency_code=provider_currency_code,  # Use provider-specific currency code
                 order_id=str(payment.id),
                 callback_url=request.callback_url,
                 cancel_url=request.cancel_url,
@@ -118,50 +118,75 @@ class PaymentService(BaseService):
             
             provider_response = provider.create_payment(provider_request)
             
+            
             # Update payment with provider response
             if provider_response.success:
                 def update_payment_transaction():
                     payment.provider_payment_id = provider_response.provider_payment_id
-                    payment.crypto_amount = provider_response.amount
+                    payment.pay_amount = provider_response.amount  # Fix: use pay_amount instead of crypto_amount
                     payment.payment_url = provider_response.payment_url
                     payment.qr_code_url = provider_response.qr_code_url
-                    payment.wallet_address = provider_response.wallet_address
+                    payment.pay_address = provider_response.wallet_address  # Fix: use pay_address instead of wallet_address
                     if provider_response.expires_at:
                         payment.expires_at = provider_response.expires_at
                     payment.save()
                     return payment
                 
                 payment = self._execute_with_transaction(update_payment_transaction)
+                
+                # Convert to PaymentData using our helper method
+                payment_data = self._convert_payment_to_data(payment)
+                
+                self._log_operation(
+                    "create_payment",
+                    True,
+                    payment_id=str(payment.id),
+                    user_id=request.user_id,
+                    amount_usd=request.amount_usd
+                )
+                
+                return PaymentResult(
+                    success=True,
+                    message="Payment created successfully",
+                    payment_id=str(payment.id),
+                    status=payment.status,
+                    amount_usd=payment.amount_usd,
+                    crypto_amount=payment.pay_amount,
+                    currency_code=payment.currency.code,
+                    payment_url=payment.payment_url,
+                    expires_at=payment.expires_at,
+                    data={'payment': payment_data.model_dump()}
+                )
+                
             else:
                 # Mark payment as failed if provider creation failed
+                self.logger.error("❌ PAYMENT SERVICE: Provider creation failed", extra={
+                    'payment_id': str(payment.id),
+                    'provider_error': getattr(provider_response, 'error_message', 'Unknown error')
+                })
                 payment.mark_failed(
                     reason=provider_response.error_message,
                     error_code="provider_creation_failed"
                 )
-            
-            # Convert to PaymentData using our helper method
-            payment_data = self._convert_payment_to_data(payment)
-            
-            self._log_operation(
-                "create_payment",
-                True,
-                payment_id=str(payment.id),
-                user_id=request.user_id,
-                amount_usd=request.amount_usd
-            )
-            
-            return PaymentResult(
-                success=True,
-                message="Payment created successfully",
-                payment_id=str(payment.id),
-                status=payment.status,
-                amount_usd=payment.amount_usd,
-                crypto_amount=payment.pay_amount,
-                currency_code=payment.currency.code,
-                payment_url=payment.payment_url,
-                expires_at=payment.expires_at,
-                data={'payment': payment_data.model_dump()}
-            )
+                
+                # Return error result when provider fails
+                self._log_operation(
+                    "create_payment",
+                    False,
+                    payment_id=str(payment.id),
+                    user_id=request.user_id,
+                    amount_usd=request.amount_usd,
+                    error=provider_response.error_message
+                )
+                
+                return PaymentResult(
+                    success=False,
+                    message=provider_response.error_message or "Payment creation failed",
+                    error_code="provider_creation_failed",
+                    payment_id=str(payment.id),
+                    status=payment.status,
+                    data={'error_details': getattr(provider_response, 'raw_response', {})}
+                )
             
         except Exception as e:
             return PaymentResult(**self._handle_exception(
@@ -362,21 +387,114 @@ class PaymentService(BaseService):
             )
     
     def _check_provider_status(self, payment: UniversalPayment) -> ServiceOperationResult:
-        """Check payment status with provider."""
+        """Check payment status with provider and update database if needed."""
         try:
-            # This would integrate with provider services
-            # For now, return success without changes
+            if not payment.provider_payment_id:
+                return self._create_success_result(
+                    "No provider payment ID, skipping provider check",
+                    {'status_changed': False}
+                )
+            
+            # Get provider instance
+            provider = self.provider_registry.get_provider(payment.provider)
+            if not provider:
+                return self._create_error_result(
+                    f"Provider {payment.provider} not available",
+                    "provider_not_available"
+                )
+            
+            # Check status with provider
+            provider_response = provider.get_payment_status(payment.provider_payment_id)
+            
+            if not provider_response.success:
+                self.logger.warning(f"Provider status check failed for payment {payment.id}", extra={
+                    'payment_id': str(payment.id),
+                    'provider_payment_id': payment.provider_payment_id,
+                    'error': provider_response.error_message
+                })
+                return self._create_error_result(
+                    f"Provider status check failed: {provider_response.error_message}",
+                    "provider_check_failed"
+                )
+            
+            # Map provider status to our status
+            original_status = payment.status
+            new_status = self._map_provider_status(provider_response.status, payment.provider)
+            
+            status_changed = False
+            
+            # Update payment if status changed
+            if new_status and new_status != original_status:
+                def update_payment_transaction():
+                    nonlocal status_changed
+                    
+                    # Update status
+                    payment.status = new_status
+                    payment.status_changed_at = timezone.now()  # Track when status changed
+                    
+                    # Update other fields from provider response
+                    if provider_response.transaction_hash and not payment.transaction_hash:
+                        payment.transaction_hash = provider_response.transaction_hash
+                    
+                    if provider_response.confirmations_count is not None:
+                        payment.confirmations_count = provider_response.confirmations_count
+                    
+                    # Mark as completed if status is completed/confirmed
+                    if new_status in ['completed', 'confirmed'] and not payment.completed_at:
+                        payment.completed_at = timezone.now()
+                    
+                    payment.save()
+                    status_changed = True
+                    
+                    return True
+                
+                # Execute in transaction
+                self._execute_with_transaction(update_payment_transaction)
+                
+                self.logger.info(f"Payment status updated from provider", extra={
+                    'payment_id': str(payment.id),
+                    'provider_payment_id': payment.provider_payment_id,
+                    'status_change': f"{original_status} -> {new_status}",
+                    'provider': payment.provider
+                })
+            
             return self._create_success_result(
-                "Provider status checked",
-                {'status_changed': False}
+                f"Provider status checked: {original_status} -> {new_status}" if status_changed else "No status change",
+                {
+                    'status_changed': status_changed,
+                    'original_status': original_status,
+                    'new_status': new_status,
+                    'provider_response': provider_response.raw_response
+                }
             )
             
         except Exception as e:
+            self.logger.error(f"Provider status check failed", extra={
+                'payment_id': str(payment.id),
+                'error': str(e)
+            })
             return self._create_error_result(
                 f"Provider check failed: {e}",
                 "provider_check_failed"
             )
     
+    def _map_provider_status(self, provider_status: str, provider: str) -> Optional[str]:
+        """Map provider-specific status to universal status."""
+        if provider == 'nowpayments':
+            status_mapping = {
+                'waiting': 'pending',
+                'confirming': 'confirming', 
+                'confirmed': 'confirmed',
+                'finished': 'completed',
+                'failed': 'failed',
+                'refunded': 'refunded',
+                'expired': 'expired'
+            }
+            return status_mapping.get(provider_status.lower())
+        
+        # Default mapping for unknown providers
+        return provider_status.lower() if provider_status else None
+    
     def get_user_payments(
         self, 
         user_id: int, 
@@ -477,3 +595,112 @@ class PaymentService(BaseService):
             
         except Exception as e:
             return self._handle_exception("get_payment_stats", e)
+    
+    def _check_provider_status(self, payment: 'UniversalPayment') -> ServiceOperationResult:
+        """
+        Check payment status with provider and update if changed.
+        
+        Args:
+            payment: Payment object to check
+            
+        Returns:
+            ServiceOperationResult: Result with status_changed flag
+        """
+        try:
+            from ..providers.registry import ProviderRegistry
+            from django.db import transaction
+            
+            self.logger.debug("Checking provider status", extra={
+                'payment_id': str(payment.id),
+                'current_status': payment.status,
+                'provider': payment.provider
+            })
+            
+            # Get provider instance
+            registry = ProviderRegistry()
+            provider = registry.get_provider(payment.provider)
+            
+            if not provider:
+                return self._create_error_result(
+                    f"Provider {payment.provider} not found",
+                    "provider_not_found"
+                )
+            
+            # Get status from provider
+            provider_response = provider.get_payment_status(payment.provider_payment_id)
+            
+            if not provider_response.success:
+                self.logger.warning("Provider status check failed", extra={
+                    'payment_id': str(payment.id),
+                    'provider': payment.provider,
+                    'error': provider_response.error_message
+                })
+                return self._create_error_result(
+                    f"Provider status check failed: {provider_response.error_message}",
+                    "provider_check_failed"
+                )
+            
+            # Map provider status to universal status
+            provider_status = provider_response.data.get('status', '').lower()
+            status_mapping = {
+                'waiting': UniversalPayment.PaymentStatus.PENDING,
+                'confirming': UniversalPayment.PaymentStatus.PENDING,
+                'confirmed': UniversalPayment.PaymentStatus.COMPLETED,
+                'sending': UniversalPayment.PaymentStatus.PENDING,
+                'partially_paid': UniversalPayment.PaymentStatus.PENDING,
+                'finished': UniversalPayment.PaymentStatus.COMPLETED,
+                'failed': UniversalPayment.PaymentStatus.FAILED,
+                'refunded': UniversalPayment.PaymentStatus.FAILED,
+                'expired': UniversalPayment.PaymentStatus.EXPIRED,
+            }
+            
+            new_status = status_mapping.get(provider_status, payment.status)
+            status_changed = new_status != payment.status
+            
+            # Update payment if status changed
+            if status_changed:
+                with transaction.atomic():
+                    # Prepare extra fields from provider response
+                    provider_data = provider_response.data
+                    
+                    extra_fields = PaymentStatusUpdateFields(
+                        transaction_hash=provider_data.get('transaction_hash'),
+                        confirmations_count=provider_data.get('confirmations_count')
+                    )
+                    
+                    # Use manager method for consistent status updates
+                    from ...models import UniversalPayment
+                    success = UniversalPayment.objects.update_payment_status(
+                        payment, new_status, extra_fields
+                    )
+                    
+                    if not success:
+                        return self._create_error_result(
+                            "Failed to update payment status",
+                            "status_update_failed"
+                        )
+                
+                self.logger.info("Payment status updated", extra={
+                    'payment_id': str(payment.id),
+                    'old_status': payment.status,
+                    'new_status': new_status,
+                    'provider_status': provider_status
+                })
+            
+            return self._create_success_result(
+                "Provider status checked",
+                {
+                    'status_changed': status_changed,
+                    'old_status': payment.status if not status_changed else None,
+                    'new_status': new_status,
+                    'provider_status': provider_status,
+                    'provider_response': provider_response.data
+                }
+            )
+            
+        except Exception as e:
+            self.logger.error("Error checking provider status", extra={
+                'payment_id': str(payment.id),
+                'error': str(e)
+            })
+            return self._handle_exception("_check_provider_status", e)

django_cfg/apps/payments/services/providers/__init__.py

@@ -7,6 +7,7 @@ Provider implementations with unified interface and Pydantic validation.
 from .base import BaseProvider
 from .nowpayments import NowPaymentsProvider
 from .registry import ProviderRegistry, get_provider_registry, initialize_providers
+from .sync_service import ProviderSyncService, get_provider_sync_service
 
 __all__ = [
     'BaseProvider',
@@ -14,4 +15,6 @@ __all__ = [
     'ProviderRegistry',
     'get_provider_registry',
     'initialize_providers',
+    'ProviderSyncService',
+    'get_provider_sync_service',
 ]