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

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

@@ -0,0 +1,166 @@
+"""
+Base service class for the Universal Payment System v2.0.
+
+Provides common functionality for all services.
+"""
+
+from abc import ABC
+from typing import Optional, Dict, Any, Type
+from django.db import transaction
+from django_cfg.modules.django_logger import get_logger
+from ..types import ServiceOperationResult
+
+
+class BaseService(ABC):
+    """
+    Base service class with common functionality.
+    
+    Provides logging, error handling, and transaction management.
+    """
+    
+    def __init__(self):
+        """Initialize base service."""
+        self.logger = get_logger(f"services.{self.__class__.__name__.lower()}")
+        self._cache = {}
+        
+        # Initialize config service
+        from ...config.constance import get_payment_config_service
+        self.config_service = get_payment_config_service()
+    
+    def _create_success_result(
+        self, 
+        message: str = "Operation completed successfully",
+        data: Optional[Dict[str, Any]] = None
+    ) -> ServiceOperationResult:
+        """Create success result."""
+        return ServiceOperationResult(
+            success=True,
+            message=message,
+            data=data or {}
+        )
+    
+    def _create_error_result(
+        self,
+        message: str,
+        error_code: Optional[str] = None,
+        data: Optional[Dict[str, Any]] = None
+    ) -> ServiceOperationResult:
+        """Create error result."""
+        return ServiceOperationResult(
+            success=False,
+            message=message,
+            error_code=error_code,
+            data=data or {}
+        )
+    
+    def _log_operation(
+        self,
+        operation: str,
+        success: bool,
+        **kwargs
+    ) -> None:
+        """Log service operation."""
+        log_data = {
+            'service': self.__class__.__name__,
+            'operation': operation,
+            'success': success,
+            **kwargs
+        }
+        
+        if success:
+            self.logger.info(f"Operation {operation} completed successfully", extra=log_data)
+        else:
+            self.logger.error(f"Operation {operation} failed", extra=log_data)
+    
+    def _handle_exception(
+        self,
+        operation: str,
+        exception: Exception,
+        **context
+    ) -> ServiceOperationResult:
+        """Handle service exception."""
+        error_message = f"Service error in {operation}: {str(exception)}"
+        
+        self.logger.error(error_message, extra={
+            'service': self.__class__.__name__,
+            'operation': operation,
+            'exception_type': type(exception).__name__,
+            'exception_message': str(exception),
+            **context
+        }, exc_info=True)
+        
+        return self._create_error_result(
+            message=error_message,
+            error_code=type(exception).__name__.lower(),
+            data={'context': context}
+        )
+    
+    @transaction.atomic
+    def _execute_with_transaction(self, operation_func, *args, **kwargs):
+        """Execute operation within database transaction."""
+        try:
+            return operation_func(*args, **kwargs)
+        except Exception as e:
+            self.logger.error(f"Transaction rolled back due to error: {e}")
+            raise
+    
+    def _validate_input(self, data: Any, model_class: Type) -> Any:
+        """Validate input data using Pydantic model."""
+        try:
+            if isinstance(data, dict):
+                return model_class(**data)
+            elif isinstance(data, model_class):
+                return data
+            else:
+                return model_class.model_validate(data)
+        except Exception as e:
+            raise ValueError(f"Invalid input data: {e}")
+    
+    def _get_cache_key(self, prefix: str, *args) -> str:
+        """Generate cache key."""
+        key_parts = [prefix] + [str(arg) for arg in args]
+        return ":".join(key_parts)
+    
+    def _cache_get(self, key: str) -> Optional[Any]:
+        """Get value from cache."""
+        return self._cache.get(key)
+    
+    def _cache_set(self, key: str, value: Any, ttl: int = 300) -> None:
+        """Set value in cache."""
+        # Simple in-memory cache for now
+        # In production, this would use Redis
+        self._cache[key] = value
+    
+    def _cache_delete(self, key: str) -> None:
+        """Delete value from cache."""
+        self._cache.pop(key, None)
+    
+    def _cache_clear(self, prefix: Optional[str] = None) -> None:
+        """Clear cache entries."""
+        if prefix:
+            keys_to_delete = [k for k in self._cache.keys() if k.startswith(prefix)]
+            for key in keys_to_delete:
+                del self._cache[key]
+        else:
+            self._cache.clear()
+    
+    def get_service_stats(self) -> Dict[str, Any]:
+        """Get service statistics."""
+        return {
+            'service_name': self.__class__.__name__,
+            'cache_size': len(self._cache),
+            'cache_keys': list(self._cache.keys())
+        }
+    
+    def health_check(self) -> ServiceOperationResult:
+        """Perform service health check."""
+        try:
+            # Basic health check - can be overridden by subclasses
+            stats = self.get_service_stats()
+            
+            return self._create_success_result(
+                message=f"{self.__class__.__name__} is healthy",
+                data=stats
+            )
+        except Exception as e:
+            return self._handle_exception("health_check", e)

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

@@ -0,0 +1,478 @@
+"""
+Currency service for the Universal Payment System v2.0.
+
+Handles currency conversion and rate management using django_currency module.
+"""
+
+from typing import Optional, Dict, Any, List
+from decimal import Decimal
+from django.utils import timezone
+from datetime import timedelta
+
+from .base import BaseService
+from ..types import (
+    CurrencyConversionRequest, CurrencyConversionResult, CurrencyData,
+    ServiceOperationResult
+)
+from ...models import Currency, ProviderCurrency, Network
+from django_cfg.modules.django_currency import (
+    convert_currency, get_exchange_rate, CurrencyError
+)
+
+
+class CurrencyService(BaseService):
+    """
+    Currency service with conversion and rate management.
+    
+    Integrates with django_currency module for real-time rates.
+    """
+    
+    def convert_currency(self, request: CurrencyConversionRequest) -> CurrencyConversionResult:
+        """
+        Convert amount between currencies.
+        
+        Args:
+            request: Currency conversion request
+            
+        Returns:
+            CurrencyConversionResult: Conversion result with rate
+        """
+        try:
+            # Validate request
+            if isinstance(request, dict):
+                request = CurrencyConversionRequest(**request)
+            
+            self.logger.debug("Converting currency", extra={
+                'amount': request.amount,
+                'from_currency': request.from_currency,
+                'to_currency': request.to_currency
+            })
+            
+            # Check if currencies are supported
+            validation_result = self._validate_currencies(
+                request.from_currency, 
+                request.to_currency
+            )
+            if not validation_result.success:
+                return CurrencyConversionResult(
+                    success=False,
+                    message=validation_result.message,
+                    error_code=validation_result.error_code
+                )
+            
+            # Perform conversion using django_currency
+            try:
+                converted_amount = convert_currency(
+                    request.amount,
+                    request.from_currency,
+                    request.to_currency
+                )
+                
+                exchange_rate = get_exchange_rate(
+                    request.from_currency,
+                    request.to_currency
+                )
+                
+                self._log_operation(
+                    "convert_currency",
+                    True,
+                    from_currency=request.from_currency,
+                    to_currency=request.to_currency,
+                    amount=request.amount,
+                    converted_amount=converted_amount,
+                    exchange_rate=exchange_rate
+                )
+                
+                return CurrencyConversionResult(
+                    success=True,
+                    message="Currency converted successfully",
+                    amount=request.amount,
+                    from_currency=request.from_currency,
+                    to_currency=request.to_currency,
+                    converted_amount=converted_amount,
+                    exchange_rate=exchange_rate,
+                    rate_timestamp=timezone.now()
+                )
+                
+            except CurrencyError as e:
+                return CurrencyConversionResult(
+                    success=False,
+                    message=f"Currency conversion failed: {e}",
+                    error_code="conversion_failed",
+                    amount=request.amount,
+                    from_currency=request.from_currency,
+                    to_currency=request.to_currency
+                )
+                
+        except Exception as e:
+            return CurrencyConversionResult(**self._handle_exception(
+                "convert_currency", e,
+                from_currency=request.from_currency if hasattr(request, 'from_currency') else None,
+                to_currency=request.to_currency if hasattr(request, 'to_currency') else None
+            ).model_dump())
+    
+    def get_exchange_rate(self, base_currency: str, quote_currency: str) -> ServiceOperationResult:
+        """
+        Get current exchange rate between currencies.
+        
+        Args:
+            base_currency: Base currency code
+            quote_currency: Quote currency code
+            
+        Returns:
+            ServiceOperationResult: Exchange rate information
+        """
+        try:
+            self.logger.debug("Getting exchange rate", extra={
+                'base_currency': base_currency,
+                'quote_currency': quote_currency
+            })
+            
+            # Validate currencies
+            validation_result = self._validate_currencies(base_currency, quote_currency)
+            if not validation_result.success:
+                return validation_result
+            
+            # Get rate using django_currency
+            try:
+                rate = get_exchange_rate(base_currency, quote_currency)
+                
+                return self._create_success_result(
+                    "Exchange rate retrieved successfully",
+                    {
+                        'base_currency': base_currency,
+                        'quote_currency': quote_currency,
+                        'exchange_rate': rate,
+                        'rate_timestamp': timezone.now().isoformat(),
+                        'pair': f"{base_currency}/{quote_currency}"
+                    }
+                )
+                
+            except CurrencyError as e:
+                return self._create_error_result(
+                    f"Failed to get exchange rate: {e}",
+                    "rate_fetch_failed"
+                )
+                
+        except Exception as e:
+            return self._handle_exception(
+                "get_exchange_rate", e,
+                base_currency=base_currency,
+                quote_currency=quote_currency
+            )
+    
+    def get_supported_currencies(self, provider: Optional[str] = None) -> ServiceOperationResult:
+        """
+        Get list of supported currencies.
+        
+        Args:
+            provider: Filter by provider (optional)
+            
+        Returns:
+            ServiceOperationResult: List of supported currencies
+        """
+        try:
+            self.logger.debug("Getting supported currencies", extra={
+                'provider': provider
+            })
+            
+            # Get currencies from database
+            queryset = Currency.objects.filter(is_enabled=True)
+            
+            if provider:
+                # Filter by provider support
+                queryset = queryset.filter(
+                    providercurrency__provider=provider,
+                    providercurrency__is_enabled=True
+                ).distinct()
+            
+            currencies = queryset.order_by('code')
+            
+            # Convert to data
+            currency_data = []
+            for currency in currencies:
+                data = CurrencyData.model_validate(currency)
+                currency_info = data.model_dump()
+                
+                # Add provider-specific info if requested
+                if provider:
+                    try:
+                        provider_currency = ProviderCurrency.objects.get(
+                            currency=currency,
+                            provider=provider,
+                            is_enabled=True
+                        )
+                        currency_info['provider_info'] = {
+                            'min_amount': float(provider_currency.min_amount) if provider_currency.min_amount else None,
+                            'max_amount': float(provider_currency.max_amount) if provider_currency.max_amount else None,
+                            'network_fee': float(provider_currency.network_fee) if provider_currency.network_fee else None,
+                            'confirmation_blocks': provider_currency.confirmation_blocks
+                        }
+                    except ProviderCurrency.DoesNotExist:
+                        pass
+                
+                currency_data.append(currency_info)
+            
+            return self._create_success_result(
+                f"Retrieved {len(currency_data)} supported currencies",
+                {
+                    'currencies': currency_data,
+                    'count': len(currency_data),
+                    'provider': provider
+                }
+            )
+            
+        except Exception as e:
+            return self._handle_exception(
+                "get_supported_currencies", e,
+                provider=provider
+            )
+    
+    def get_currency_networks(self, currency_code: str) -> ServiceOperationResult:
+        """
+        Get available networks for a currency.
+        
+        Args:
+            currency_code: Currency code
+            
+        Returns:
+            ServiceOperationResult: Available networks
+        """
+        try:
+            self.logger.debug("Getting currency networks", extra={
+                'currency_code': currency_code
+            })
+            
+            # Get currency
+            try:
+                currency = Currency.objects.get(code=currency_code, is_enabled=True)
+            except Currency.DoesNotExist:
+                return self._create_error_result(
+                    f"Currency {currency_code} not found or disabled",
+                    "currency_not_found"
+                )
+            
+            # Get networks
+            networks = Network.objects.filter(
+                currency_code=currency_code,
+                is_enabled=True
+            ).order_by('name')
+            
+            network_data = []
+            for network in networks:
+                network_info = {
+                    'code': network.code,
+                    'name': network.name,
+                    'currency_code': network.currency_code,
+                    'is_testnet': network.is_testnet,
+                    'confirmation_blocks': network.confirmation_blocks,
+                    'block_time_seconds': network.block_time_seconds,
+                    'estimated_confirmation_time': network.estimated_confirmation_time()
+                }
+                network_data.append(network_info)
+            
+            return self._create_success_result(
+                f"Retrieved {len(network_data)} networks for {currency_code}",
+                {
+                    'currency_code': currency_code,
+                    'networks': network_data,
+                    'count': len(network_data)
+                }
+            )
+            
+        except Exception as e:
+            return self._handle_exception(
+                "get_currency_networks", e,
+                currency_code=currency_code
+            )
+    
+    def update_currency_rates(self, currency_codes: Optional[List[str]] = None) -> ServiceOperationResult:
+        """
+        Update currency rates from external sources.
+        
+        Args:
+            currency_codes: Specific currencies to update (optional)
+            
+        Returns:
+            ServiceOperationResult: Update result
+        """
+        try:
+            self.logger.info("Updating currency rates", extra={
+                'currency_codes': currency_codes
+            })
+            
+            # Get currencies to update
+            if currency_codes:
+                currencies = Currency.objects.filter(
+                    code__in=currency_codes,
+                    is_enabled=True
+                )
+            else:
+                currencies = Currency.objects.filter(is_enabled=True)
+            
+            updated_count = 0
+            failed_count = 0
+            errors = []
+            
+            # Update rates for each currency against USD
+            for currency in currencies:
+                try:
+                    if currency.code != 'USD':
+                        # Test rate fetch
+                        rate = get_exchange_rate('USD', currency.code)
+                        updated_count += 1
+                        
+                        self.logger.debug(f"Updated rate for {currency.code}", extra={
+                            'currency_code': currency.code,
+                            'usd_rate': rate
+                        })
+                except CurrencyError as e:
+                    failed_count += 1
+                    error_msg = f"{currency.code}: {str(e)}"
+                    errors.append(error_msg)
+                    
+                    self.logger.warning(f"Failed to update rate for {currency.code}", extra={
+                        'currency_code': currency.code,
+                        'error': str(e)
+                    })
+            
+            self._log_operation(
+                "update_currency_rates",
+                failed_count == 0,
+                updated_count=updated_count,
+                failed_count=failed_count
+            )
+            
+            return self._create_success_result(
+                f"Updated rates for {updated_count} currencies, {failed_count} failed",
+                {
+                    'updated_count': updated_count,
+                    'failed_count': failed_count,
+                    'errors': errors,
+                    'total_currencies': currencies.count()
+                }
+            )
+            
+        except Exception as e:
+            return self._handle_exception(
+                "update_currency_rates", e,
+                currency_codes=currency_codes
+            )
+    
+    def get_currency_stats(self) -> ServiceOperationResult:
+        """
+        Get currency statistics.
+        
+        Returns:
+            ServiceOperationResult: Currency statistics
+        """
+        try:
+            # Currency counts
+            total_currencies = Currency.objects.count()
+            enabled_currencies = Currency.objects.filter(is_enabled=True).count()
+            crypto_currencies = Currency.objects.filter(
+                currency_type=Currency.CurrencyType.CRYPTO,
+                is_enabled=True
+            ).count()
+            fiat_currencies = Currency.objects.filter(
+                currency_type=Currency.CurrencyType.FIAT,
+                is_enabled=True
+            ).count()
+            
+            # Provider support
+            provider_stats = ProviderCurrency.objects.filter(
+                is_enabled=True
+            ).values('provider').annotate(
+                currency_count=models.Count('currency', distinct=True)
+            ).order_by('-currency_count')
+            
+            # Network stats
+            network_stats = Network.objects.filter(
+                is_enabled=True
+            ).values('currency_code').annotate(
+                network_count=models.Count('id')
+            ).order_by('-network_count')
+            
+            stats = {
+                'total_currencies': total_currencies,
+                'enabled_currencies': enabled_currencies,
+                'crypto_currencies': crypto_currencies,
+                'fiat_currencies': fiat_currencies,
+                'provider_support': list(provider_stats),
+                'network_support': list(network_stats),
+                'generated_at': timezone.now().isoformat()
+            }
+            
+            return self._create_success_result(
+                "Currency statistics retrieved",
+                stats
+            )
+            
+        except Exception as e:
+            return self._handle_exception("get_currency_stats", e)
+    
+    def _validate_currencies(self, from_currency: str, to_currency: str) -> ServiceOperationResult:
+        """Validate that currencies are supported."""
+        try:
+            # Check from_currency
+            if not Currency.objects.filter(code=from_currency, is_enabled=True).exists():
+                return self._create_error_result(
+                    f"Currency {from_currency} not supported",
+                    "from_currency_not_supported"
+                )
+            
+            # Check to_currency
+            if not Currency.objects.filter(code=to_currency, is_enabled=True).exists():
+                return self._create_error_result(
+                    f"Currency {to_currency} not supported",
+                    "to_currency_not_supported"
+                )
+            
+            return self._create_success_result("Currencies are valid")
+            
+        except Exception as e:
+            return self._create_error_result(
+                f"Currency validation error: {e}",
+                "validation_error"
+            )
+    
+    def health_check(self) -> ServiceOperationResult:
+        """Perform currency service health check."""
+        try:
+            # Check database connectivity
+            currency_count = Currency.objects.filter(is_enabled=True).count()
+            
+            # Test currency conversion
+            try:
+                test_rate = get_exchange_rate('USD', 'BTC')
+                conversion_healthy = True
+            except CurrencyError:
+                conversion_healthy = False
+            
+            # Check provider currencies
+            provider_currency_count = ProviderCurrency.objects.filter(
+                is_enabled=True
+            ).count()
+            
+            stats = {
+                'service_name': 'CurrencyService',
+                'enabled_currencies': currency_count,
+                'provider_currencies': provider_currency_count,
+                'conversion_service_healthy': conversion_healthy,
+                'django_currency_module': 'available'
+            }
+            
+            if conversion_healthy and currency_count > 0:
+                return self._create_success_result(
+                    "CurrencyService is healthy",
+                    stats
+                )
+            else:
+                return self._create_error_result(
+                    "CurrencyService has issues",
+                    "service_unhealthy",
+                    stats
+                )
+                
+        except Exception as e:
+            return self._handle_exception("health_check", e)