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

django_cfg/apps/payments/services/internal_types.py

@@ -0,0 +1,266 @@
+"""
+Internal Service Types - ONLY for inter-service communication.
+
+DO NOT duplicate Django ORM or DRF! Only for:
+1. Providers -> Services (external API response validation)
+2. Service -> Service (internal operations)
+3. Configuration (settings and parameters)
+"""
+
+from pydantic import BaseModel, Field, ConfigDict
+from decimal import Decimal
+from datetime import datetime
+from typing import Optional, Dict, Any
+from enum import Enum
+
+
+# =============================================================================
+# PROVIDERS - External API response validation
+# =============================================================================
+
+class ProviderResponse(BaseModel):
+    """Validation for any provider response"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    success: bool
+    provider_payment_id: Optional[str] = None
+    payment_url: Optional[str] = None
+    pay_amount: Optional[Decimal] = None
+    pay_currency: Optional[str] = None
+    pay_address: Optional[str] = None
+    status: Optional[str] = None
+    error_message: Optional[str] = None
+    # Legacy fields for backward compatibility with tests
+    amount: Optional[Decimal] = None
+    currency: Optional[str] = None
+    payment_id: Optional[str] = None
+    payment_status: Optional[str] = None
+    currency_code: Optional[str] = None
+
+
+class WebhookData(BaseModel):
+    """Provider webhook validation"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    provider_payment_id: str
+    status: str
+    pay_amount: Optional[Decimal] = None
+    pay_currency: Optional[str] = None
+    actually_paid: Optional[Decimal] = None
+    order_id: Optional[str] = None
+    signature: Optional[str] = None
+    error_message: Optional[str] = None
+
+
+# =============================================================================
+# INTER-SERVICE OPERATIONS - Service-to-service typing
+# =============================================================================
+
+class ServiceOperationResult(BaseModel):
+    """Result of inter-service operation"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    success: bool
+    error_code: Optional[str] = None
+    error_message: Optional[str] = None
+    data: Dict[str, Any] = Field(default_factory=dict)
+
+
+class BalanceUpdateRequest(BaseModel):
+    """Balance update request between services"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    user_id: int = Field(gt=0)
+    amount: Decimal
+    source: str
+    reference_id: Optional[str] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+class AccessCheckRequest(BaseModel):
+    """Access check request between services"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    user_id: int = Field(gt=0)
+    endpoint_group: str
+    use_cache: bool = True
+
+
+class AccessCheckResult(BaseModel):
+    """Access check result"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    allowed: bool
+    subscription_id: Optional[str] = None
+    reason: Optional[str] = None
+    remaining_requests: Optional[int] = None
+    usage_percentage: Optional[float] = None
+
+
+# =============================================================================
+# CONFIGURATION - Service settings
+# =============================================================================
+
+class RedisConfig(BaseModel):
+    """Redis configuration"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    host: str = "localhost"
+    port: int = 6379
+    db: int = 0
+    password: Optional[str] = None
+    max_connections: int = 10
+    timeout_seconds: int = 5
+
+
+class ProviderConfig(BaseModel):
+    """Base provider configuration"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    enabled: bool = True
+    api_key: str
+    sandbox: bool = False
+    timeout_seconds: int = 30
+    max_retries: int = 3
+
+
+# =============================================================================
+# CACHE OPERATIONS - Minimal cache typing
+# =============================================================================
+
+class CacheKey(BaseModel):
+    """Cache key typing"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    key: str
+    ttl_seconds: Optional[int] = None
+
+
+class RateLimitResult(BaseModel):
+    """Rate limit check result"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    allowed: bool
+    remaining: int
+    reset_at: datetime
+    retry_after_seconds: Optional[int] = None
+
+
+# =============================================================================
+# SERVICE RESPONSE MODELS - Typed responses for service methods
+# =============================================================================
+
+class PaymentCreationResult(BaseModel):
+    """Payment creation response"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    success: bool
+    payment_id: Optional[str] = None
+    provider_payment_id: Optional[str] = None
+    payment_url: Optional[str] = None
+    error: Optional[str] = None
+
+
+class WebhookProcessingResult(BaseModel):
+    """Webhook processing response"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    success: bool
+    payment_id: Optional[str] = None
+    status_updated: bool = False
+    balance_updated: bool = False
+    error: Optional[str] = None
+
+
+class PaymentStatusResult(BaseModel):
+    """Payment status response"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    payment_id: str
+    status: str
+    amount_usd: Decimal
+    currency_code: str
+    provider: str
+    provider_payment_id: Optional[str] = None
+    created_at: datetime
+    updated_at: datetime
+
+
+class UserBalanceResult(BaseModel):
+    """User balance response"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str
+    user_id: int
+    available_balance: Decimal
+    total_balance: Decimal
+    reserved_balance: Decimal
+    last_updated: datetime
+    created_at: datetime
+
+
+class TransferResult(BaseModel):
+    """Funds transfer response"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    success: bool
+    transaction_id: Optional[str] = None
+    from_user_id: int
+    to_user_id: int
+    amount: Decimal
+    error: Optional[str] = None
+    error_code: Optional[str] = None
+
+
+class TransactionInfo(BaseModel):
+    """Transaction information"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str
+    user_id: int
+    transaction_type: str
+    amount: Decimal
+    balance_after: Decimal
+    source: str
+    reference_id: Optional[str] = None
+    description: Optional[str] = None
+    created_at: datetime
+
+
+class EndpointGroupInfo(BaseModel):
+    """Endpoint group information"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str
+    name: str
+    display_name: str
+
+
+class SubscriptionInfo(BaseModel):
+    """Subscription information"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str
+    endpoint_group: EndpointGroupInfo
+    status: str
+    tier: str
+    monthly_price: Decimal
+    usage_current: int
+    usage_limit: int
+    usage_percentage: float
+    remaining_requests: int
+    expires_at: datetime
+    next_billing: Optional[datetime] = None
+    created_at: datetime
+
+
+class SubscriptionAnalytics(BaseModel):
+    """Subscription analytics response"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    period: Dict[str, Any] = Field(default_factory=dict)
+    total_revenue: Decimal
+    active_subscriptions: int
+    new_subscriptions: int
+    churned_subscriptions: int
+    error: Optional[str] = None

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

@@ -0,0 +1,8 @@
+"""
+Service layer middleware for payments.
+
+TODO: Implement service middleware when needed.
+"""
+
+# Placeholder for future service middleware
+__all__ = []

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

@@ -0,0 +1,19 @@
+"""
+Payment provider services.
+
+All payment provider implementations and abstractions.
+"""
+
+from .base import PaymentProvider
+from .registry import ProviderRegistry
+from .nowpayments import NowPaymentsProvider, NowPaymentsConfig
+from .cryptapi import CryptAPIProvider, CryptAPIConfig
+
+__all__ = [
+    'PaymentProvider',
+    'ProviderRegistry',
+    'NowPaymentsProvider',
+    'NowPaymentsConfig',
+    'CryptAPIProvider',
+    'CryptAPIConfig',
+]

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

@@ -0,0 +1,137 @@
+"""
+Base payment provider interface.
+
+Abstract base class for all payment providers.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, List
+from decimal import Decimal
+
+from ..internal_types import ProviderResponse, WebhookData
+
+
+class PaymentProvider(ABC):
+    """Abstract base class for payment providers."""
+    
+    def __init__(self, config: dict):
+        """Initialize provider with config."""
+        self.config = config
+        self.name = self.__class__.__name__.lower().replace('provider', '')
+        self.enabled = config.get('enabled', True)
+    
+    @abstractmethod
+    def create_payment(self, payment_data: dict) -> ProviderResponse:
+        """
+        Create a payment request.
+        
+        Args:
+            amount: Payment amount
+            currency: Payment currency
+            **kwargs: Additional parameters (order_id, description, etc.)
+            
+        Returns:
+            Dict with payment creation result
+        """
+        pass
+    
+    @abstractmethod
+    def check_payment_status(self, payment_id: str) -> ProviderResponse:
+        """
+        Check payment status.
+        
+        Args:
+            payment_id: Payment ID from provider
+            
+        Returns:
+            Dict with payment status
+        """
+        pass
+    
+    @abstractmethod
+    def process_webhook(self, payload: dict) -> WebhookData:
+        """
+        Process webhook payload.
+        
+        Args:
+            payload: Webhook data from provider
+            
+        Returns:
+            Dict with processed webhook data
+        """
+        pass
+    
+    @abstractmethod
+    def get_supported_currencies(self) -> List[str]:
+        """
+        Get list of supported currencies.
+        
+        Returns:
+            List of supported currency codes
+        """
+        pass
+    
+    def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
+        """
+        Validate webhook signature and data.
+        
+        Args:
+            payload: Webhook data
+            signature: Webhook signature (if applicable)
+            
+        Returns:
+            True if webhook is valid
+        """
+        # Default implementation - providers can override
+        return True
+    
+    def get_minimum_payment_amount(self, currency_from: str, currency_to: str = 'usd') -> Optional[Decimal]:
+        """
+        Get minimum payment amount for currency pair.
+        
+        Args:
+            currency_from: Source currency
+            currency_to: Target currency
+            
+        Returns:
+            Minimum payment amount or None if not supported
+        """
+        # Optional method - providers can override
+        return None
+    
+    def estimate_payment_amount(self, amount: Decimal, currency_code: str) -> Optional[dict]:
+        """
+        Estimate payment amount in target currency.
+        
+        Args:
+            amount: Amount to estimate
+            currency_code: Target currency
+            
+        Returns:
+            Dict with estimation data or None if not supported
+        """
+        # Optional method - providers can override
+        return None
+    
+    def check_api_status(self) -> bool:
+        """
+        Check if provider API is available.
+        
+        Returns:
+            True if API is available
+        """
+        # Optional method - providers can override
+        return True
+    
+    def is_enabled(self) -> bool:
+        """Check if provider is enabled."""
+        return self.enabled
+    
+    def get_provider_info(self) -> dict:
+        """Get provider information."""
+        return {
+            'name': self.name,
+            'enabled': self.enabled,
+            'supported_currencies': self.get_supported_currencies(),
+            'api_status': self.check_api_status(),
+        }

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

@@ -0,0 +1,262 @@
+"""
+CryptAPI provider implementation.
+
+Crypto payment provider using CryptAPI service.
+"""
+
+import logging
+import requests
+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 CryptAPIConfig(BaseModel):
+    """CryptAPI provider configuration."""
+    own_address: str = Field(..., description="Your cryptocurrency address")
+    callback_url: str = Field(..., description="Webhook callback URL")
+    convert_payments: bool = Field(default=True, description="Auto-convert payments")
+    multi_token: bool = Field(default=True, description="Support multi-token payments")
+    priority: str = Field(default='default', description="Transaction priority")
+    enabled: bool = Field(default=True, description="Provider enabled")
+
+
+class CryptAPIException(Exception):
+    """CryptAPI specific exception."""
+    pass
+
+
+class CryptAPIProvider(PaymentProvider):
+    """CryptAPI cryptocurrency payment provider."""
+    
+    CRYPTAPI_URL = 'https://api.cryptapi.io/'
+    
+    def __init__(self, config: CryptAPIConfig):
+        """Initialize CryptAPI provider."""
+        super().__init__(config.dict())
+        self.config = config
+        self.own_address = config.own_address
+        self.callback_url = config.callback_url
+        self.convert_payments = config.convert_payments
+        self.multi_token = config.multi_token
+        self.priority = config.priority
+    
+    def _make_request(self, coin: str, endpoint: str, params: Optional[dict] = None) -> Optional[dict]:
+        """Make HTTP request to CryptAPI."""
+        try:
+            if coin:
+                coin = coin.replace('/', '_')
+                url = f"{self.CRYPTAPI_URL}{coin}/{endpoint}/"
+            else:
+                url = f"{self.CRYPTAPI_URL}{endpoint}/"
+            
+            response = requests.get(url, params=params or {}, timeout=30)
+            response.raise_for_status()
+            
+            result = response.json()
+            
+            # Check for API errors
+            if 'error' in result:
+                logger.error(f"CryptAPI error: {result['error']}")
+                return None
+            
+            return result
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"CryptAPI request failed: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Unexpected CryptAPI error: {e}")
+            return None
+    
+    def create_payment(self, payment_data: dict) -> ProviderResponse:
+        """Create payment address via CryptAPI."""
+        try:
+            amount = Decimal(str(payment_data['amount']))
+            currency = payment_data['currency'].lower()
+            order_id = payment_data.get('order_id', f'payment_{int(amount * 100)}')
+            
+            # Build callback URL with parameters
+            callback_params = {
+                'order_id': order_id,
+                'amount': str(amount)
+            }
+            
+            # Create payment address
+            params = {
+                'address': self.own_address,
+                'callback': self.callback_url,
+                'convert': 1 if self.convert_payments else 0,
+                'multi_token': 1 if self.multi_token else 0,
+                'priority': self.priority,
+                **callback_params
+            }
+            
+            response = self._make_request(currency, 'create', params)
+            
+            if response and 'address_in' in response:
+                return ProviderResponse(
+                    success=True,
+                    provider_payment_id=response['address_in'],  # Use address as payment ID
+                    payment_url=None,  # CryptAPI doesn't provide payment URLs
+                    pay_address=response['address_in'],
+                    amount=amount,
+                    currency=currency.upper(),
+                    status='pending'
+                )
+            else:
+                return ProviderResponse(
+                    success=False,
+                    error_message='Failed to create payment address'
+                )
+                
+        except Exception as e:
+            logger.error(f"CryptAPI 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 CryptAPI."""
+        try:
+            # For CryptAPI, payment_id is the address
+            # We need to check logs to see if payment was received
+            # This is a limitation of CryptAPI - no direct status check by address
+            
+            # Return pending status as CryptAPI uses callbacks for status updates
+            return ProviderResponse(
+                success=True,
+                provider_payment_id=payment_id,
+                status='pending',
+                pay_address=payment_id,
+                amount=Decimal('0'),  # Unknown without logs
+                currency='unknown'
+            )
+            
+        except Exception as e:
+            logger.error(f"CryptAPI check_payment_status error: {e}")
+            return ProviderResponse(
+                success=False,
+                error_message=str(e)
+            )
+    
+    def process_webhook(self, payload: dict) -> WebhookData:
+        """Process CryptAPI webhook/callback."""
+        try:
+            # CryptAPI sends callbacks with these parameters:
+            # - address_in: payment address
+            # - address_out: your address  
+            # - txid_in: transaction ID
+            # - txid_out: forwarding transaction ID (if applicable)
+            # - confirmations: number of confirmations
+            # - value: amount received
+            # - value_coin: amount in coin
+            # - value_forwarded: amount forwarded
+            # - coin: cryptocurrency
+            # - pending: 0 or 1
+            
+            confirmations = int(payload.get('confirmations', 0))
+            pending = int(payload.get('pending', 1))
+            
+            # Determine status based on confirmations and pending flag
+            if pending == 1:
+                status = 'pending'
+            elif confirmations >= 1:
+                status = 'completed'
+            else:
+                status = 'processing'
+            
+            return WebhookData(
+                provider_payment_id=payload.get('address_in', ''),
+                status=status,
+                pay_amount=Decimal(str(payload.get('value_coin', 0))),
+                actually_paid=Decimal(str(payload.get('value_coin', 0))),
+                order_id=payload.get('order_id'),  # Custom parameter we sent
+                signature=payload.get('txid_in')  # Use transaction ID as signature
+            )
+            
+        except Exception as e:
+            logger.error(f"CryptAPI webhook processing error: {e}")
+            raise
+    
+    def get_supported_currencies(self) -> List[str]:
+        """Get list of supported currencies."""
+        try:
+            response = self._make_request('', 'info')
+            
+            if response and isinstance(response, dict):
+                # CryptAPI returns a dict with coin info
+                return list(response.keys())
+            else:
+                # Fallback currencies
+                return ['BTC', 'ETH', 'LTC', 'BCH', 'XMR', 'TRX']
+                
+        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."""
+        try:
+            response = self._make_request(currency_from.lower(), 'info')
+            
+            if response and 'minimum_transaction' in response:
+                return Decimal(str(response['minimum_transaction']))
+            
+            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 - CryptAPI doesn't provide this."""
+        # CryptAPI doesn't have a direct estimation API
+        # Would need to use external price APIs
+        return None
+    
+    def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
+        """Validate CryptAPI webhook."""
+        try:
+            # CryptAPI doesn't use HMAC signatures
+            # Validation is done by checking if the callback came from their servers
+            # and contains expected parameters
+            
+            required_fields = ['address_in', 'value', 'txid_in', 'confirmations']
+            
+            for field in required_fields:
+                if field not in payload:
+                    logger.warning(f"Missing required field in CryptAPI webhook: {field}")
+                    return False
+            
+            # Basic validation passed
+            return True
+            
+        except Exception as e:
+            logger.error(f"CryptAPI webhook validation error: {e}")
+            return False
+    
+    def check_api_status(self) -> bool:
+        """Check if CryptAPI is available."""
+        try:
+            response = self._make_request('', 'info')
+            return response is not None
+        except:
+            return False
+    
+    def get_logs(self, callback_url: str) -> Optional[dict]:
+        """Get payment logs for a callback URL."""
+        try:
+            params = {'callback': callback_url}
+            # Note: This would need a specific coin, but we don't know which one
+            # This is a limitation of the current implementation
+            return None
+        except Exception as e:
+            logger.error(f"Error getting logs: {e}")
+            return None