django-cfg 1.2.29__py3-none-any.whl → 1.2.31__py3-none-any.whl

django_cfg/apps/payments/services/internal_types.py

@@ -7,11 +7,137 @@ DO NOT duplicate Django ORM or DRF! Only for:
 3. Configuration (settings and parameters)
 """
 
-from pydantic import BaseModel, Field, ConfigDict
+from pydantic import BaseModel, Field, ConfigDict, computed_field
 from decimal import Decimal
 from datetime import datetime
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 from enum import Enum
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("internal_types")
+
+
+
+
+# =============================================================================
+# UNIVERSAL CURRENCY MODEL - for provider → base communication
+# =============================================================================
+
+class UniversalCurrency(BaseModel):
+    """Universal currency model that all providers should return."""
+    model_config = ConfigDict(validate_assignment=True, extra="allow")
+    
+    # Core identification
+    provider_currency_code: str = Field(..., description="Original provider code: USDTERC20, USDTBSC, BTC")
+    base_currency_code: str = Field(..., description="Parsed base currency: USDT, BTC")
+    network_code: Optional[str] = Field(None, description="Parsed network: ethereum, bsc, bitcoin")
+    
+    # Display info
+    name: str = Field(..., description="Human readable name")
+    currency_type: str = Field(default="crypto", description="fiat or crypto")
+    
+    # Provider flags
+    is_enabled: bool = Field(default=True, description="Available for use")
+    is_popular: bool = Field(default=False, description="Popular currency")
+    is_stable: bool = Field(default=False, description="Stablecoin")
+    priority: int = Field(default=0, description="Display priority")
+    
+    # URLs and assets
+    logo_url: str = Field(default="", description="Logo URL")
+    
+    # Limits and availability  
+    available_for_payment: bool = Field(default=True, description="Can receive payments")
+    available_for_payout: bool = Field(default=True, description="Can send payouts")
+    min_amount: Optional[float] = Field(None, description="Minimum amount")
+    max_amount: Optional[float] = Field(None, description="Maximum amount")
+    
+    # Raw provider data
+    raw_data: Dict[str, Any] = Field(default_factory=dict, description="Original provider response")
+
+
+class UniversalCurrenciesResponse(BaseModel):
+    """Universal response with parsed currencies."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currencies: List[UniversalCurrency] = Field(..., description="Parsed currencies")
+
+
+# =============================================================================
+# SYNCHRONIZATION RESULTS - Typed sync operation results
+# =============================================================================
+
+class ProviderSyncResult(BaseModel):
+    """Result of provider synchronization operation."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    # Currencies operations
+    currencies_created: int = Field(default=0, description="Number of new currencies created")
+    currencies_updated: int = Field(default=0, description="Number of existing currencies updated")
+    
+    # Networks operations  
+    networks_created: int = Field(default=0, description="Number of new networks created")
+    networks_updated: int = Field(default=0, description="Number of existing networks updated")
+    
+    # Provider currencies operations
+    provider_currencies_created: int = Field(default=0, description="Number of new provider currencies created")
+    provider_currencies_updated: int = Field(default=0, description="Number of existing provider currencies updated")
+    
+    # Error tracking
+    errors: List[str] = Field(default_factory=list, description="List of errors encountered during sync")
+    
+    @property
+    def total_items_processed(self) -> int:
+        """Get total number of items processed."""
+        return (
+            self.currencies_created + self.currencies_updated +
+            self.networks_created + self.networks_updated +
+            self.provider_currencies_created + self.provider_currencies_updated
+        )
+    
+    @property
+    def success(self) -> bool:
+        """Check if sync completed without errors."""
+        return len(self.errors) == 0
+    
+    @property
+    def has_changes(self) -> bool:
+        """Check if any changes were made."""
+        return self.total_items_processed > 0
+
+
+# AJAX Response Types
+class CurrencyOptionModel(BaseModel):
+    """Single currency option for UI select dropdown."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    provider_currency_code: str = Field(..., description="Provider-specific currency code")
+    display_name: str = Field(..., description="Human-readable display name")
+    base_currency_code: str = Field(..., description="Normalized base currency code")
+    base_currency_name: str = Field(..., description="Base currency full name")
+    network_code: Optional[str] = Field(None, description="Network code if applicable")
+    network_name: Optional[str] = Field(None, description="Network full name if applicable")
+    currency_type: str = Field(..., description="Currency type: crypto or fiat")
+    is_popular: bool = Field(default=False, description="Is this a popular currency")
+    is_stable: bool = Field(default=False, description="Is this a stablecoin")
+    available_for_payment: bool = Field(default=True, description="Available for payments")
+    available_for_payout: bool = Field(default=True, description="Available for payouts")
+    min_amount: Optional[str] = Field(None, description="Minimum amount as string")
+    max_amount: Optional[str] = Field(None, description="Maximum amount as string")
+    logo_url: Optional[str] = Field(None, description="Currency logo URL")
+    # Exchange rates
+    usd_rate: float = Field(default=0.0, description="1 CURRENCY = X USD")
+    tokens_per_usd: float = Field(default=0.0, description="How many tokens for 1 USD")
+
+
+class ProviderCurrencyOptionsResponse(BaseModel):
+    """Response for provider currency options API."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    success: bool = Field(..., description="API call success status")
+    provider: str = Field(..., description="Provider name")
+    currency_options: List[CurrencyOptionModel] = Field(default_factory=list, description="Available currency options")
+    count: int = Field(..., description="Number of currency options")
+    error: Optional[str] = Field(None, description="Error message if any")
 
 
 # =============================================================================
@@ -30,6 +156,8 @@ class ProviderResponse(BaseModel):
     pay_address: Optional[str] = None
     status: Optional[str] = None
     error_message: Optional[str] = None
+    data: Dict[str, Any] = Field(default_factory=dict)
+    
     # Legacy fields for backward compatibility with tests
     amount: Optional[Decimal] = None
     currency: Optional[str] = None
@@ -38,6 +166,20 @@ class ProviderResponse(BaseModel):
     currency_code: Optional[str] = None
 
 
+class PaymentAmountEstimate(BaseModel):
+    """Universal payment amount estimation response"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currency_from: str = Field(description="Source currency code")
+    currency_to: str = Field(description="Target currency code") 
+    amount_from: Decimal = Field(gt=0, description="Source amount")
+    estimated_amount: Decimal = Field(gt=0, description="Estimated target amount")
+    fee_amount: Optional[Decimal] = Field(None, ge=0, description="Provider fee amount")
+    exchange_rate: Optional[Decimal] = Field(None, gt=0, description="Exchange rate used")
+    provider_name: str = Field(description="Provider that made the estimation")
+    estimated_at: Optional[datetime] = Field(None, description="When estimation was made")
+
+
 class WebhookData(BaseModel):
     """Provider webhook validation"""
     model_config = ConfigDict(validate_assignment=True, extra="forbid")
@@ -114,14 +256,36 @@ class RedisConfig(BaseModel):
 
 
 class ProviderConfig(BaseModel):
-    """Base provider configuration"""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    """Base provider configuration with automatic sandbox detection"""
+    model_config = ConfigDict(validate_assignment=True, extra="allow")  # Allow extra fields for flexibility
     
     enabled: bool = True
     api_key: str
-    sandbox: bool = False
-    timeout_seconds: int = 30
+    timeout_seconds: int = Field(default=30, alias='timeout', description="Request timeout in seconds")
     max_retries: int = 3
+    
+    @computed_field
+    @property
+    def sandbox(self) -> bool:
+        """Get sandbox mode from django-cfg config."""
+        try:
+            from django_cfg.core.config import get_current_config
+            current_config = get_current_config()
+            
+            if current_config:
+                # Check env_mode first
+                if hasattr(current_config, 'env_mode'):
+                    env_mode = current_config.env_mode
+                    if isinstance(env_mode, str):
+                        return env_mode.lower() in ['development', 'dev', 'test']
+                
+                # Fallback to debug flag
+                if hasattr(current_config, 'debug'):
+                    return current_config.debug
+            
+            return True  # Default to sandbox for safety
+        except Exception:
+            return True
 
 
 # =============================================================================
@@ -294,4 +458,4 @@ class ProviderInfo(BaseModel):
     display_name: str
     supported_currencies: list[str] = Field(default_factory=list)
     is_active: bool
-    features: Dict[str, Any] = Field(default_factory=dict)
+    features: Dict[str, Any] = Field(default_factory=dict)

django_cfg/apps/payments/services/monitoring/api_schemas.py

@@ -1,222 +1,76 @@
 """
-Pydantic schemas for provider API responses.
+Provider API monitoring schemas.
 
-Type-safe models for validating and parsing responses
-from payment provider health check endpoints.
+Re-exports provider-specific monitoring models from their dedicated folders.
+Universal monitoring models and utilities.
 """
 
-from typing import Dict, Optional, Any
-from decimal import Decimal
-from datetime import datetime
-from pydantic import BaseModel, Field, validator
+# Re-export provider-specific health check models
+from ..providers.cryptapi.models import CryptAPIInfoResponse
+from ..providers.nowpayments.models import NowPaymentsStatusResponse  
+from ..providers.cryptomus.models import CryptomusErrorResponse
+from ..providers.stripe.models import StripeHealthErrorResponse
 
-
-class CryptAPIInfoResponse(BaseModel):
-    """CryptAPI /btc/info/ response schema."""
-    
-    coin: str = Field(..., description="Cryptocurrency name")
-    logo: str = Field(..., description="Logo URL")
-    ticker: str = Field(..., description="Currency ticker")
-    minimum_transaction: int = Field(..., description="Minimum transaction in satoshis")
-    minimum_transaction_coin: str = Field(..., description="Minimum transaction in coin units")
-    minimum_fee: int = Field(..., description="Minimum fee in satoshis")
-    minimum_fee_coin: str = Field(..., description="Minimum fee in coin units")
-    fee_percent: str = Field(..., description="Fee percentage")
-    network_fee_estimation: str = Field(..., description="Network fee estimation")
-    status: str = Field(..., description="API status")
-    prices: Dict[str, str] = Field(..., description="Prices in various fiat currencies")
-    prices_updated: str = Field(..., description="Prices last updated timestamp")
-    
-    @validator('status')
-    def validate_status(cls, v):
-        """Validate that status is success."""
-        if v != 'success':
-            raise ValueError(f"Expected status 'success', got '{v}'")
-        return v
-    
-    @validator('prices')
-    def validate_prices_not_empty(cls, v):
-        """Validate that prices dict is not empty."""
-        if not v:
-            raise ValueError("Prices dictionary cannot be empty")
-        return v
-    
-    def get_usd_price(self) -> Optional[Decimal]:
-        """Get USD price as Decimal."""
-        usd_price = self.prices.get('USD')
-        if usd_price:
-            try:
-                return Decimal(usd_price)
-            except:
-                return None
-        return None
-
-
-class NowPaymentsStatusResponse(BaseModel):
-    """NowPayments /v1/status response schema."""
-    
-    message: str = Field(..., description="Status message")
-    
-    @validator('message')
-    def validate_message_ok(cls, v):
-        """Validate that message is OK."""
-        if v.upper() != 'OK':
-            raise ValueError(f"Expected message 'OK', got '{v}'")
-        return v
+# Universal monitoring models - defined here
+from pydantic import BaseModel, Field
+from typing import Dict, Any, Optional
+from enum import Enum
 
 
-class StripeErrorResponse(BaseModel):
-    """Stripe API error response schema."""
-    
-    class StripeError(BaseModel):
-        message: str = Field(..., description="Error message")
-        type: str = Field(..., description="Error type")
-        
-    error: StripeError = Field(..., description="Error details")
-    
-    @validator('error')
-    def validate_auth_error(cls, v):
-        """Validate this is an authentication error (meaning API is healthy)."""
-        if v.type != 'invalid_request_error':
-            raise ValueError(f"Expected auth error, got '{v.type}'")
-        return v
-
-
-class CryptomusErrorResponse(BaseModel):
-    """Cryptomus API error response schema."""
-    
-    error: str = Field(..., description="Error message")
-    
-    @validator('error')
-    def validate_not_found_error(cls, v):
-        """Validate this is a not found error (meaning API is responding)."""
-        if v.lower() not in ['not found', 'unauthorized', 'forbidden']:
-            raise ValueError(f"Unexpected error: {v}")
-        return v
+class APIHealthStatus(str, Enum):
+    """API health status enumeration."""
+    HEALTHY = "healthy"
+    DEGRADED = "degraded"
+    UNHEALTHY = "unhealthy"
+    UNKNOWN = "unknown"
 
 
 class GenericAPIHealthResponse(BaseModel):
-    """Generic API health response for unknown formats."""
-    
-    status_code: int = Field(..., description="HTTP status code")
-    response_body: str = Field(..., description="Raw response body")
-    response_time_ms: float = Field(..., description="Response time in milliseconds")
-    
-    def is_healthy(self) -> bool:
-        """Determine if API is healthy based on status code."""
-        # 2xx = healthy, 401/403 = healthy (auth required), 4xx = degraded, 5xx = unhealthy
-        if 200 <= self.status_code < 300:
-            return True
-        elif self.status_code in [401, 403]:
-            return True  # Auth required but API responding
-        else:
-            return False
+    """Generic API health check response."""
+    status: APIHealthStatus = Field(description="API health status")
+    response_time_ms: float = Field(description="Response time in milliseconds")
+    error_message: Optional[str] = Field(None, description="Error message if unhealthy")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
 
 
 class ProviderHealthResponse(BaseModel):
-    """Unified health response model for all providers."""
-    
-    provider_name: str = Field(..., description="Provider name")
-    is_healthy: bool = Field(..., description="Is provider healthy")
-    status_code: int = Field(..., description="HTTP status code")
-    response_time_ms: float = Field(..., description="Response time in milliseconds")
-    error_message: Optional[str] = Field(None, description="Error message if unhealthy")
-    parsed_response: Optional[Dict[str, Any]] = Field(None, description="Parsed API response")
-    raw_response: Optional[str] = Field(None, description="Raw response body")
-    checked_at: datetime = Field(default_factory=datetime.now, description="Check timestamp")
+    """Provider health check response wrapper."""
+    provider_name: str = Field(description="Provider name")
+    api_health: GenericAPIHealthResponse = Field(description="API health details")
+    checked_at: str = Field(description="Check timestamp")
+
+
+def parse_provider_response(provider_name: str, response_data: Dict[str, Any]) -> ProviderHealthResponse:
+    """Parse provider API response into standardized health format."""
+    # Simple implementation - can be enhanced per provider
+    status = APIHealthStatus.HEALTHY if response_data.get('success', False) else APIHealthStatus.UNHEALTHY
+    
+    api_health = GenericAPIHealthResponse(
+        status=status,
+        response_time_ms=response_data.get('response_time', 0.0),
+        error_message=response_data.get('error_message'),
+        metadata=response_data.get('metadata', {})
+    )
     
-    class Config:
-        json_encoders = {
-            datetime: lambda v: v.isoformat()
-        }
+    return ProviderHealthResponse(
+        provider_name=provider_name,
+        api_health=api_health,
+        checked_at=response_data.get('timestamp', '')
+    )
 
 
-def parse_provider_response(provider_name: str, status_code: int, response_body: str, response_time_ms: float) -> ProviderHealthResponse:
-    """
-    Parse provider API response using appropriate schema.
-    
-    Args:
-        provider_name: Name of the provider
-        status_code: HTTP status code
-        response_body: Raw response body
-        response_time_ms: Response time in milliseconds
-        
-    Returns:
-        ProviderHealthResponse with parsed data
-    """
-    parsed_response = None
-    error_message = None
-    is_healthy = False
+# Backward compatibility exports
+__all__ = [
+    # Provider-specific models
+    'CryptAPIInfoResponse',
+    'NowPaymentsStatusResponse',
+    'CryptomusErrorResponse', 
+    'StripeHealthErrorResponse',
     
-    try:
-        import json
-        response_json = json.loads(response_body) if response_body else {}
-        
-        if provider_name == 'cryptapi':
-            if status_code == 200:
-                cryptapi_response = CryptAPIInfoResponse(**response_json)
-                parsed_response = cryptapi_response.dict()
-                is_healthy = True
-            else:
-                error_message = f"CryptAPI returned status {status_code}"
-                
-        elif provider_name == 'nowpayments':
-            if status_code == 200:
-                nowpayments_response = NowPaymentsStatusResponse(**response_json)
-                parsed_response = nowpayments_response.dict()
-                is_healthy = True
-            else:
-                error_message = f"NowPayments returned status {status_code}"
-                
-        elif provider_name == 'stripe':
-            if status_code == 401:
-                stripe_response = StripeErrorResponse(**response_json)
-                parsed_response = stripe_response.dict()
-                is_healthy = True  # Auth error = API responding
-            elif 200 <= status_code < 300:
-                parsed_response = response_json
-                is_healthy = True
-            else:
-                error_message = f"Stripe returned unexpected status {status_code}"
-                
-        elif provider_name == 'cryptomus':
-            if status_code == 404 and response_json.get('error') == 'Not found':
-                cryptomus_response = CryptomusErrorResponse(**response_json)
-                parsed_response = cryptomus_response.dict()
-                is_healthy = True  # Not found = API responding
-            elif status_code == 204:
-                # No Content = API responding and healthy
-                parsed_response = {'status': 'no_content', 'message': 'API responding correctly'}
-                is_healthy = True
-            elif status_code in [401, 403]:
-                is_healthy = True  # Auth required = API responding
-                parsed_response = response_json
-            elif 200 <= status_code < 300:
-                parsed_response = response_json
-                is_healthy = True
-            else:
-                error_message = f"Cryptomus returned status {status_code}"
-        
-        else:
-            # Generic handling for unknown providers
-            generic_response = GenericAPIHealthResponse(
-                status_code=status_code,
-                response_body=response_body,
-                response_time_ms=response_time_ms
-            )
-            parsed_response = generic_response.dict()
-            is_healthy = generic_response.is_healthy()
-            
-    except Exception as e:
-        error_message = f"Failed to parse {provider_name} response: {str(e)}"
-        is_healthy = False
+    # Universal models
+    'GenericAPIHealthResponse',
+    'ProviderHealthResponse',
     
-    return ProviderHealthResponse(
-        provider_name=provider_name,
-        is_healthy=is_healthy,
-        status_code=status_code,
-        response_time_ms=response_time_ms,
-        error_message=error_message,
-        parsed_response=parsed_response,
-        raw_response=response_body
-    )
+    # Utility functions
+    'parse_provider_response',
+]

django_cfg/apps/payments/services/monitoring/provider_health.py

@@ -5,7 +5,7 @@ Monitors the health of all payment providers and provides
 fallback mechanisms when providers are unavailable.
 """
 
-import logging
+from django_cfg.modules.django_logger import get_logger
 import time
 import asyncio
 import requests
@@ -22,7 +22,7 @@ from ..providers.registry import ProviderRegistry
 from ...models.events import PaymentEvent
 from .api_schemas import parse_provider_response
 
-logger = logging.getLogger(__name__)
+logger = get_logger("provider_health")
 
 
 class HealthStatus(Enum):