django-cfg 1.3.9__py3-none-any.whl → 1.3.13__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.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/base.py

@@ -7,9 +7,11 @@ Abstract base class for all payment providers with unified interface.
 from abc import ABC, abstractmethod
 from typing import Dict, Any, Optional
 from decimal import Decimal
+import requests
+from django.utils import timezone
 from django_cfg.modules.django_logger import get_logger
 from ..types import ProviderResponse, ServiceOperationResult
-from .models import ProviderConfig, PaymentRequest
+from .models import ProviderConfig, PaymentRequest, WithdrawalRequest
 
 
 class BaseProvider(ABC):
@@ -38,7 +40,7 @@ class BaseProvider(ABC):
     @property
     def is_sandbox(self) -> bool:
         """Check if provider is in sandbox mode."""
-        return self.config.sandbox
+        return self.config.sandbox_mode
     
     # Provider configuration methods (to be overridden by specific providers)
     def get_fee_percentage(self, currency_code: str = None, currency_type: str = None) -> Decimal:
@@ -149,6 +151,61 @@ class BaseProvider(ABC):
         """
         pass
     
+    def refresh_payment_status(self, provider_payment_id: str, force_update: bool = True) -> ProviderResponse:
+        """
+        Refresh payment status with enhanced error handling and caching control.
+        
+        This method provides additional functionality over get_payment_status:
+        - Enhanced error handling
+        - Optional caching control
+        - Detailed logging
+        
+        Args:
+            provider_payment_id: Provider's payment ID
+            force_update: Whether to bypass cache and force fresh data
+            
+        Returns:
+            ProviderResponse: Current payment status with enhanced metadata
+        """
+        self.logger.info(f"Refreshing payment status for {provider_payment_id}", extra={
+            'provider': self.name,
+            'payment_id': provider_payment_id,
+            'force_update': force_update
+        })
+        
+        try:
+            # Call the provider-specific implementation
+            result = self.get_payment_status(provider_payment_id)
+            
+            # Add refresh metadata
+            if result.success and hasattr(result, 'raw_response') and result.raw_response:
+                result.raw_response['_refresh_metadata'] = {
+                    'refreshed_at': timezone.now().isoformat(),
+                    'provider': self.name,
+                    'force_update': force_update
+                }
+            
+            self.logger.info(f"Payment status refreshed successfully", extra={
+                'provider': self.name,
+                'payment_id': provider_payment_id,
+                'status': getattr(result, 'status', 'unknown')
+            })
+            
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"Failed to refresh payment status", extra={
+                'provider': self.name,
+                'payment_id': provider_payment_id,
+                'error': str(e)
+            })
+            
+            return ProviderResponse(
+                success=False,
+                error_message=f"Failed to refresh payment status: {str(e)}",
+                raw_response={'error': str(e), 'provider': self.name}
+            )
+    
     @abstractmethod
     def get_supported_currencies(self) -> ServiceOperationResult:
         """
@@ -183,6 +240,129 @@ class BaseProvider(ABC):
         """
         pass
     
+    # Withdrawal/Payout Methods
+    
+    def supports_withdrawals(self) -> bool:
+        """
+        Check if provider supports withdrawals/payouts.
+        
+        Returns:
+            bool: True if provider supports withdrawals
+        """
+        return False  # Default: most payment processors don't support withdrawals
+    
+    def create_withdrawal(self, request: WithdrawalRequest) -> ProviderResponse:
+        """
+        Create withdrawal/payout request with provider.
+        
+        Args:
+            request: Withdrawal creation request
+            
+        Returns:
+            ProviderResponse: Provider response with withdrawal details
+            
+        Raises:
+            NotImplementedError: If provider doesn't support withdrawals
+        """
+        if not self.supports_withdrawals():
+            return ProviderResponse(
+                success=False,
+                error_message=f"Provider {self.name} does not support withdrawals",
+                raw_response={'error': 'withdrawals_not_supported'}
+            )
+        
+        raise NotImplementedError("Subclasses must implement create_withdrawal if they support withdrawals")
+    
+    def get_withdrawal_status(self, provider_withdrawal_id: str) -> ProviderResponse:
+        """
+        Get withdrawal status from provider.
+        
+        Args:
+            provider_withdrawal_id: Provider's withdrawal ID
+            
+        Returns:
+            ProviderResponse: Current withdrawal status
+            
+        Raises:
+            NotImplementedError: If provider doesn't support withdrawals
+        """
+        if not self.supports_withdrawals():
+            return ProviderResponse(
+                success=False,
+                error_message=f"Provider {self.name} does not support withdrawals",
+                raw_response={'error': 'withdrawals_not_supported'}
+            )
+        
+        raise NotImplementedError("Subclasses must implement get_withdrawal_status if they support withdrawals")
+    
+    def cancel_withdrawal(self, provider_withdrawal_id: str) -> ProviderResponse:
+        """
+        Cancel pending withdrawal.
+        
+        Args:
+            provider_withdrawal_id: Provider's withdrawal ID
+            
+        Returns:
+            ProviderResponse: Cancellation result
+            
+        Raises:
+            NotImplementedError: If provider doesn't support withdrawal cancellation
+        """
+        if not self.supports_withdrawals():
+            return ProviderResponse(
+                success=False,
+                error_message=f"Provider {self.name} does not support withdrawals",
+                raw_response={'error': 'withdrawals_not_supported'}
+            )
+        
+        return ProviderResponse(
+            success=False,
+            error_message=f"Provider {self.name} does not support withdrawal cancellation",
+            raw_response={'error': 'withdrawal_cancellation_not_supported'}
+        )
+    
+    def get_withdrawal_fees(self, currency_code: str) -> ServiceOperationResult:
+        """
+        Get withdrawal fees for specific currency.
+        
+        Args:
+            currency_code: Currency code
+            
+        Returns:
+            ServiceOperationResult: Fee information or not supported
+        """
+        if not self.supports_withdrawals():
+            return ServiceOperationResult(
+                success=False,
+                message=f"Provider {self.name} does not support withdrawals"
+            )
+        
+        return ServiceOperationResult(
+            success=False,
+            message="Withdrawal fee information not available"
+        )
+    
+    def get_minimum_withdrawal_amount(self, currency_code: str) -> ServiceOperationResult:
+        """
+        Get minimum withdrawal amount for specific currency.
+        
+        Args:
+            currency_code: Currency code
+            
+        Returns:
+            ServiceOperationResult: Minimum amount or not supported
+        """
+        if not self.supports_withdrawals():
+            return ServiceOperationResult(
+                success=False,
+                message=f"Provider {self.name} does not support withdrawals"
+            )
+        
+        return ServiceOperationResult(
+            success=False,
+            message="Minimum withdrawal amount information not available"
+        )
+    
     def get_exchange_rate(self, from_currency: str, to_currency: str) -> ServiceOperationResult:
         """
         Get exchange rate from provider (optional).
@@ -313,7 +493,33 @@ class BaseProvider(ABC):
         })
         
         # Handle response
-        response.raise_for_status()
+        try:
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as e:
+            # Log the error with response content for debugging
+            error_content = response.text if response.text else "No response content"
+            self.logger.error(f"HTTP {response.status_code} error from {self.name}", extra={
+                'status_code': response.status_code,
+                'error_content': error_content[:500],  # Limit content length
+                'url': response.url
+            })
+            
+            # Handle specific HTTP errors
+            if response.status_code == 403:
+                if "blocked" in error_content.lower() or "nowpayments.io" in error_content:
+                    raise Exception(f"IP address blocked by {self.name}. Please contact {self.name} support or use a different IP/VPN.")
+                else:
+                    raise Exception(f"Access forbidden by {self.name}. Check API key and permissions.")
+            elif response.status_code == 401:
+                raise Exception(f"Authentication failed with {self.name}. Check API key.")
+            elif response.status_code == 400:
+                raise Exception(f"Bad request to {self.name}: {error_content[:200]}")
+            elif response.status_code == 429:
+                raise Exception(f"Rate limit exceeded for {self.name}. Please try again later.")
+            elif response.status_code >= 500:
+                raise Exception(f"{self.name} server error ({response.status_code}). Please try again later.")
+            else:
+                raise Exception(f"HTTP {response.status_code} error from {self.name}: {error_content[:200]}")
         
         try:
             return response.json()

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

@@ -7,6 +7,7 @@ Common models used across all payment providers.
 from .base import (
     ProviderConfig,
     PaymentRequest,
+    WithdrawalRequest,
     ProviderMetadata,
     ProviderType,
     ProviderStatus
@@ -25,6 +26,7 @@ __all__ = [
     # Base models
     'ProviderConfig',
     'PaymentRequest',
+    'WithdrawalRequest',
     'ProviderMetadata',
     'ProviderType',
     'ProviderStatus',

django_cfg/apps/payments/services/providers/models/base.py

@@ -44,8 +44,7 @@ class ProviderConfig(BaseModel):
     api_key: str = Field(..., description="Provider API key")
     api_url: str = Field(..., description="Provider API URL")
     enabled: bool = Field(default=True, description="Whether provider is enabled")
-    sandbox: bool = Field(default=False, description="Sandbox mode")
-    sandbox_mode: bool = Field(default=False, description="Sandbox mode (alias for sandbox)")
+    sandbox_mode: bool = Field(default=False, description="Sandbox mode")
     timeout: int = Field(default=30, ge=5, le=300, description="Request timeout in seconds")
     retry_attempts: int = Field(default=3, ge=0, le=10, description="Number of retry attempts")
     retry_delay: int = Field(default=5, ge=1, le=60, description="Delay between retries in seconds")
@@ -77,6 +76,30 @@ class PaymentRequest(BaseModel):
     metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
 
 
+class WithdrawalRequest(BaseModel):
+    """
+    Universal withdrawal request for providers with Pydantic v2.
+    
+    Standardized withdrawal/payout request across all providers.
+    """
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid",
+        str_strip_whitespace=True
+    )
+    
+    amount: float = Field(..., gt=0, description="Withdrawal amount in crypto currency")
+    currency_code: str = Field(..., min_length=3, max_length=10, description="Cryptocurrency code")
+    destination_address: str = Field(..., min_length=10, description="Destination wallet address")
+    withdrawal_id: str = Field(..., min_length=1, max_length=100, description="Internal withdrawal ID")
+    callback_url: Optional[str] = Field(None, description="Withdrawal status callback URL")
+    description: Optional[str] = Field(None, max_length=500, description="Withdrawal description")
+    extra_id: Optional[str] = Field(None, description="Extra ID for destination (memo, tag, etc.)")
+    priority: Optional[str] = Field(default="normal", description="Transaction priority (low, normal, high)")
+    
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
 class ProviderMetadata(BaseModel):
     """
     Provider metadata with classification and features.