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

django_cfg/apps/payments/services/providers/models/currencies.py

@@ -0,0 +1,190 @@
+"""
+Provider-specific currency and network models.
+
+These models are ONLY for provider-specific currency data,
+NOT for universal service communication (those are in internal_types.py).
+"""
+
+from pydantic import BaseModel, Field, ConfigDict, field_validator
+from decimal import Decimal
+from typing import List, Dict, Optional, Any
+from enum import Enum
+
+
+class CurrencyType(str, Enum):
+    """Currency type enumeration."""
+    FIAT = "fiat"
+    CRYPTO = "crypto"
+
+
+class NetworkType(str, Enum):
+    """Network type enumeration."""
+    MAINNET = "mainnet"
+    TESTNET = "testnet"
+    LAYER2 = "layer2"
+    SIDECHAIN = "sidechain"
+
+
+class CurrencyInfo(BaseModel):
+    """Information about a currency from provider API."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    code: str = Field(min_length=2, max_length=10, description="Currency code (BTC, ETH, USD)")
+    name: str = Field(min_length=1, max_length=100, description="Full currency name")
+    symbol: Optional[str] = Field(None, max_length=10, description="Currency symbol")
+    currency_type: CurrencyType = Field(description="Type of currency")
+    
+    # Provider-specific data
+    min_amount: Optional[Decimal] = Field(None, ge=0, description="Minimum payment amount")
+    max_amount: Optional[Decimal] = Field(None, ge=0, description="Maximum payment amount")
+    precision: Optional[int] = Field(None, ge=0, le=18, description="Decimal precision")
+    
+    # Exchange rate info
+    usd_rate: Optional[Decimal] = Field(None, gt=0, description="Rate to USD")
+    rate_updated_at: Optional[str] = Field(None, description="Rate update timestamp")
+    
+    # Provider metadata
+    provider_metadata: Dict[str, Any] = Field(default_factory=dict, description="Provider-specific data")
+    
+    @field_validator('code')
+    @classmethod
+    def code_must_be_uppercase(cls, v):
+        return v.upper() if v else v
+    
+    @field_validator('max_amount')
+    @classmethod
+    def max_amount_must_be_greater_than_min(cls, v, info):
+        if v is not None and 'min_amount' in info.data and info.data['min_amount'] is not None:
+            if v <= info.data['min_amount']:
+                raise ValueError('max_amount must be greater than min_amount')
+        return v
+
+
+class NetworkInfo(BaseModel):
+    """Information about a blockchain network from provider API."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    code: str = Field(min_length=1, max_length=20, description="Network code")
+    name: str = Field(min_length=1, max_length=50, description="Network display name")
+    network_type: Optional[NetworkType] = Field(None, description="Type of network")
+    
+    # Network-specific settings
+    confirmation_blocks: int = Field(default=1, ge=0, description="Required confirmations")
+    min_amount: Optional[Decimal] = Field(None, ge=0, description="Minimum amount for this network")
+    max_amount: Optional[Decimal] = Field(None, ge=0, description="Maximum amount for this network")
+    
+    # Fee information
+    base_fee: Optional[Decimal] = Field(None, ge=0, description="Base network fee")
+    fee_percentage: Optional[Decimal] = Field(None, ge=0, le=100, description="Fee percentage")
+    
+    # Network status
+    is_active: bool = Field(default=True, description="Whether network is active")
+    is_maintenance: bool = Field(default=False, description="Whether network is in maintenance")
+    
+    # Provider metadata
+    provider_metadata: Dict[str, Any] = Field(default_factory=dict, description="Provider-specific data")
+    
+    @field_validator('code')
+    @classmethod
+    def code_must_be_lowercase(cls, v):
+        return v.lower() if v else v
+
+
+class ProviderCurrencyResponse(BaseModel):
+    """Response from provider API for supported currencies."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    success: bool = Field(description="Whether request was successful")
+    currencies: List[CurrencyInfo] = Field(default_factory=list, description="List of supported currencies")
+    total_count: Optional[int] = Field(None, ge=0, description="Total number of currencies")
+    
+    # Error information
+    error_code: Optional[str] = Field(None, description="Provider error code")
+    error_message: Optional[str] = Field(None, description="Error message if failed")
+    
+    # Request metadata
+    provider_name: Optional[str] = Field(None, description="Provider name")
+    request_timestamp: Optional[str] = Field(None, description="Request timestamp")
+    cache_ttl: Optional[int] = Field(None, ge=0, description="Cache TTL in seconds")
+    
+    @field_validator('currencies')
+    @classmethod
+    def validate_currency_codes_unique(cls, v):
+        codes = [currency.code for currency in v]
+        if len(codes) != len(set(codes)):
+            raise ValueError('Currency codes must be unique')
+        return v
+
+
+class ProviderNetworkResponse(BaseModel):
+    """Response from provider API for supported networks."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    success: bool = Field(description="Whether request was successful")
+    networks: Dict[str, List[NetworkInfo]] = Field(
+        default_factory=dict, 
+        description="Networks grouped by currency code"
+    )
+    
+    # Error information
+    error_code: Optional[str] = Field(None, description="Provider error code")
+    error_message: Optional[str] = Field(None, description="Error message if failed")
+    
+    # Request metadata
+    provider_name: Optional[str] = Field(None, description="Provider name")
+    request_timestamp: Optional[str] = Field(None, description="Request timestamp")
+    cache_ttl: Optional[int] = Field(None, ge=0, description="Cache TTL in seconds")
+    
+    @field_validator('networks')
+    @classmethod
+    def validate_network_structure(cls, v):
+        for currency_code, networks in v.items():
+            if not currency_code.isupper():
+                raise ValueError(f'Currency code {currency_code} must be uppercase')
+            
+            network_codes = [network.code for network in networks]
+            if len(network_codes) != len(set(network_codes)):
+                raise ValueError(f'Network codes must be unique for currency {currency_code}')
+        return v
+
+
+class CurrencyNetworkMapping(BaseModel):
+    """Mapping of currencies to their supported networks."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    provider_name: str = Field(description="Provider name")
+    mapping: Dict[str, List[str]] = Field(
+        default_factory=dict,
+        description="Currency code -> List of network codes"
+    )
+    last_updated: Optional[str] = Field(None, description="Last update timestamp")
+    
+    # Cache information
+    cache_key: Optional[str] = Field(None, description="Cache key for this mapping")
+    ttl_seconds: Optional[int] = Field(None, ge=0, description="TTL for caching")
+    
+    @field_validator('mapping')
+    @classmethod
+    def validate_mapping_structure(cls, v):
+        for currency_code, network_codes in v.items():
+            if not currency_code.isupper():
+                raise ValueError(f'Currency code {currency_code} must be uppercase')
+            
+            if len(network_codes) != len(set(network_codes)):
+                raise ValueError(f'Network codes must be unique for currency {currency_code}')
+        return v
+    
+    def get_networks_for_currency(self, currency_code: str) -> List[str]:
+        """Get supported networks for a specific currency."""
+        return self.mapping.get(currency_code.upper(), [])
+    
+    def get_all_currencies(self) -> List[str]:
+        """Get all supported currency codes."""
+        return list(self.mapping.keys())
+    
+    def get_all_networks(self) -> List[str]:
+        """Get all unique network codes."""
+        all_networks = []
+        for networks in self.mapping.values():
+            all_networks.extend(networks)
+        return list(set(all_networks))

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

@@ -0,0 +1,4 @@
+from .provider import NowPaymentsProvider
+from .models import NowPaymentsConfig, NowPaymentsCurrency, NowPaymentsNetwork
+
+__all__ = ['NowPaymentsProvider', 'NowPaymentsConfig', 'NowPaymentsCurrency', 'NowPaymentsNetwork']

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

@@ -0,0 +1,196 @@
+from pydantic import BaseModel, Field, ConfigDict, field_validator
+from typing import Optional, List
+from decimal import Decimal
+
+from ...internal_types import ProviderConfig
+
+
+class NowPaymentsConfig(ProviderConfig):
+    """NowPayments provider configuration with Pydantic v2."""
+    
+    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")
+    
+    
+
+
+class NowPaymentsCurrency(BaseModel):
+    """NowPayments full currency model from /v1/full-currencies."""
+    model_config = ConfigDict(validate_assignment=True, extra="allow")
+    
+    id: int = Field(..., description="Currency ID")
+    code: str = Field(..., description="Currency code (e.g., BTC, USDTERC20)")
+    name: str = Field(..., description="Full currency name")
+    enable: bool = Field(..., description="Currency availability")
+    wallet_regex: Optional[str] = Field(None, description="Wallet address regex")
+    priority: int = Field(..., description="Currency priority")
+    extra_id_exists: bool = Field(..., description="Whether extra ID is required")
+    extra_id_regex: Optional[str] = Field(None, description="Extra ID regex")
+    logo_url: str = Field(..., description="Currency logo URL")
+    track: bool = Field(..., description="Track transactions")
+    cg_id: Optional[str] = Field(None, description="CoinGecko ID")
+    is_maxlimit: bool = Field(..., description="Has max limit")
+    network: Optional[str] = Field(None, description="Blockchain network")
+    smart_contract: Optional[str] = Field(None, description="Smart contract address")
+    network_precision: Optional[str] = Field(None, description="Network precision")
+    explorer_link_hash: Optional[str] = Field(None, description="Explorer link")
+    precision: int = Field(..., description="Currency precision")
+    ticker: Optional[str] = Field(None, description="Ticker symbol")
+    is_defi: bool = Field(..., description="Is DeFi token")
+    is_popular: bool = Field(..., description="Is popular currency")
+    is_stable: bool = Field(..., description="Is stablecoin")
+    available_for_to_conversion: bool = Field(..., description="Available for conversion")
+    trust_wallet_id: Optional[str] = Field(None, description="Trust Wallet ID")
+    created_at: str = Field(..., description="Creation timestamp")
+    updated_at: str = Field(..., description="Update timestamp")
+    available_for_payment: bool = Field(..., description="Available for payment")
+    available_for_payout: bool = Field(..., description="Available for payout")
+    extra_id_optional: bool = Field(..., description="Extra ID is optional")
+
+
+class NowPaymentsNetwork(BaseModel):
+    """NowPayments specific network model."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    code: str = Field(..., description="Network code")
+    name: str = Field(..., description="Network display name")
+    currency: str = Field(..., description="Currency this network belongs to")
+    confirmations: int = Field(1, description="Required confirmations")
+
+
+class NowPaymentsPaymentRequest(BaseModel):
+    """NowPayments payment creation request."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    price_amount: float = Field(..., description="Payment amount")
+    price_currency: str = Field(..., description="Price currency (usually USD)")
+    pay_currency: str = Field(..., description="Payment currency (crypto)")
+    order_id: str = Field(..., description="Unique order identifier")
+    order_description: Optional[str] = Field(None, description="Order description")
+    success_url: Optional[str] = Field(None, description="Success redirect URL")
+    cancel_url: Optional[str] = Field(None, description="Cancel redirect URL")
+    ipn_callback_url: Optional[str] = Field(None, description="IPN callback URL")
+
+
+class NowPaymentsPaymentResponse(BaseModel):
+    """NowPayments payment creation response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    payment_id: str = Field(..., description="Payment ID")
+    payment_status: str = Field(..., description="Payment status")
+    pay_address: str = Field(..., description="Payment address")
+    price_amount: float = Field(..., description="Price amount")
+    price_currency: str = Field(..., description="Price currency")
+    pay_amount: float = Field(..., description="Payment amount")
+    pay_currency: str = Field(..., description="Payment currency")
+    order_id: str = Field(..., description="Order ID")
+    order_description: Optional[str] = Field(None, description="Order description")
+    invoice_url: Optional[str] = Field(None, description="Payment page URL")
+    success_url: Optional[str] = Field(None, description="Success URL")
+    cancel_url: Optional[str] = Field(None, description="Cancel URL")
+    created_at: str = Field(..., description="Creation timestamp")
+    updated_at: str = Field(..., description="Update timestamp")
+
+
+class NowPaymentsWebhook(BaseModel):
+    """NowPayments webhook/IPN data."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    payment_id: str = Field(..., description="Payment ID")
+    payment_status: str = Field(..., description="Payment status")
+    pay_address: str = Field(..., description="Payment address")
+    price_amount: float = Field(..., description="Price amount")
+    price_currency: str = Field(..., description="Price currency")
+    pay_amount: float = Field(..., description="Payment amount")
+    pay_currency: str = Field(..., description="Payment currency")
+    order_id: str = Field(..., description="Order ID")
+    order_description: Optional[str] = Field(None, description="Order description")
+    outcome_amount: Optional[float] = Field(None, description="Outcome amount")
+    outcome_currency: Optional[str] = Field(None, description="Outcome currency")
+    actually_paid: Optional[float] = Field(None, description="Actually paid amount")
+    txid: Optional[str] = Field(None, description="Transaction ID")
+    created_at: str = Field(..., description="Creation timestamp")
+    updated_at: str = Field(..., description="Update timestamp")
+
+
+class NowPaymentsStatusResponse(BaseModel):
+    """NowPayments payment status response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    payment_id: str = Field(..., description="Payment ID")
+    payment_status: str = Field(..., description="Payment status")
+    pay_address: str = Field(..., description="Payment address")
+    price_amount: float = Field(..., description="Price amount")
+    price_currency: str = Field(..., description="Price currency")
+    pay_amount: float = Field(..., description="Payment amount")
+    pay_currency: str = Field(..., description="Payment currency")
+    order_id: str = Field(..., description="Order ID")
+    order_description: Optional[str] = Field(None, description="Order description")
+    outcome_amount: Optional[float] = Field(None, description="Outcome amount")
+    outcome_currency: Optional[str] = Field(None, description="Outcome currency")
+    actually_paid: Optional[float] = Field(None, description="Actually paid amount")
+    created_at: str = Field(..., description="Creation timestamp")
+    updated_at: str = Field(..., description="Update timestamp")
+
+
+class NowPaymentsCurrenciesResponse(BaseModel):
+    """NowPayments supported currencies response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currencies: List[str] = Field(..., description="List of supported currency codes")
+
+
+class NowPaymentsFullCurrenciesResponse(BaseModel):
+    """NowPayments full currencies response from /v1/full-currencies."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currencies: List[NowPaymentsCurrency] = Field(..., description="List of full currency data")
+
+
+class NowPaymentsMinAmountResponse(BaseModel):
+    """NowPayments minimum amount response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currency_from: str = Field(..., description="Source currency")
+    currency_to: str = Field(..., description="Target currency")
+    min_amount: float = Field(..., description="Minimum payment amount")
+
+
+class NowPaymentsEstimateResponse(BaseModel):
+    """NowPayments payment estimate response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currency_from: str = Field(..., description="Source currency")
+    currency_to: str = Field(..., description="Target currency")
+    amount_from: float = Field(..., description="Source amount")
+    estimated_amount: float = Field(..., description="Estimated target amount")
+    fee_amount: Optional[float] = Field(None, description="Fee amount")
+
+
+class NowPaymentsStatusInfo(BaseModel):
+    """NowPayments API status response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    message: str = Field(..., description="Status message")
+    uptime: Optional[float] = Field(None, description="API uptime percentage")
+
+
+# =============================================================================
+# MONITORING & HEALTH CHECK MODELS
+# =============================================================================
+
+class NowPaymentsStatusResponse(BaseModel):
+    """NowPayments /v1/status response schema for health checks."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    message: str = Field(..., description="Status message")
+    
+    @field_validator('message')
+    @classmethod
+    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