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

django_cfg/apps/payments/config/constance/settings.py

@@ -1,160 +0,0 @@
-"""
-Constance settings integration for Payments app.
-
-Simplified settings management using Pydantic models and Constance.
-"""
-
-from typing import Dict, Any, Optional
-from pydantic import BaseModel, Field
-from django_cfg.modules.django_logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class PaymentConstanceSettings(BaseModel):
-    """
-    Pydantic model for payments Constance settings.
-    
-    Provides type-safe access to dynamic settings with validation.
-    """
-    
-    # Core settings
-    enabled: bool = Field(default=True, description="Enable payments system")
-    middleware_enabled: bool = Field(default=True, description="Enable payments middleware")
-    
-    # Rate limiting
-    rate_limiting_enabled: bool = Field(default=True, description="Enable rate limiting")
-    anonymous_rate_limit: int = Field(default=60, description="Anonymous user rate limit")
-    authenticated_rate_limit: int = Field(default=300, description="Authenticated user rate limit")
-    
-    # Usage tracking
-    usage_tracking_enabled: bool = Field(default=True, description="Enable usage tracking")
-    track_anonymous_usage: bool = Field(default=False, description="Track anonymous usage")
-    
-    # Cache timeouts
-    api_key_cache_timeout: int = Field(default=300, description="API key cache timeout")
-    rate_limit_cache_timeout: int = Field(default=3600, description="Rate limit cache timeout")
-    session_cache_timeout: int = Field(default=1800, description="Session cache timeout")
-    default_cache_timeout: int = Field(default=600, description="Default cache timeout")
-    
-    # Provider settings
-    nowpayments_api_key: str = Field(default="", description="NowPayments API key")
-    nowpayments_ipn_secret: str = Field(default="", description="NowPayments IPN secret")
-    nowpayments_sandbox_mode: bool = Field(default=True, description="NowPayments sandbox mode")
-    
-    # Currency settings
-    auto_update_rates: bool = Field(default=True, description="Auto update currency rates")
-    rate_update_interval_hours: int = Field(default=1, description="Rate update interval")
-    
-    @classmethod
-    def from_constance(cls) -> 'PaymentConstanceSettings':
-        """
-        Create instance from Constance settings.
-        
-        Returns:
-            PaymentConstanceSettings instance with current Constance values
-        """
-        try:
-            from constance import config
-            from ..django_cfg_integration import PaymentsConfigManager
-            
-            # Get defaults from initialized Pydantic config using PaymentsConfigManager
-            pydantic_config = PaymentsConfigManager.get_payments_config()
-            
-            return cls(
-                # Static settings from Pydantic (not in Constance anymore)
-                enabled=pydantic_config.enabled,
-                middleware_enabled=pydantic_config.middleware_enabled,
-                rate_limiting_enabled=pydantic_config.rate_limiting_enabled,
-                anonymous_rate_limit=pydantic_config.default_rate_limits['anonymous'],
-                authenticated_rate_limit=pydantic_config.default_rate_limits['authenticated'],
-                usage_tracking_enabled=pydantic_config.usage_tracking_enabled,
-                
-                # Dynamic settings from Constance (only what's actually in Constance)
-                track_anonymous_usage=getattr(config, 'PAYMENTS_TRACK_ANONYMOUS_USAGE', pydantic_config.track_anonymous_usage),
-                
-                # Cache timeouts from Pydantic (not in Constance anymore)
-                api_key_cache_timeout=pydantic_config.cache_timeouts['api_key'],
-                rate_limit_cache_timeout=pydantic_config.cache_timeouts['rate_limit'],
-                session_cache_timeout=pydantic_config.cache_timeouts['session'],
-                default_cache_timeout=pydantic_config.cache_timeouts['default'],
-                
-                # Provider settings from Constance (sensitive data)
-                nowpayments_api_key=getattr(config, 'PAYMENTS_NOWPAYMENTS_API_KEY', ''),
-                nowpayments_ipn_secret=getattr(config, 'PAYMENTS_NOWPAYMENTS_IPN_SECRET', ''),
-                nowpayments_sandbox_mode=getattr(config, 'PAYMENTS_NOWPAYMENTS_SANDBOX_MODE', True),
-                
-                # Currency settings from Pydantic (automatic now)
-                auto_update_rates=True,  # Always automatic
-                rate_update_interval_hours=1,  # Fixed interval
-            )
-        except ImportError:
-            logger.warning("Constance not available, using default settings")
-            return cls()
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for easy access."""
-        return self.model_dump()
-    
-    def get_rate_limits(self) -> Dict[str, int]:
-        """Get rate limits as dictionary."""
-        return {
-            'anonymous': self.anonymous_rate_limit,
-            'authenticated': self.authenticated_rate_limit,
-        }
-    
-    def get_cache_timeouts(self) -> Dict[str, int]:
-        """Get cache timeouts as dictionary."""
-        return {
-            'api_key': self.api_key_cache_timeout,
-            'rate_limit': self.rate_limit_cache_timeout,
-            'session': self.session_cache_timeout,
-            'default': self.default_cache_timeout,
-        }
-    
-    def get_provider_config(self, provider: str) -> Dict[str, Any]:
-        """Get provider-specific configuration."""
-        if provider.lower() == 'nowpayments':
-            # Provider is enabled if it has API key configured
-            is_enabled = bool(self.nowpayments_api_key and self.nowpayments_api_key.strip())
-            return {
-                'enabled': is_enabled,
-                'api_key': self.nowpayments_api_key,
-                'ipn_secret': self.nowpayments_ipn_secret,
-                'sandbox_mode': self.nowpayments_sandbox_mode,
-            }
-        return {}
-
-
-def get_payment_settings() -> PaymentConstanceSettings:
-    """
-    Get current payment settings from Constance.
-    
-    Returns:
-        PaymentConstanceSettings instance with current values
-    """
-    return PaymentConstanceSettings.from_constance()
-
-
-def is_feature_enabled(feature: str) -> bool:
-    """
-    Check if a specific feature is enabled.
-    
-    Args:
-        feature: Feature name (e.g., 'rate_limiting', 'usage_tracking')
-        
-    Returns:
-        True if feature is enabled, False otherwise
-    """
-    settings = get_payment_settings()
-    
-    feature_map = {
-        'payments': settings.enabled,
-        'middleware': settings.middleware_enabled,
-        'rate_limiting': settings.rate_limiting_enabled,
-        'usage_tracking': settings.usage_tracking_enabled,
-        'anonymous_tracking': settings.track_anonymous_usage,
-        'auto_rates': settings.auto_update_rates,
-    }
-    
-    return feature_map.get(feature, False)

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

@@ -1,478 +0,0 @@
-"""
-NowPayments provider for the Universal Payment System v2.0.
-
-Implementation of NowPayments API integration with unified interface.
-"""
-
-from typing import Dict, Any, Optional, List
-from decimal import Decimal
-from datetime import datetime
-from pydantic import BaseModel, Field
-import hmac
-import hashlib
-import json
-
-from .base import BaseProvider, ProviderConfig, PaymentRequest
-from ..types import ProviderResponse, ServiceOperationResult, NowPaymentsWebhook
-from django_cfg.modules.django_currency import convert_currency
-
-
-class NowPaymentsConfig(ProviderConfig):
-    """
-    NowPayments-specific configuration.
-    
-    Extends base config with NowPayments-specific fields.
-    """
-    
-    ipn_secret: Optional[str] = Field(None, description="IPN callback secret")
-    
-    def __init__(self, **data):
-        """Initialize with NowPayments defaults."""
-        # Set NowPayments-specific defaults
-        if 'provider_name' not in data:
-            data['provider_name'] = 'nowpayments'
-        
-        if 'api_url' not in data:
-            sandbox = data.get('sandbox', False)
-            data['api_url'] = (
-                'https://api-sandbox.nowpayments.io/v1' if sandbox 
-                else 'https://api.nowpayments.io/v1'
-            )
-        
-        if 'supported_currencies' not in data:
-            data['supported_currencies'] = [
-                'BTC', 'ETH', 'LTC', 'XMR', 'USDT', 'USDC', 'ADA', 'DOT'
-            ]
-        
-        super().__init__(**data)
-
-
-class NowPaymentsProvider(BaseProvider):
-    """
-    NowPayments provider implementation.
-    
-    Handles payment creation, status checking, and webhook validation for NowPayments.
-    """
-    
-    def __init__(self, config: NowPaymentsConfig):
-        """Initialize NowPayments provider."""
-        super().__init__(config)
-        self.config: NowPaymentsConfig = config
-    
-    def create_payment(self, request: PaymentRequest) -> ProviderResponse:
-        """
-        Create payment with NowPayments.
-        
-        Args:
-            request: Payment creation request
-            
-        Returns:
-            ProviderResponse: NowPayments response
-        """
-        try:
-            self.logger.info("Creating NowPayments payment", extra={
-                'amount_usd': request.amount_usd,
-                'currency': request.currency_code,
-                'order_id': request.order_id
-            })
-            
-            # Convert USD to crypto amount
-            try:
-                crypto_amount = convert_currency(
-                    request.amount_usd, 
-                    'USD', 
-                    request.currency_code
-                )
-            except Exception as e:
-                return self._create_provider_response(
-                    success=False,
-                    raw_response={'error': f'Currency conversion failed: {e}'},
-                    error_message=f'Currency conversion failed: {e}'
-                )
-            
-            # Prepare NowPayments request
-            payment_data = {
-                'price_amount': request.amount_usd,
-                'price_currency': 'USD',
-                'pay_currency': request.currency_code,
-                'order_id': request.order_id,
-                'order_description': request.description or f'Payment {request.order_id}',
-            }
-            
-            # Add optional fields
-            if request.callback_url:
-                payment_data['success_url'] = request.callback_url
-            
-            if request.cancel_url:
-                payment_data['cancel_url'] = request.cancel_url
-            
-            if request.customer_email:
-                payment_data['customer_email'] = request.customer_email
-            
-            # Add IPN callback URL (would be configured via webhook service)
-            if hasattr(self, '_ipn_callback_url'):
-                payment_data['ipn_callback_url'] = self._ipn_callback_url
-            
-            # Make API request
-            headers = {
-                'x-api-key': self.config.api_key
-            }
-            
-            response_data = self._make_request(
-                method='POST',
-                endpoint='payment',
-                data=payment_data,
-                headers=headers
-            )
-            
-            # Parse NowPayments response
-            if 'payment_id' in response_data:
-                # Successful payment creation
-                payment_url = response_data.get('invoice_url') or response_data.get('pay_url')
-                
-                return self._create_provider_response(
-                    success=True,
-                    raw_response=response_data,
-                    provider_payment_id=response_data['payment_id'],
-                    status='waiting',  # NowPayments initial status
-                    amount=Decimal(str(crypto_amount)),
-                    currency=request.currency_code,
-                    payment_url=payment_url,
-                    wallet_address=response_data.get('pay_address'),
-                    qr_code_url=response_data.get('qr_code_url'),
-                    expires_at=self._parse_expiry_time(response_data.get('expiration_estimate_date'))
-                )
-            else:
-                # Error response
-                error_message = response_data.get('message', 'Unknown error')
-                return self._create_provider_response(
-                    success=False,
-                    raw_response=response_data,
-                    error_message=error_message
-                )
-                
-        except Exception as e:
-            self.logger.error(f"NowPayments payment creation failed: {e}", extra={
-                'order_id': request.order_id
-            })
-            
-            return self._create_provider_response(
-                success=False,
-                raw_response={'error': str(e)},
-                error_message=f'Payment creation failed: {e}'
-            )
-    
-    def get_payment_status(self, provider_payment_id: str) -> ProviderResponse:
-        """
-        Get payment status from NowPayments.
-        
-        Args:
-            provider_payment_id: NowPayments payment ID
-            
-        Returns:
-            ProviderResponse: Current payment status
-        """
-        try:
-            self.logger.debug("Getting NowPayments payment status", extra={
-                'payment_id': provider_payment_id
-            })
-            
-            headers = {
-                'x-api-key': self.config.api_key
-            }
-            
-            response_data = self._make_request(
-                method='GET',
-                endpoint=f'payment/{provider_payment_id}',
-                headers=headers
-            )
-            
-            if 'payment_status' in response_data:
-                return self._create_provider_response(
-                    success=True,
-                    raw_response=response_data,
-                    provider_payment_id=provider_payment_id,
-                    status=response_data['payment_status'],
-                    amount=Decimal(str(response_data.get('pay_amount', 0))),
-                    currency=response_data.get('pay_currency'),
-                    wallet_address=response_data.get('pay_address')
-                )
-            else:
-                error_message = response_data.get('message', 'Payment not found')
-                return self._create_provider_response(
-                    success=False,
-                    raw_response=response_data,
-                    error_message=error_message
-                )
-                
-        except Exception as e:
-            self.logger.error(f"NowPayments status check failed: {e}", extra={
-                'payment_id': provider_payment_id
-            })
-            
-            return self._create_provider_response(
-                success=False,
-                raw_response={'error': str(e)},
-                error_message=f'Status check failed: {e}'
-            )
-    
-    def get_supported_currencies(self) -> ServiceOperationResult:
-        """
-        Get supported currencies from NowPayments.
-        
-        Returns:
-            ServiceOperationResult: List of supported currencies
-        """
-        try:
-            self.logger.debug("Getting NowPayments supported currencies")
-            
-            headers = {
-                'x-api-key': self.config.api_key
-            }
-            
-            response_data = self._make_request(
-                method='GET',
-                endpoint='currencies',
-                headers=headers
-            )
-            
-            if 'currencies' in response_data:
-                currencies = response_data['currencies']
-                
-                return ServiceOperationResult(
-                    success=True,
-                    message=f"Retrieved {len(currencies)} supported currencies",
-                    data={
-                        'currencies': currencies,
-                        'count': len(currencies),
-                        'provider': self.name
-                    }
-                )
-            else:
-                return ServiceOperationResult(
-                    success=False,
-                    message="Failed to get currencies from NowPayments",
-                    error_code="currencies_fetch_failed"
-                )
-                
-        except Exception as e:
-            self.logger.error(f"NowPayments currencies fetch failed: {e}")
-            
-            return ServiceOperationResult(
-                success=False,
-                message=f"Currencies fetch error: {e}",
-                error_code="currencies_fetch_error"
-            )
-    
-    def validate_webhook(self, payload: Dict[str, Any], signature: str = None) -> ServiceOperationResult:
-        """
-        Validate NowPayments IPN webhook.
-        
-        Args:
-            payload: Webhook payload
-            signature: HMAC signature (optional)
-            
-        Returns:
-            ServiceOperationResult: Validation result
-        """
-        try:
-            self.logger.debug("Validating NowPayments webhook", extra={
-                'has_signature': bool(signature),
-                'payment_id': payload.get('payment_id')
-            })
-            
-            # Validate payload structure
-            try:
-                webhook_data = NowPaymentsWebhook(**payload)
-            except Exception as e:
-                return ServiceOperationResult(
-                    success=False,
-                    message=f"Invalid webhook payload: {e}",
-                    error_code="invalid_payload"
-                )
-            
-            # Validate signature if provided and secret is configured
-            if signature and self.config.ipn_secret:
-                is_valid_signature = self._validate_ipn_signature(payload, signature)
-                if not is_valid_signature:
-                    return ServiceOperationResult(
-                        success=False,
-                        message="Invalid webhook signature",
-                        error_code="invalid_signature"
-                    )
-            
-            return ServiceOperationResult(
-                success=True,
-                message="Webhook validated successfully",
-                data={
-                    'provider': self.name,
-                    'payment_id': webhook_data.payment_id,
-                    'status': webhook_data.payment_status,
-                    'signature_validated': bool(signature and self.config.ipn_secret),
-                    'webhook_data': webhook_data.model_dump()
-                }
-            )
-            
-        except Exception as e:
-            self.logger.error(f"NowPayments webhook validation failed: {e}")
-            
-            return ServiceOperationResult(
-                success=False,
-                message=f"Webhook validation error: {e}",
-                error_code="validation_error"
-            )
-    
-    def get_exchange_rate(self, from_currency: str, to_currency: str) -> ServiceOperationResult:
-        """
-        Get exchange rate from NowPayments.
-        
-        Args:
-            from_currency: Source currency
-            to_currency: Target currency
-            
-        Returns:
-            ServiceOperationResult: Exchange rate
-        """
-        try:
-            self.logger.debug("Getting NowPayments exchange rate", extra={
-                'from': from_currency,
-                'to': to_currency
-            })
-            
-            headers = {
-                'x-api-key': self.config.api_key
-            }
-            
-            response_data = self._make_request(
-                method='GET',
-                endpoint=f'exchange-amount/{from_currency}-{to_currency}',
-                headers=headers
-            )
-            
-            if 'estimated_amount' in response_data:
-                rate = float(response_data['estimated_amount'])
-                
-                return ServiceOperationResult(
-                    success=True,
-                    message="Exchange rate retrieved",
-                    data={
-                        'from_currency': from_currency,
-                        'to_currency': to_currency,
-                        'rate': rate,
-                        'provider': self.name
-                    }
-                )
-            else:
-                return ServiceOperationResult(
-                    success=False,
-                    message="Exchange rate not available",
-                    error_code="rate_not_available"
-                )
-                
-        except Exception as e:
-            self.logger.error(f"NowPayments exchange rate failed: {e}")
-            
-            return ServiceOperationResult(
-                success=False,
-                message=f"Exchange rate error: {e}",
-                error_code="rate_fetch_error"
-            )
-    
-    def _validate_ipn_signature(self, payload: Dict[str, Any], signature: str) -> bool:
-        """
-        Validate IPN signature using HMAC-SHA512.
-        
-        Args:
-            payload: Webhook payload
-            signature: Received signature
-            
-        Returns:
-            bool: True if signature is valid
-        """
-        try:
-            # Sort payload and create canonical string
-            sorted_payload = json.dumps(payload, separators=(',', ':'), sort_keys=True)
-            
-            # Calculate expected signature
-            expected_signature = hmac.new(
-                self.config.ipn_secret.encode('utf-8'),
-                sorted_payload.encode('utf-8'),
-                hashlib.sha512
-            ).hexdigest()
-            
-            # Compare signatures
-            return hmac.compare_digest(expected_signature, signature)
-            
-        except Exception as e:
-            self.logger.error(f"Signature validation error: {e}")
-            return False
-    
-    def _parse_expiry_time(self, expiry_str: Optional[str]) -> Optional[datetime]:
-        """
-        Parse NowPayments expiry time string.
-        
-        Args:
-            expiry_str: Expiry time string from NowPayments
-            
-        Returns:
-            Optional[datetime]: Parsed expiry time
-        """
-        if not expiry_str:
-            return None
-        
-        try:
-            # NowPayments typically returns ISO format
-            return datetime.fromisoformat(expiry_str.replace('Z', '+00:00'))
-        except Exception:
-            self.logger.warning(f"Failed to parse expiry time: {expiry_str}")
-            return None
-    
-    def set_ipn_callback_url(self, callback_url: str):
-        """
-        Set IPN callback URL for payments.
-        
-        Args:
-            callback_url: IPN callback URL
-        """
-        self._ipn_callback_url = callback_url
-        self.logger.info(f"Set IPN callback URL: {callback_url}")
-    
-    def health_check(self) -> ServiceOperationResult:
-        """Perform NowPayments-specific health check."""
-        try:
-            # Test API connectivity by getting currencies
-            currencies_result = self.get_supported_currencies()
-            
-            if currencies_result.success:
-                currency_count = len(currencies_result.data.get('currencies', []))
-                
-                return ServiceOperationResult(
-                    success=True,
-                    message="NowPayments provider is healthy",
-                    data={
-                        'provider': self.name,
-                        'sandbox': self.is_sandbox,
-                        'api_url': self.config.api_url,
-                        'supported_currencies': currency_count,
-                        'has_ipn_secret': bool(self.config.ipn_secret),
-                        'api_key_configured': bool(self.config.api_key)
-                    }
-                )
-            else:
-                return ServiceOperationResult(
-                    success=False,
-                    message="NowPayments API connectivity failed",
-                    error_code="api_connectivity_failed",
-                    data={
-                        'provider': self.name,
-                        'error': currencies_result.message
-                    }
-                )
-                
-        except Exception as e:
-            return ServiceOperationResult(
-                success=False,
-                message=f"NowPayments health check error: {e}",
-                error_code="health_check_error",
-                data={'provider': self.name}
-            )