django-cfg 1.2.22__py3-none-any.whl → 1.2.25__py3-none-any.whl

django_cfg/apps/payments/services/internal_types.py

@@ -0,0 +1,297 @@
+"""
+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
+
+
+# =============================================================================
+# ADDITIONAL RESPONSE MODELS - Missing Pydantic models
+# =============================================================================
+
+class PaymentHistoryItem(BaseModel):
+    """Single payment item for history lists"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str
+    user_id: int
+    amount: Decimal
+    currency: str
+    status: str
+    provider: str
+    provider_payment_id: Optional[str] = None
+    created_at: datetime
+    updated_at: datetime
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+class ProviderInfo(BaseModel):
+    """Payment provider information"""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    name: str
+    display_name: str
+    supported_currencies: list[str] = Field(default_factory=list)
+    is_active: bool
+    features: Dict[str, Any] = Field(default_factory=dict)

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/monitoring/__init__.py

@@ -0,0 +1,22 @@
+"""
+Payment system monitoring services.
+
+Provides health monitoring, alerting, and fallback mechanisms
+for payment providers and system components.
+"""
+
+from .provider_health import (
+    ProviderHealthMonitor,
+    ProviderHealthCheck,
+    ProviderHealthSummary,
+    HealthStatus,
+    get_health_monitor
+)
+
+__all__ = [
+    'ProviderHealthMonitor',
+    'ProviderHealthCheck', 
+    'ProviderHealthSummary',
+    'HealthStatus',
+    'get_health_monitor'
+]

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

@@ -0,0 +1,222 @@
+"""
+Pydantic schemas for provider API responses.
+
+Type-safe models for validating and parsing responses
+from payment provider health check endpoints.
+"""
+
+from typing import Dict, Optional, Any
+from decimal import Decimal
+from datetime import datetime
+from pydantic import BaseModel, Field, validator
+
+
+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
+
+
+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 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
+
+
+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")
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+
+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
+    
+    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
+    
+    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
+    )