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

django_cfg/apps/payments/services/core/payment_service.py

@@ -8,22 +8,27 @@ and payment lifecycle management.
 import logging
 from typing import Optional, List
 from decimal import Decimal
-from datetime import timezone
-
 from django.db import transaction
 from django.contrib.auth import get_user_model
+from django.utils import timezone
 from pydantic import BaseModel, Field, ValidationError
 
 from .balance_service import BalanceService
+from .fallback_service import get_fallback_service
 from ...models import UniversalPayment, UserBalance, Transaction
 from ...utils.config_utils import get_payments_config
 from ..providers.registry import ProviderRegistry
+from ..monitoring.provider_health import get_health_monitor
 from ..internal_types import (
     ProviderResponse, WebhookData, ServiceOperationResult,
     BalanceUpdateRequest, AccessCheckRequest, AccessCheckResult,
-    PaymentCreationResult, WebhookProcessingResult, PaymentStatusResult
+    PaymentCreationResult, WebhookProcessingResult, PaymentStatusResult,
+    PaymentHistoryItem, ProviderInfo
 )
 
+# Import django_currency module for currency conversion
+from django_cfg.modules.django_currency import convert_currency, CurrencyError
+
 User = get_user_model()
 logger = logging.getLogger(__name__)
 
@@ -281,7 +286,7 @@ class PaymentService:
         status: Optional[str] = None,
         limit: int = 50,
         offset: int = 0
-    ) -> List[dict]:
+    ) -> List[PaymentHistoryItem]:
         """
         Get user's payment history.
         
@@ -292,7 +297,7 @@ class PaymentService:
             offset: Pagination offset
             
         Returns:
-            List of payment dictionaries
+            List of PaymentHistoryItem objects
         """
         try:
             queryset = UniversalPayment.objects.filter(user=user)
@@ -303,16 +308,18 @@ class PaymentService:
             payments = queryset.order_by('-created_at')[offset:offset+limit]
             
             return [
-                {
-                    'id': str(payment.id),
-                    'status': payment.status,
-                    'amount_usd': str(payment.amount_usd),
-                    'pay_amount': str(payment.pay_amount) if payment.pay_amount else str(payment.amount_usd),
-                    'currency_code': payment.currency_code,
-                    'provider': payment.provider.name if payment.provider else None,
-                    'created_at': payment.created_at.isoformat(),
-                    'processed_at': payment.processed_at.isoformat() if payment.processed_at else None
-                }
+                PaymentHistoryItem(
+                    id=str(payment.id),
+                    user_id=payment.user.id,
+                    amount=payment.pay_amount if payment.pay_amount else payment.amount_usd,
+                    currency=payment.currency_code,
+                    status=payment.status,
+                    provider=payment.provider.name if payment.provider else 'unknown',
+                    provider_payment_id=payment.provider_payment_id,
+                    created_at=payment.created_at,
+                    updated_at=payment.updated_at,
+                    metadata=payment.metadata or {}
+                )
                 for payment in payments
             ]
             
@@ -356,7 +363,7 @@ class PaymentService:
     
     def _convert_to_usd(self, amount: Decimal, currency: str) -> Decimal:
         """
-        Convert amount to USD using current exchange rates.
+        Convert amount to USD using django_currency module.
         
         Args:
             amount: Amount to convert
@@ -368,26 +375,202 @@ class PaymentService:
         if currency == 'USD':
             return amount
         
-        # TODO: Implement currency conversion using exchange rate API
-        # For now, return the same amount (assuming USD)
-        logger.warning(f"Currency conversion not implemented for {currency}, using 1:1 rate")
-        return amount
+        try:
+            # Use django_currency module for conversion
+            converted_amount = convert_currency(
+                amount=float(amount),
+                from_currency=currency,
+                to_currency='USD'
+            )
+            
+            logger.info(f"Currency conversion: {amount} {currency} = {converted_amount} USD")
+            return Decimal(str(converted_amount))
+            
+        except CurrencyError as e:
+            logger.error(f"Currency conversion failed for {amount} {currency} to USD: {e}")
+            # Fallback to 1:1 rate if conversion fails
+            logger.warning(f"Using 1:1 fallback rate for {currency} to USD")
+            return amount
+            
+        except Exception as e:
+            logger.error(f"Unexpected error in currency conversion: {e}")
+            # Fallback to 1:1 rate for any other errors
+            logger.warning(f"Using 1:1 fallback rate for {currency} to USD due to error")
+            return amount
+    
+    def process_webhook(self, provider: str, webhook_data: dict, headers: dict = None) -> 'WebhookProcessingResult':
+        """
+        Process webhook from payment provider.
+        
+        Args:
+            provider: Provider name
+            webhook_data: Webhook payload
+            headers: Request headers for validation
+            
+        Returns:
+            WebhookProcessingResult with processing status
+        """
+        try:
+            # Get provider instance for validation
+            provider_instance = self.provider_registry.get_provider(provider)
+            if not provider_instance:
+                return WebhookProcessingResult(
+                    success=False,
+                    error_message=f"Unknown provider: {provider}"
+                )
+            
+            # Validate webhook
+            if hasattr(provider_instance, 'validate_webhook'):
+                is_valid = provider_instance.validate_webhook(webhook_data, headers)
+                if not is_valid:
+                    logger.warning(f"Invalid webhook from {provider}: {webhook_data}")
+                    return WebhookProcessingResult(
+                        success=False,
+                        error_message="Webhook validation failed"
+                    )
+            
+            # Process webhook data
+            processed_data = provider_instance.process_webhook(webhook_data)
+            
+            # Find payment record
+            payment_id = processed_data.payment_id
+            if not payment_id:
+                return WebhookProcessingResult(
+                    success=False,
+                    error_message="No payment ID found in webhook"
+                )
+            
+            # Update payment
+            with transaction.atomic():
+                try:
+                    payment = UniversalPayment.objects.get(
+                        provider_payment_id=payment_id,
+                        provider=provider
+                    )
+                    
+                    # Update payment status and data
+                    old_status = payment.status
+                    payment.update_from_webhook(webhook_data)
+                    
+                    # Create event for audit trail
+                    self._create_payment_event(
+                        payment=payment,
+                        event_type='webhook_processed',
+                        data={
+                            'provider': provider,
+                            'old_status': old_status,
+                            'new_status': payment.status,
+                            'webhook_data': webhook_data
+                        }
+                    )
+                    
+                    # Process completion if needed
+                    if payment.is_completed and old_status != payment.status:
+                        success = self._process_payment_completion(payment)
+                        if success:
+                            payment.processed_at = timezone.now()
+                            payment.save()
+                    
+                    return WebhookProcessingResult(
+                        success=True,
+                        payment_id=str(payment.id),
+                        new_status=payment.status
+                    )
+                    
+                except UniversalPayment.DoesNotExist:
+                    logger.error(f"Payment not found for webhook: provider={provider}, payment_id={payment_id}")
+                    return WebhookProcessingResult(
+                        success=False,
+                        error_message="Payment not found"
+                    )
+        
+        except Exception as e:
+            logger.error(f"Error processing webhook from {provider}: {e}")
+            return WebhookProcessingResult(
+                success=False,
+                error_message=str(e)
+            )
     
+    def _create_payment_event(self, payment: UniversalPayment, event_type: str, data: dict):
+        """
+        Create payment event for audit trail.
+        
+        Args:
+            payment: Payment object
+            event_type: Type of event
+            data: Event data
+        """
+        try:
+            from ...models.events import PaymentEvent
+            
+            # Get next sequence number
+            last_event = PaymentEvent.objects.filter(
+                payment_id=str(payment.id)
+            ).order_by('-sequence_number').first()
+            
+            sequence_number = (last_event.sequence_number + 1) if last_event else 1
+            
+            PaymentEvent.objects.create(
+                payment_id=str(payment.id),
+                event_type=event_type,
+                sequence_number=sequence_number,
+                event_data=data,
+                processed_by=f"payment_service_{timezone.now().timestamp()}",
+                correlation_id=data.get('correlation_id'),
+                idempotency_key=f"{payment.id}_{event_type}_{sequence_number}"
+            )
+            
+        except Exception as e:
+            logger.error(f"Failed to create payment event: {e}")
     
-    def list_available_providers(self) -> List[dict]:
+    def get_payment_events(self, payment_id: str) -> List[dict]:
+        """
+        Get all events for a payment.
+        
+        Args:
+            payment_id: Payment ID
+            
+        Returns:
+            List of payment events
+        """
+        try:
+            from ...models.events import PaymentEvent
+            
+            events = PaymentEvent.objects.filter(
+                payment_id=payment_id
+            ).order_by('sequence_number')
+            
+            return [
+                {
+                    'id': str(event.id),
+                    'event_type': event.event_type,
+                    'sequence_number': event.sequence_number,
+                    'event_data': event.event_data,
+                    'created_at': event.created_at,
+                    'processed_by': event.processed_by
+                }
+                for event in events
+            ]
+            
+        except Exception as e:
+            logger.error(f"Error getting payment events for {payment_id}: {e}")
+            return []
+    
+    
+    def list_available_providers(self) -> List[ProviderInfo]:
         """
         List all available payment providers.
         
         Returns:
-            List of provider information
+            List of ProviderInfo objects
         """
         return [
-            {
-                'name': name,
-                'display_name': provider.get_display_name(),
-                'supported_currencies': provider.get_supported_currencies(),
-                'is_active': provider.is_active(),
-                'provider_type': provider.get_provider_type()
-            }
+            ProviderInfo(
+                name=name,
+                display_name=provider.get_display_name(),
+                supported_currencies=provider.get_supported_currencies(),
+                is_active=provider.is_active(),
+                features={'provider_type': provider.get_provider_type()}
+            )
             for name, provider in self.provider_registry.get_all_providers().items()
         ]

django_cfg/apps/payments/services/core/subscription_service.py

@@ -91,7 +91,7 @@ class SubscriptionService:
                 existing = Subscription.objects.filter(
                     user=user,
                     endpoint_group=endpoint_group,
-                    status='active',
+                    status=Subscription.SubscriptionStatus.ACTIVE,
                     expires_at__gt=timezone.now()
                 ).first()
                 
@@ -105,8 +105,8 @@ class SubscriptionService:
                 subscription = Subscription.objects.create(
                     user=user,
                     endpoint_group=endpoint_group,
-                    tier='basic',
-                    status='active',
+                    tier=Subscription.SubscriptionTier.BASIC,
+                    status=Subscription.SubscriptionStatus.ACTIVE,
                     monthly_price=endpoint_group.basic_price,
                     usage_limit=endpoint_group.basic_limit,
                     usage_current=0,
@@ -268,7 +268,7 @@ class SubscriptionService:
             
             if active_only:
                 queryset = queryset.filter(
-                    status='active',
+                    status=Subscription.SubscriptionStatus.ACTIVE,
                     expires_at__gt=timezone.now()
                 )
             
@@ -393,20 +393,18 @@ class SubscriptionService:
                         error_message="Subscription not found"
                     )
                 
-                # Update billing period if provided
-                if billing_period:
-                    subscription.billing_period = billing_period
-                
-                # Calculate new expiry
+                # Calculate new expiry based on billing period
                 now = timezone.now()
-                # Always renew for monthly (30 days) as we don't have billing_period field
-                new_expiry = now + timedelta(days=30)
+                if billing_period == 'yearly':
+                    new_expiry = now + timedelta(days=365)
+                else:  # Default to monthly
+                    new_expiry = now + timedelta(days=30)
                 
-                # Update subscription
+                # Update subscription using correct enum
                 subscription.expires_at = new_expiry
-                subscription.next_billing = new_expiry  # Model uses next_billing, not next_billing_at
-                subscription.status = 'active'  # Use string instead of enum
-                subscription.usage_current = 0  # Reset usage - correct field name
+                subscription.next_billing = new_expiry
+                subscription.status = subscription.SubscriptionStatus.ACTIVE  # Use proper enum
+                subscription.usage_current = 0  # Reset usage counter
                 subscription.save()
                 
                 
@@ -527,7 +525,7 @@ class SubscriptionService:
             subscription = Subscription.objects.select_related('endpoint_group').get(
                 user_id=user_id,
                 endpoint_group__name=endpoint_group,
-                status='active',
+                status=Subscription.SubscriptionStatus.ACTIVE,
                 expires_at__gt=timezone.now()
             )
             
@@ -586,7 +584,7 @@ class SubscriptionService:
             subscription = Subscription.objects.select_related('endpoint_group').get(
                 user_id=user_id,
                 endpoint_group__name=endpoint_group,
-                status='active',
+                status=Subscription.SubscriptionStatus.ACTIVE,
                 expires_at__gt=timezone.now()
             )
             

django_cfg/apps/payments/services/internal_types.py

@@ -264,3 +264,34 @@ class SubscriptionAnalytics(BaseModel):
     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/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
+    )