django-cfg 1.2.21__py3-none-any.whl → 1.2.23__py3-none-any.whl

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

@@ -0,0 +1,293 @@
+"""
+NowPayments provider implementation.
+
+Enhanced crypto payment provider with minimal typing.
+"""
+
+import logging
+import requests
+import hashlib
+import hmac
+from typing import Optional, List
+from decimal import Decimal
+from pydantic import BaseModel, Field
+
+from .base import PaymentProvider
+from ..internal_types import ProviderResponse, WebhookData
+
+logger = logging.getLogger(__name__)
+
+
+class NowPaymentsConfig(BaseModel):
+    """NowPayments provider configuration."""
+    api_key: str = Field(..., description="NowPayments API key")
+    sandbox: bool = Field(default=False, description="Use sandbox mode")
+    ipn_secret: Optional[str] = Field(default=None, description="IPN secret for webhook validation")
+    callback_url: Optional[str] = Field(default=None, description="Webhook callback URL")
+    success_url: Optional[str] = Field(default=None, description="Payment success redirect URL")
+    cancel_url: Optional[str] = Field(default=None, description="Payment cancel redirect URL")
+    enabled: bool = Field(default=True, description="Provider enabled")
+
+
+class NowPaymentsProvider(PaymentProvider):
+    """NowPayments cryptocurrency payment provider."""
+    
+    def __init__(self, config: NowPaymentsConfig):
+        """Initialize NowPayments provider."""
+        super().__init__(config.dict())
+        self.config = config
+        self.api_key = config.api_key
+        self.sandbox = config.sandbox
+        self.ipn_secret = config.ipn_secret or ''
+        self.base_url = self._get_base_url()
+        
+        # Configurable URLs 
+        self.callback_url = config.callback_url
+        self.success_url = config.success_url
+        self.cancel_url = config.cancel_url
+        
+        self.headers = {
+            'x-api-key': self.api_key,
+            'Content-Type': 'application/json'
+        }
+    
+    def _get_base_url(self) -> str:
+        """Get base URL based on sandbox mode."""
+        if self.sandbox:
+            return 'https://api-sandbox.nowpayments.io/v1'
+        return 'https://api.nowpayments.io/v1'
+    
+    def _make_request(self, method: str, endpoint: str, data: Optional[dict] = None) -> Optional[dict]:
+        """Make HTTP request to NowPayments API with error handling."""
+        try:
+            url = f"{self.base_url}/{endpoint}"
+            
+            response = requests.request(
+                method=method,
+                url=url,
+                headers=self.headers,
+                json=data,
+                timeout=30
+            )
+            
+            response.raise_for_status()
+            return response.json()
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"NowPayments API request failed: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Unexpected error in NowPayments request: {e}")
+            return None
+    
+    def create_payment(self, payment_data: dict) -> ProviderResponse:
+        """Create payment via NowPayments API."""
+        try:
+            amount = Decimal(str(payment_data['amount']))
+            currency = payment_data['currency']
+            order_id = payment_data.get('order_id', f'payment_{int(amount * 100)}_{currency}')
+            
+            payment_request = {
+                'price_amount': float(amount),
+                'price_currency': 'usd',  # Base currency
+                'pay_currency': currency,
+                'order_id': order_id,
+                'order_description': payment_data.get('description', f'Payment {order_id}'),
+            }
+            
+            # Add optional URLs
+            if self.success_url:
+                payment_request['success_url'] = self.success_url
+            if self.cancel_url:
+                payment_request['cancel_url'] = self.cancel_url
+            if self.callback_url:
+                payment_request['ipn_callback_url'] = self.callback_url
+            
+            response = self._make_request('POST', 'payment', payment_request)
+            
+            if response:
+                return ProviderResponse(
+                    success=True,
+                    provider_payment_id=response.get('payment_id'),
+                    payment_url=response.get('invoice_url'),
+                    pay_address=response.get('pay_address'),
+                    amount=Decimal(str(response.get('pay_amount', 0))),
+                    currency=response.get('pay_currency'),
+                    status='pending'
+                )
+            else:
+                return ProviderResponse(
+                    success=False,
+                    error_message='Failed to create payment'
+                )
+                
+        except Exception as e:
+            logger.error(f"NowPayments create_payment error: {e}")
+            return ProviderResponse(
+                success=False,
+                error_message=str(e)
+            )
+    
+    def check_payment_status(self, payment_id: str) -> ProviderResponse:
+        """Check payment status via NowPayments API."""
+        try:
+            response = self._make_request('GET', f'payment/{payment_id}')
+            
+            if response:
+                # Map NowPayments status to universal status
+                status_mapping = {
+                    'waiting': 'pending',
+                    'confirming': 'processing',
+                    'confirmed': 'completed',
+                    'sending': 'processing',
+                    'partially_paid': 'pending',
+                    'finished': 'completed',
+                    'failed': 'failed',
+                    'refunded': 'refunded',
+                    'expired': 'expired'
+                }
+                
+                provider_status = response.get('payment_status', 'unknown')
+                universal_status = status_mapping.get(provider_status, 'unknown')
+                
+                return ProviderResponse(
+                    success=True,
+                    provider_payment_id=response.get('payment_id'),
+                    status=universal_status,
+                    pay_address=response.get('pay_address'),
+                    amount=Decimal(str(response.get('pay_amount', 0))),
+                    currency=response.get('pay_currency')
+                )
+            else:
+                return ProviderResponse(
+                    success=False,
+                    error_message='Payment not found'
+                )
+                
+        except Exception as e:
+            logger.error(f"NowPayments check_payment_status error: {e}")
+            return ProviderResponse(
+                success=False,
+                error_message=str(e)
+            )
+    
+    def process_webhook(self, payload: dict) -> WebhookData:
+        """Process NowPayments webhook."""
+        try:
+            # Map status
+            status_mapping = {
+                'waiting': 'pending',
+                'confirming': 'processing', 
+                'confirmed': 'completed',
+                'sending': 'processing',
+                'partially_paid': 'pending',
+                'finished': 'completed',
+                'failed': 'failed',
+                'refunded': 'refunded',
+                'expired': 'expired'
+            }
+            
+            provider_status = payload.get('payment_status', 'unknown')
+            universal_status = status_mapping.get(provider_status, 'unknown')
+            
+            return WebhookData(
+                provider_payment_id=str(payload.get('payment_id', '')),
+                status=universal_status,
+                pay_amount=Decimal(str(payload.get('pay_amount', 0))),
+                actually_paid=Decimal(str(payload.get('actually_paid', 0))),
+                order_id=payload.get('order_id'),
+                signature=payload.get('signature')
+            )
+            
+        except Exception as e:
+            logger.error(f"NowPayments webhook processing error: {e}")
+            raise
+    
+    def get_supported_currencies(self) -> List[str]:
+        """Get list of supported currencies."""
+        try:
+            response = self._make_request('GET', 'currencies')
+            
+            if response and 'currencies' in response:
+                return response['currencies']
+            else:
+                # Fallback currencies
+                return ['BTC', 'ETH', 'LTC', 'BCH', 'XMR', 'TRX', 'BNB']
+                
+        except Exception as e:
+            logger.error(f"Error getting supported currencies: {e}")
+            return ['BTC', 'ETH', 'LTC']  # Minimal fallback
+    
+    def get_minimum_payment_amount(self, currency_from: str, currency_to: str = 'usd') -> Optional[Decimal]:
+        """Get minimum payment amount for currency pair."""
+        try:
+            response = self._make_request('GET', 'min-amount', {
+                'currency_from': currency_from,
+                'currency_to': currency_to
+            })
+            
+            if response and 'min_amount' in response:
+                return Decimal(str(response['min_amount']))
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Error getting minimum amount: {e}")
+            return None
+    
+    def estimate_payment_amount(self, amount: Decimal, currency_code: str) -> Optional[dict]:
+        """Estimate payment amount in target currency."""
+        try:
+            response = self._make_request('GET', 'estimate', {
+                'amount': float(amount),
+                'currency_from': 'usd',
+                'currency_to': currency_code
+            })
+            
+            if response and 'estimated_amount' in response:
+                return {
+                    'estimated_amount': Decimal(str(response['estimated_amount'])),
+                    'currency_from': response.get('currency_from'),
+                    'currency_to': response.get('currency_to'),
+                    'fee_amount': Decimal(str(response.get('fee_amount', 0)))
+                }
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Error estimating payment amount: {e}")
+            return None
+    
+    def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
+        """Validate NowPayments webhook signature."""
+        try:
+            if not self.ipn_secret:
+                logger.warning("IPN secret not configured, skipping webhook validation")
+                return True
+            
+            if not headers:
+                logger.warning("No headers provided for webhook validation")
+                return False
+            
+            # Get signature from headers
+            signature = headers.get('x-nowpayments-sig')
+            if not signature:
+                logger.warning("No signature found in webhook headers")
+                return False
+            
+            # TODO: Implement proper HMAC signature validation
+            # This requires the raw payload body for proper validation
+            logger.info("Webhook signature validation placeholder")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Webhook validation error: {e}")
+            return False
+    
+    def check_api_status(self) -> bool:
+        """Check if NowPayments API is available."""
+        try:
+            response = self._make_request('GET', 'status')
+            return response is not None and response.get('message') == 'OK'
+        except:
+            return False

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

@@ -0,0 +1,99 @@
+"""
+Provider registry for managing payment providers.
+
+Central registry with lazy loading and typed configuration.
+"""
+
+import logging
+from typing import Optional, List
+
+from .base import PaymentProvider
+from .nowpayments import NowPaymentsProvider, NowPaymentsConfig
+from .cryptapi import CryptAPIProvider, CryptAPIConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ProviderRegistry:
+    """Central registry for payment providers with typed configs."""
+    
+    def __init__(self):
+        """Initialize registry with lazy loading."""
+        self._providers: dict[str, PaymentProvider] = {}
+        self._provider_configs: dict[str, dict] = {}
+        self._load_configurations()
+    
+    def _load_configurations(self) -> None:
+        """Load provider configurations."""
+        try:
+            from ...utils.config_utils import get_payments_config
+            config = get_payments_config()
+            
+            self._provider_configs = {}
+            for provider_name, provider_config in config.providers.items():
+                if provider_config.enabled:
+                    self._provider_configs[provider_name] = provider_config.get_config_dict()
+                    
+        except Exception as e:
+            logger.warning(f"Failed to load provider configurations: {e}")
+            self._provider_configs = {}
+    
+    def _create_provider(self, name: str, config_dict: dict) -> Optional[PaymentProvider]:
+        """Create provider instance from configuration with typed config."""
+        try:
+            if name == 'nowpayments':
+                config = NowPaymentsConfig(**config_dict)
+                return NowPaymentsProvider(config)
+            elif name == 'cryptapi':
+                config = CryptAPIConfig(**config_dict)
+                return CryptAPIProvider(config)
+            elif name == 'stripe':
+                # TODO: Implement StripeProvider with StripeConfig
+                return None
+            else:
+                logger.warning(f"Unknown provider type: {name}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Failed to create provider {name}: {e}")
+            return None
+    
+    def register_provider(self, name: str, provider: PaymentProvider) -> None:
+        """Register a payment provider instance."""
+        self._providers[name] = provider
+    
+    def get_provider(self, name: str) -> Optional[PaymentProvider]:
+        """Get provider by name with lazy loading."""
+        # Check if already loaded
+        if name in self._providers:
+            return self._providers[name]
+        
+        # Try to load from configuration
+        if name in self._provider_configs:
+            provider = self._create_provider(name, self._provider_configs[name])
+            if provider:
+                self._providers[name] = provider
+                return provider
+        
+        return None
+    
+    def list_providers(self) -> List[str]:
+        """Get list of available providers."""
+        available = set(self._providers.keys())
+        available.update(self._provider_configs.keys())
+        return list(available)
+    
+    def get_active_providers(self) -> List[str]:
+        """Get list of active providers."""
+        active = []
+        for name in self.list_providers():
+            provider = self.get_provider(name)
+            if provider and provider.is_enabled():
+                active.append(name)
+        return active
+    
+    def reload_providers(self) -> None:
+        """Reload all providers from configuration."""
+        logger.info("Reloading providers from configuration")
+        self._providers.clear()
+        self._load_configurations()

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

@@ -0,0 +1,8 @@
+"""
+Validators for payment services.
+
+TODO: Implement payment validators when needed.
+"""
+
+# Placeholder for future validators
+__all__ = []

django_cfg/apps/payments/signals/__init__.py

@@ -0,0 +1,13 @@
+"""
+Universal Payment Signals.
+
+Automatically imports all signal handlers when the payments app is loaded.
+"""
+
+from .api_key_signals import *  # noqa: F401,F403
+from .payment_signals import *  # noqa: F401,F403
+from .subscription_signals import *  # noqa: F401,F403
+
+__all__ = [
+    # Signal functions are automatically exported by Django
+]

django_cfg/apps/payments/signals/api_key_signals.py

@@ -0,0 +1,150 @@
+"""
+🔄 Universal API Keys Auto-Creation Signals
+
+Automatic API key creation and management via Django signals.
+Enhanced version of CarAPI signals with universal support.
+"""
+
+from django.db.models.signals import post_save, post_delete, pre_save
+from django.dispatch import receiver
+from django.contrib.auth import get_user_model
+from django.db import transaction
+from django.utils import timezone
+import logging
+
+from ..models import APIKey
+
+User = get_user_model()
+logger = logging.getLogger(__name__)
+
+
+@receiver(post_save, sender=User)
+def create_default_api_key(sender, instance, created, **kwargs):
+    """
+    Automatically create default API key for new users.
+    This ensures every user can immediately start using the API.
+    """
+    if created:
+        try:
+            with transaction.atomic():
+                api_key = APIKey.objects.create(
+                    user=instance,
+                    name="Default API Key",
+                    is_active=True
+                )
+                
+                logger.info(
+                    f"Created default API key for user {instance.email}: {api_key.key_prefix}***"
+                )
+                
+                # Optional: Send welcome email with API key info
+                # This would be handled in custom project implementations
+                # from .tasks import send_api_key_welcome_email
+                # send_api_key_welcome_email.delay(instance.id, api_key.id)
+                
+        except Exception as e:
+            logger.error(f"Failed to create default API key for user {instance.email}: {e}")
+
+
+@receiver(post_save, sender=User)
+def ensure_user_has_api_key(sender, instance, **kwargs):
+    """
+    Ensure user always has at least one API key.
+    Creates one if user has no active keys.
+    """
+    # Skip if this is a new user (handled by create_default_api_key)
+    if kwargs.get('created', False):
+        return
+    
+    # Check if user has any active keys
+    if not APIKey.objects.filter(user=instance, is_active=True).exists():
+        try:
+            with transaction.atomic():
+                api_key = APIKey.objects.create(
+                    user=instance,
+                    name="Recovery API Key",
+                    is_active=True
+                )
+                logger.info(
+                    f"Created recovery API key for user {instance.email}: {api_key.key_prefix}***"
+                )
+        except Exception as e:
+            logger.error(f"Failed to create recovery API key for user {instance.email}: {e}")
+
+
+@receiver(pre_save, sender=APIKey)
+def store_original_status(sender, instance, **kwargs):
+    """Store original status for change detection."""
+    if instance.pk:
+        try:
+            old_instance = APIKey.objects.get(pk=instance.pk)
+            instance._original_is_active = old_instance.is_active
+        except APIKey.DoesNotExist:
+            instance._original_is_active = None
+
+
+@receiver(post_save, sender=APIKey)
+def log_api_key_changes(sender, instance, created, **kwargs):
+    """Log API key creation and status changes for security monitoring."""
+    if created:
+        logger.info(
+            f"New API key created: {instance.name} ({instance.key_prefix}***) "
+            f"for user {instance.user.email}"
+        )
+    else:
+        # Check if status changed
+        if hasattr(instance, '_original_is_active'):
+            old_status = instance._original_is_active
+            new_status = instance.is_active
+            
+            if old_status is not None and old_status != new_status:
+                status_text = "activated" if new_status else "deactivated"
+                logger.warning(
+                    f"API key {status_text}: {instance.name} ({instance.key_prefix}***) "
+                    f"for user {instance.user.email}"
+                )
+
+
+@receiver(post_save, sender=APIKey)
+def update_last_used_on_activation(sender, instance, created, **kwargs):
+    """Update last_used when API key is activated."""
+    if not created and instance.is_active and hasattr(instance, '_original_is_active'):
+        if instance._original_is_active is False and instance.is_active is True:
+            # Key was just activated
+            APIKey.objects.filter(pk=instance.pk).update(
+                last_used=timezone.now()
+            )
+
+
+@receiver(post_delete, sender=APIKey)
+def log_api_key_deletion(sender, instance, **kwargs):
+    """Log API key deletions for security audit."""
+    logger.warning(
+        f"API key deleted: {instance.name} ({instance.key_prefix}***) "
+        f"for user {instance.user.email} - Status was: {'active' if instance.is_active else 'inactive'}"
+    )
+
+
+@receiver(post_delete, sender=APIKey)
+def ensure_user_has_remaining_key(sender, instance, **kwargs):
+    """
+    Ensure user still has at least one API key after deletion.
+    Creates a new one if this was the last active key.
+    """
+    user = instance.user
+    
+    # Check if user has any remaining active keys
+    if not APIKey.objects.filter(user=user, is_active=True).exists():
+        try:
+            with transaction.atomic():
+                api_key = APIKey.objects.create(
+                    user=user,
+                    name="Auto Recovery API Key",
+                    is_active=True
+                )
+                logger.info(
+                    f"Created auto-recovery API key for user {user.email}: {api_key.key_prefix}*** "
+                    f"(previous key was deleted)"
+                )
+        except Exception as e:
+            logger.error(f"Failed to create auto-recovery API key for user {user.email}: {e}")

django_cfg/apps/payments/signals/payment_signals.py

@@ -0,0 +1,127 @@
+"""
+🔄 Universal Payment Signals
+
+Automatic payment processing and balance management via Django signals.
+"""
+
+from django.db.models.signals import post_save, pre_save
+from django.dispatch import receiver
+from django.db import transaction
+from django.utils import timezone
+import logging
+
+from ..models import UniversalPayment, UserBalance, Transaction
+from ..services.cache import SimpleCache
+
+logger = logging.getLogger(__name__)
+
+
+@receiver(pre_save, sender=UniversalPayment)
+def store_original_payment_status(sender, instance, **kwargs):
+    """Store original payment status for change detection."""
+    if instance.pk:
+        try:
+            old_instance = UniversalPayment.objects.get(pk=instance.pk)
+            instance._original_status = old_instance.status
+        except UniversalPayment.DoesNotExist:
+            instance._original_status = None
+
+
+@receiver(post_save, sender=UniversalPayment)
+def process_payment_status_changes(sender, instance, created, **kwargs):
+    """Process payment status changes and update user balance."""
+    if created:
+        logger.info(f"New payment created: {instance.internal_payment_id} for user {instance.user.email}")
+        return
+    
+    # Check if status changed to completed
+    if hasattr(instance, '_original_status'):
+        old_status = instance._original_status
+        new_status = instance.status
+        
+        if old_status != new_status:
+            logger.info(
+                f"Payment status changed: {instance.internal_payment_id} "
+                f"for user {instance.user.email} - {old_status} → {new_status}"
+            )
+            
+            # Process completed payment
+            if new_status == UniversalPayment.PaymentStatus.COMPLETED and old_status != new_status:
+                _process_completed_payment(instance)
+
+
+def _process_completed_payment(payment: UniversalPayment):
+    """Process completed payment and add funds to user balance."""
+    try:
+        with transaction.atomic():
+            # Get or create user balance
+            balance, created = UserBalance.objects.get_or_create(
+                user=payment.user,
+                defaults={
+                    'amount_usd': 0,
+                    'reserved_usd': 0
+                }
+            )
+            
+            # Add funds to balance
+            old_balance = balance.amount_usd
+            balance.amount_usd += payment.amount_usd
+            balance.save()
+            
+            # Create transaction record
+            Transaction.objects.create(
+                user=payment.user,
+                transaction_type=Transaction.TransactionType.PAYMENT,
+                amount_usd=payment.amount_usd,
+                balance_before=old_balance,
+                balance_after=balance.amount_usd,
+                description=f"Payment completed: {payment.internal_payment_id}",
+                payment=payment,
+                metadata={
+                    'provider': payment.provider,
+                    'provider_payment_id': payment.provider_payment_id,
+                    'original_amount': str(payment.original_amount),
+                    'original_currency': payment.original_currency
+                }
+            )
+            
+            # Mark payment as processed
+            payment.processed_at = timezone.now()
+            payment.save(update_fields=['processed_at'])
+            
+            # Clear Redis cache for user
+            try:
+                redis_service = RedisService()
+                redis_service.invalidate_user_cache(payment.user.id)
+            except Exception as e:
+                logger.warning(f"Failed to clear Redis cache for user {payment.user.id}: {e}")
+            
+            logger.info(
+                f"Payment {payment.internal_payment_id} processed successfully. "
+                f"User {payment.user.email} balance: ${balance.amount_usd}"
+            )
+            
+    except Exception as e:
+        logger.error(f"Error processing completed payment {payment.internal_payment_id}: {e}")
+        raise
+
+
+@receiver(post_save, sender=UniversalPayment)
+def log_payment_webhook_data(sender, instance, created, **kwargs):
+    """Log webhook data for audit purposes."""
+    if not created and instance.webhook_data:
+        logger.info(
+            f"Webhook data received for payment {instance.internal_payment_id}: "
+            f"status={instance.status}, provider={instance.provider}"
+        )
+
+
+@receiver(post_save, sender=Transaction)
+def log_transaction_creation(sender, instance, created, **kwargs):
+    """Log transaction creation for audit trail."""
+    if created:
+        logger.info(
+            f"New transaction: {instance.transaction_type} "
+            f"${instance.amount_usd} for user {instance.user.email} "
+            f"(balance: ${instance.balance_after})"
+        )