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

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

@@ -1,576 +1,452 @@
 """
-Payment Service - Core payment processing logic.
+Payment service for the Universal Payment System v2.0.
 
-This service handles universal payment operations, provider orchestration,
-and payment lifecycle management.
+Handles payment creation, status checking, and lifecycle management.
 """
 
-import logging
-from typing import Optional, List
+from typing import Optional, Dict, Any
 from decimal import Decimal
-from django.db import transaction
-from django.contrib.auth import get_user_model
+from django.contrib.auth.models import User
 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,
-    PaymentHistoryItem, ProviderInfo
+from .base import BaseService
+from ..types import (
+    PaymentCreateRequest, PaymentStatusRequest, PaymentResult,
+    PaymentData, ServiceOperationResult
 )
+from ...models import UniversalPayment, Currency, ProviderCurrency
+from django_cfg.modules.django_currency import convert_currency, get_exchange_rate
+# ConfigService removed - using direct Constance access
+from ..providers import ProviderRegistry, get_provider_registry
 
-# 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__)
-
-
-class PaymentRequest(BaseModel):
-    """Type-safe payment request validation"""
-    user_id: int = Field(gt=0, description="User ID")
-    amount: Decimal = Field(gt=0, description="Payment amount")
-    currency: str = Field(min_length=3, max_length=10, description="Currency code")
-    provider: str = Field(min_length=1, description="Payment provider name")
-    callback_url: Optional[str] = Field(None, description="Success callback URL")
-    cancel_url: Optional[str] = Field(None, description="Cancellation URL")
-    metadata: dict = Field(default_factory=dict, description="Additional metadata")
-
-
-class PaymentResult(BaseModel):
-    """Type-safe payment operation result"""
-    success: bool
-    payment_id: Optional[str] = None
-    provider_payment_id: Optional[str] = None
-    payment_url: Optional[str] = None
-    error_message: Optional[str] = None
-    error_code: Optional[str] = None
-    metadata: dict = Field(default_factory=dict)
-
-
-class WebhookProcessingResult(BaseModel):
-    """Type-safe webhook processing result"""
-    success: bool
-    payment_id: Optional[str] = None
-    status_updated: bool = False
-    balance_updated: bool = False
-    error_message: Optional[str] = None
-
-
-class PaymentService:
+class PaymentService(BaseService):
     """
-    Universal payment processing service.
+    Payment service with business logic and validation.
     
-    Handles payment creation, webhook processing, and provider management.
-    Integrates with balance management and caching.
+    Handles payment operations using Pydantic validation and Django ORM managers.
     """
     
     def __init__(self):
-        """Initialize payment service with dependencies"""
-        self.provider_registry = ProviderRegistry()
-        self.config = get_payments_config()
+        """Initialize payment service with configuration."""
+        super().__init__()
+        # Direct Constance access instead of ConfigService
+        self.provider_registry = get_provider_registry()
     
-    def create_payment(self, payment_data: dict) -> 'PaymentCreationResult':
+    def create_payment(self, request: PaymentCreateRequest) -> PaymentResult:
         """
-        Create a new payment with the specified provider.
+        Create new payment with full validation.
         
         Args:
-            payment_data: Dictionary with payment details
+            request: Payment creation request with validation
             
         Returns:
-            PaymentCreationResult with payment details or error information
+            PaymentResult: Result with payment data or error
         """
         try:
-            # Validate payment request
-            request = PaymentRequest(
-                user_id=payment_data['user_id'],
-                amount=payment_data['amount'],
-                currency=payment_data.get('currency', 'USD'),
-                provider=payment_data['provider'],
-                metadata=payment_data.get('metadata', {})
-            )
+            # Validate request
+            if isinstance(request, dict):
+                request = PaymentCreateRequest(**request)
             
-            # Get provider instance
-            provider_instance = self.provider_registry.get_provider(request.provider)
-            if not provider_instance:
-                return PaymentCreationResult(
+            self.logger.info("Creating payment", extra={
+                'user_id': request.user_id,
+                'amount_usd': request.amount_usd,
+                'currency_code': request.currency_code,
+                'provider': request.provider
+            })
+            
+            # Get user
+            try:
+                user = User.objects.get(id=request.user_id)
+            except User.DoesNotExist:
+                return PaymentResult(
                     success=False,
-                    error=f"Payment provider '{request.provider}' is not available"
+                    message=f"User {request.user_id} not found",
+                    error_code="user_not_found"
                 )
             
-            # Get user
-            user = User.objects.get(id=request.user_id)
+            # Validate currency
+            currency_result = self._validate_currency(request.currency_code)
+            if not currency_result.success:
+                return PaymentResult(
+                    success=False,
+                    message=currency_result.message,
+                    error_code=currency_result.error_code
+                )
             
-            # Convert currency if needed
-            amount_usd = self._convert_to_usd(request.amount, request.currency) if request.currency != 'USD' else request.amount
+            # Get provider for payment creation
+            provider = self.provider_registry.get_provider(request.provider)
+            if not provider:
+                return PaymentResult(
+                    success=False,
+                    message=f"Provider {request.provider} not available",
+                    error_code="provider_not_available"
+                )
             
-            # Create payment record
-            with transaction.atomic():
+            # Create payment in database first
+            def create_payment_transaction():
                 payment = UniversalPayment.objects.create(
                     user=user,
+                    amount_usd=request.amount_usd,
+                    currency_code=request.currency_code,
                     provider=request.provider,
-                    amount_usd=amount_usd,
-                    currency_code=request.currency,
                     status=UniversalPayment.PaymentStatus.PENDING,
-                    metadata=request.metadata
+                    callback_url=request.callback_url,
+                    cancel_url=request.cancel_url,
+                    description=request.description,
+                    metadata=request.metadata,
+                    expires_at=timezone.now() + timezone.timedelta(hours=1)  # 1 hour expiry
                 )
-                
-                # Prepare provider data
-                provider_data = {
-                    'amount': float(request.amount),
-                    'currency': request.currency,
-                    'user_id': user.id,
-                    'payment_id': str(payment.id),
-                    'callback_url': request.callback_url,
-                    'cancel_url': request.cancel_url,
-                    **request.metadata
-                }
-                
-                # Process with provider
-                provider_result = provider_instance.create_payment(provider_data)
-                
-                if provider_result.success:
-                    # Update payment with provider data
-                    payment.provider_payment_id = provider_result.provider_payment_id
-                    payment.save()
-                    
-                    
-                    return PaymentCreationResult(
-                        success=True,
-                        payment_id=str(payment.id),
-                        provider_payment_id=provider_result.provider_payment_id,
-                        payment_url=provider_result.payment_url
-                    )
-                else:
-                    # Mark payment as failed
-                    payment.status = UniversalPayment.PaymentStatus.FAILED
-                    payment.error_message = provider_result.error_message or 'Unknown provider error'
+                return payment
+            
+            payment = self._execute_with_transaction(create_payment_transaction)
+            
+            # Create payment with provider
+            from ..providers.base import PaymentRequest as ProviderPaymentRequest
+            
+            provider_request = ProviderPaymentRequest(
+                amount_usd=request.amount_usd,
+                currency_code=request.currency_code,
+                order_id=str(payment.id),
+                callback_url=request.callback_url,
+                cancel_url=request.cancel_url,
+                description=request.description,
+                metadata=request.metadata
+            )
+            
+            provider_response = provider.create_payment(provider_request)
+            
+            # Update payment with provider response
+            if provider_response.success:
+                def update_payment_transaction():
+                    payment.provider_payment_id = provider_response.provider_payment_id
+                    payment.crypto_amount = provider_response.amount
+                    payment.payment_url = provider_response.payment_url
+                    payment.qr_code_url = provider_response.qr_code_url
+                    payment.wallet_address = provider_response.wallet_address
+                    if provider_response.expires_at:
+                        payment.expires_at = provider_response.expires_at
                     payment.save()
-                    
-                    return PaymentCreationResult(
-                        success=False,
-                        payment_id=str(payment.id),
-                        error=provider_result.error_message or 'Payment creation failed'
-                    )
-                    
-        except ValidationError as e:
-            logger.error(f"Payment validation error: {e}")
-            return PaymentCreationResult(
-                success=False,
-                error=f"Invalid payment data: {e}"
+                    return payment
+                
+                payment = self._execute_with_transaction(update_payment_transaction)
+            else:
+                # Mark payment as failed if provider creation failed
+                payment.mark_failed(
+                    reason=provider_response.error_message,
+                    error_code="provider_creation_failed"
+                )
+            
+            # Convert to PaymentData for response
+            payment_data = PaymentData.model_validate(payment)
+            
+            self._log_operation(
+                "create_payment",
+                True,
+                payment_id=str(payment.id),
+                user_id=request.user_id,
+                amount_usd=request.amount_usd
             )
-        except Exception as e:
-            logger.error(f"Payment creation failed: {e}", exc_info=True)
-            return PaymentCreationResult(
-                success=False,
-                error=f"Internal error: {str(e)}"
+            
+            return PaymentResult(
+                success=True,
+                message="Payment created successfully",
+                payment_id=str(payment.id),
+                status=payment.status,
+                amount_usd=payment.amount_usd,
+                crypto_amount=payment.crypto_amount,
+                currency_code=payment.currency_code,
+                expires_at=payment.expires_at,
+                data={'payment': payment_data.model_dump()}
             )
+            
+        except Exception as e:
+            return PaymentResult(**self._handle_exception(
+                "create_payment", e,
+                user_id=request.user_id if hasattr(request, 'user_id') else None
+            ).model_dump())
     
-    def process_webhook(
-        self,
-        provider: str,
-        webhook_data: dict,
-        request_headers: Optional[dict] = None
-    ) -> 'WebhookProcessingResult':
+    def get_payment_status(self, request: PaymentStatusRequest) -> PaymentResult:
         """
-        Process payment webhook from provider.
+        Get payment status with optional provider check.
         
         Args:
-            provider: Payment provider name
-            webhook_data: Webhook payload data
-            request_headers: HTTP headers for validation
+            request: Payment status request
             
         Returns:
-            WebhookProcessingResult with processing status
+            PaymentResult: Current payment status
         """
         try:
-            # Get provider instance
-            provider_instance = self.provider_registry.get_provider(provider)
-            if not provider_instance:
-                return WebhookProcessingResult(
-                    success=False,
-                    error=f"Provider '{provider}' not found"
-                )
+            # Validate request
+            if isinstance(request, dict):
+                request = PaymentStatusRequest(**request)
             
-            # Process webhook with provider
-            webhook_result = provider_instance.process_webhook(webhook_data)
-            if not webhook_result.success:
-                return WebhookProcessingResult(
-                    success=False,
-                    error=webhook_result.error_message or "Webhook processing failed"
-                )
+            self.logger.debug("Getting payment status", extra={
+                'payment_id': request.payment_id,
+                'force_provider_check': request.force_provider_check
+            })
             
-            # Find payment by provider payment ID
+            # Get payment
             try:
-                payment = UniversalPayment.objects.get(
-                    provider_payment_id=webhook_result.provider_payment_id
-                )
+                payment = UniversalPayment.objects.get(id=request.payment_id)
             except UniversalPayment.DoesNotExist:
-                return WebhookProcessingResult(
+                return PaymentResult(
                     success=False,
-                    error=f"Payment not found: {webhook_result.provider_payment_id}"
+                    message=f"Payment {request.payment_id} not found",
+                    error_code="payment_not_found"
                 )
             
-            # Process payment status update
-            old_status = payment.status
-            new_status = webhook_result.status
-            
-            with transaction.atomic():
-                # Update payment
-                payment.status = new_status
-                payment.save()
-                
-                # Process completion if status changed to completed
-                balance_updated = False
-                if (new_status == UniversalPayment.PaymentStatus.COMPLETED and 
-                    old_status != UniversalPayment.PaymentStatus.COMPLETED):
-                    balance_updated = self._process_payment_completion(payment)
-                
-                
-                return WebhookProcessingResult(
-                    success=True,
-                    payment_id=str(payment.id),
-                    status_updated=(old_status != new_status),
-                    balance_updated=balance_updated
+            # Check user authorization if provided
+            if request.user_id and payment.user_id != request.user_id:
+                return PaymentResult(
+                    success=False,
+                    message="Access denied to payment",
+                    error_code="access_denied"
                 )
-                
-        except Exception as e:
-            logger.error(f"Webhook processing failed for {provider}: {e}", exc_info=True)
-            return WebhookProcessingResult(
-                success=False,
-                error=f"Webhook processing error: {str(e)}"
-            )
-    
-    def get_payment_status(self, payment_id: str) -> Optional['PaymentStatusResult']:
-        """
-        Get payment status by ID.
-        
-        Args:
-            payment_id: Payment UUID
             
-        Returns:
-            Payment status information or None if not found
-        """
-        try:
+            # Force provider check if requested
+            if request.force_provider_check:
+                provider_result = self._check_provider_status(payment)
+                if provider_result.success and provider_result.data.get('status_changed'):
+                    # Reload payment if status was updated
+                    payment.refresh_from_db()
             
-            # Get from database
-            payment = UniversalPayment.objects.get(id=payment_id)
+            # Convert to PaymentData
+            payment_data = PaymentData.model_validate(payment)
             
-            return PaymentStatusResult(
+            return PaymentResult(
+                success=True,
+                message="Payment status retrieved",
                 payment_id=str(payment.id),
                 status=payment.status,
                 amount_usd=payment.amount_usd,
+                crypto_amount=payment.crypto_amount,
                 currency_code=payment.currency_code,
-                provider=payment.provider,
                 provider_payment_id=payment.provider_payment_id,
-                created_at=payment.created_at,
-                updated_at=payment.updated_at
+                payment_url=payment.payment_url,
+                qr_code_url=payment.qr_code_url,
+                wallet_address=payment.wallet_address,
+                expires_at=payment.expires_at,
+                data={'payment': payment_data.model_dump()}
             )
             
-        except UniversalPayment.DoesNotExist:
-            return None
         except Exception as e:
-            logger.error(f"Error getting payment status {payment_id}: {e}")
-            return None
+            return PaymentResult(**self._handle_exception(
+                "get_payment_status", e,
+                payment_id=request.payment_id if hasattr(request, 'payment_id') else None
+            ).model_dump())
     
-    def get_user_payments(
-        self,
-        user: User,
-        status: Optional[str] = None,
-        limit: int = 50,
-        offset: int = 0
-    ) -> List[PaymentHistoryItem]:
+    def cancel_payment(self, payment_id: str, reason: str = None) -> PaymentResult:
         """
-        Get user's payment history.
+        Cancel payment if possible.
         
         Args:
-            user: User object
-            status: Filter by payment status
-            limit: Number of payments to return
-            offset: Pagination offset
+            payment_id: Payment ID to cancel
+            reason: Cancellation reason
             
         Returns:
-            List of PaymentHistoryItem objects
+            PaymentResult: Cancellation result
         """
         try:
-            queryset = UniversalPayment.objects.filter(user=user)
+            self.logger.info("Cancelling payment", extra={
+                'payment_id': payment_id,
+                'reason': reason
+            })
             
-            if status:
-                queryset = queryset.filter(status=status)
+            # Get payment
+            try:
+                payment = UniversalPayment.objects.get(id=payment_id)
+            except UniversalPayment.DoesNotExist:
+                return PaymentResult(
+                    success=False,
+                    message=f"Payment {payment_id} not found",
+                    error_code="payment_not_found"
+                )
             
-            payments = queryset.order_by('-created_at')[offset:offset+limit]
+            # Check if payment can be cancelled
+            if not payment.can_be_cancelled():
+                return PaymentResult(
+                    success=False,
+                    message=f"Payment {payment_id} cannot be cancelled (status: {payment.status})",
+                    error_code="cannot_cancel"
+                )
+            
+            # Cancel using manager
+            def cancel_payment_transaction():
+                return payment.cancel(reason)
             
-            return [
-                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,
+            success = self._execute_with_transaction(cancel_payment_transaction)
+            
+            if success:
+                payment.refresh_from_db()
+                payment_data = PaymentData.model_validate(payment)
+                
+                self._log_operation(
+                    "cancel_payment",
+                    True,
+                    payment_id=payment_id,
+                    reason=reason
+                )
+                
+                return PaymentResult(
+                    success=True,
+                    message="Payment cancelled successfully",
+                    payment_id=str(payment.id),
                     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 {}
+                    data={'payment': payment_data.model_dump()}
                 )
-                for payment in payments
-            ]
-            
+            else:
+                return PaymentResult(
+                    success=False,
+                    message="Failed to cancel payment",
+                    error_code="cancel_failed"
+                )
+                
         except Exception as e:
-            logger.error(f"Error getting user payments for {user.id}: {e}")
-            return []
+            return PaymentResult(**self._handle_exception(
+                "cancel_payment", e,
+                payment_id=payment_id
+            ).model_dump())
     
-    def _process_payment_completion(self, payment: UniversalPayment) -> bool:
-        """
-        Process completed payment by adding funds to user balance.
-        
-        Args:
-            payment: Completed payment object
-            
-        Returns:
-            True if balance was updated, False otherwise
-        """
+    def _validate_currency(self, currency_code: str) -> ServiceOperationResult:
+        """Validate currency is supported."""
         try:
+            currency = Currency.objects.get(code=currency_code, is_enabled=True)
+            
+            # Check if currency is supported by any provider
+            provider_currency = ProviderCurrency.objects.filter(
+                currency=currency,
+                is_enabled=True
+            ).first()
+            
+            if not provider_currency:
+                return self._create_error_result(
+                    f"Currency {currency_code} not supported by any provider",
+                    "currency_not_supported"
+                )
             
-            balance_service = BalanceService()
-            result = balance_service.add_funds(
-                user=payment.user,
-                amount=payment.amount_usd,
-                currency_code='USD',
-                source='payment',
-                reference_id=str(payment.id),
-                metadata={
-                    'provider': payment.provider.name if payment.provider else 'unknown',
-                    'provider_payment_id': payment.provider_payment_id,
-                    'pay_amount': str(payment.pay_amount) if payment.pay_amount else str(payment.amount_usd),
-                    'currency_code': payment.currency_code
-                }
+            return self._create_success_result(
+                "Currency is valid",
+                {'currency': currency_code}
             )
             
-            
-            return result.success
-            
-        except Exception as e:
-            logger.error(f"Error processing payment completion {payment.id}: {e}")
-            return False
+        except Currency.DoesNotExist:
+            return self._create_error_result(
+                f"Currency {currency_code} not found",
+                "currency_not_found"
+            )
     
-    def _convert_to_usd(self, amount: Decimal, currency: str) -> Decimal:
-        """
-        Convert amount to USD using django_currency module.
-        
-        Args:
-            amount: Amount to convert
-            currency: Source currency
-            
-        Returns:
-            Amount in USD
-        """
-        if currency == 'USD':
-            return amount
-        
+    def _convert_usd_to_crypto(self, amount_usd: float, currency_code: str) -> ServiceOperationResult:
+        """Convert USD amount to cryptocurrency."""
         try:
             # Use django_currency module for conversion
-            converted_amount = convert_currency(
-                amount=float(amount),
-                from_currency=currency,
-                to_currency='USD'
-            )
+            crypto_amount = convert_currency(amount_usd, 'USD', currency_code)
             
-            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
+            return self._create_success_result(
+                "Currency converted successfully",
+                {
+                    'amount_usd': amount_usd,
+                    'crypto_amount': Decimal(str(crypto_amount)),
+                    'currency_code': currency_code,
+                    'exchange_rate': get_exchange_rate('USD', currency_code)
+                }
+            )
             
         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
+            return self._create_error_result(
+                f"Currency conversion failed: {e}",
+                "conversion_failed"
+            )
     
-    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
-        """
+    def _check_provider_status(self, payment: UniversalPayment) -> ServiceOperationResult:
+        """Check payment status with provider."""
         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"
-                )
+            # This would integrate with provider services
+            # For now, return success without changes
+            return self._create_success_result(
+                "Provider status checked",
+                {'status_changed': False}
+            )
             
-            # 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)
+            return self._create_error_result(
+                f"Provider check failed: {e}",
+                "provider_check_failed"
             )
     
-    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
-        """
+    def get_user_payments(
+        self, 
+        user_id: int, 
+        status: Optional[str] = None,
+        limit: int = 50,
+        offset: int = 0
+    ) -> ServiceOperationResult:
+        """Get user payments with pagination."""
         try:
-            from ...models.events import PaymentEvent
+            queryset = UniversalPayment.objects.filter(user_id=user_id)
             
-            # Get next sequence number
-            last_event = PaymentEvent.objects.filter(
-                payment_id=str(payment.id)
-            ).order_by('-sequence_number').first()
+            if status:
+                queryset = queryset.filter(status=status)
             
-            sequence_number = (last_event.sequence_number + 1) if last_event else 1
+            total_count = queryset.count()
+            payments = queryset.order_by('-created_at')[offset:offset + limit]
             
-            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}"
+            payment_data = [
+                PaymentData.model_validate(payment).model_dump()
+                for payment in payments
+            ]
+            
+            return self._create_success_result(
+                f"Retrieved {len(payment_data)} payments",
+                {
+                    'payments': payment_data,
+                    'total_count': total_count,
+                    'limit': limit,
+                    'offset': offset,
+                    'has_more': offset + limit < total_count
+                }
             )
             
         except Exception as e:
-            logger.error(f"Failed to create payment event: {e}")
+            return self._handle_exception(
+                "get_user_payments", e,
+                user_id=user_id
+            )
     
-    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
-        """
+    def get_payment_stats(self, days: int = 30) -> ServiceOperationResult:
+        """Get payment statistics."""
         try:
-            from ...models.events import PaymentEvent
+            from datetime import timedelta
+            
+            since = timezone.now() - timedelta(days=days)
+            
+            stats = UniversalPayment.objects.filter(
+                created_at__gte=since
+            ).aggregate(
+                total_payments=models.Count('id'),
+                total_amount_usd=models.Sum('amount_usd'),
+                completed_payments=models.Count(
+                    'id', 
+                    filter=models.Q(status=UniversalPayment.PaymentStatus.COMPLETED)
+                ),
+                failed_payments=models.Count(
+                    'id',
+                    filter=models.Q(status=UniversalPayment.PaymentStatus.FAILED)
+                )
+            )
             
-            events = PaymentEvent.objects.filter(
-                payment_id=payment_id
-            ).order_by('sequence_number')
+            # Calculate success rate
+            total = stats['total_payments'] or 0
+            completed = stats['completed_payments'] or 0
+            success_rate = (completed / total * 100) if total > 0 else 0
             
-            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
-            ]
+            stats['success_rate'] = round(success_rate, 2)
+            stats['period_days'] = days
             
-        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 ProviderInfo objects
-        """
-        return [
-            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()}
+            return self._create_success_result(
+                f"Payment statistics for {days} days",
+                stats
             )
-            for name, provider in self.provider_registry.get_all_providers().items()
-        ]
+            
+        except Exception as e:
+            return self._handle_exception("get_payment_stats", e)