django-cfg 1.3.9__py3-none-any.whl → 1.3.11__py3-none-any.whl

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

@@ -27,9 +27,9 @@ class NowPaymentsProviderConfig(ProviderConfig):
         
         if 'api_url' not in data:
             # TEMP: Force production URL since sandbox is down
-            # sandbox = data.get('sandbox', False)
+            # sandbox_mode = data.get('sandbox_mode', False)
             # data['api_url'] = (
-            #     'https://api-sandbox.nowpayments.io/v1' if sandbox 
+            #     'https://api-sandbox.nowpayments.io/v1' if sandbox_mode 
             #     else 'https://api.nowpayments.io/v1'
             # )
             data['api_url'] = 'https://api.nowpayments.io/v1'  # Force production

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

@@ -99,15 +99,27 @@ class NowPaymentsProvider(BaseProvider):
                 'order_id': request.order_id
             })
             
+            # Use provider_currency_code from metadata if available, otherwise use original currency_code
+            provider_currency_code = request.metadata.get('provider_currency_code', request.currency_code)
+            
             # Prepare NowPayments request
             payment_data = {
                 'price_amount': request.amount_usd,
                 'price_currency': 'USD',
-                'pay_currency': request.currency_code,
+                'pay_currency': provider_currency_code,  # Use provider-specific currency code
                 'order_id': request.order_id,
                 'order_description': request.description or f'Payment {request.order_id}',
             }
             
+            # Log the request data for debugging
+            self.logger.info("NowPayments request data", extra={
+                'payment_data': payment_data,
+                'original_currency_code': request.currency_code,
+                'provider_currency_code': provider_currency_code,
+                'request_amount_usd': request.amount_usd,
+                'request_order_id': request.order_id
+            })
+            
             # Add optional fields
             if request.callback_url:
                 payment_data['success_url'] = request.callback_url
@@ -136,6 +148,14 @@ class NowPaymentsProvider(BaseProvider):
             
             # Parse NowPayments response
             if response_data and 'payment_id' in response_data:
+                # Log the full response for debugging
+                self.logger.info("NowPayments response received", extra={
+                    'payment_id': response_data.get('payment_id'),
+                    'pay_address': response_data.get('pay_address'),
+                    'pay_amount': response_data.get('pay_amount'),
+                    'full_response': response_data
+                })
+                
                 # Successful payment creation
                 payment_url = response_data.get('invoice_url') or response_data.get('pay_url')
                 
@@ -160,14 +180,30 @@ class NowPaymentsProvider(BaseProvider):
                 )
                 
         except Exception as e:
-            self.logger.error(f"NowPayments payment creation failed: {e}", extra={
-                'order_id': request.order_id
+            error_msg = str(e)
+            self.logger.error(f"NowPayments payment creation failed: {error_msg}", extra={
+                'order_id': request.order_id,
+                'error_type': type(e).__name__
             })
             
+            # Provide user-friendly error messages
+            if "IP address blocked" in error_msg:
+                user_message = "NowPayments has blocked this IP address. Please contact support or try from a different location."
+            elif "Authentication failed" in error_msg:
+                user_message = "Invalid NowPayments API key. Please check your configuration."
+            elif "Bad request" in error_msg:
+                user_message = f"Invalid payment request: {error_msg}"
+            elif "Rate limit exceeded" in error_msg:
+                user_message = "Too many requests to NowPayments. Please try again in a few minutes."
+            elif "server error" in error_msg.lower():
+                user_message = "NowPayments service is temporarily unavailable. Please try again later."
+            else:
+                user_message = f"Payment creation failed: {error_msg}"
+            
             return self._create_provider_response(
                 success=False,
-                raw_response={'error': str(e)},
-                error_message=f'Payment creation failed: {e}'
+                raw_response={'error': error_msg, 'error_type': type(e).__name__},
+                error_message=user_message
             )
     
     def get_payment_status(self, provider_payment_id: str) -> ProviderResponse:
@@ -209,14 +245,26 @@ class NowPaymentsProvider(BaseProvider):
                 )
                 
         except Exception as e:
-            self.logger.error(f"NowPayments status check failed: {e}", extra={
-                'payment_id': provider_payment_id
+            error_msg = str(e)
+            self.logger.error(f"NowPayments status check failed: {error_msg}", extra={
+                'payment_id': provider_payment_id,
+                'error_type': type(e).__name__
             })
             
+            # Provide user-friendly error messages
+            if "IP address blocked" in error_msg:
+                user_message = "NowPayments has blocked this IP address. Cannot check payment status."
+            elif "Authentication failed" in error_msg:
+                user_message = "Invalid NowPayments API key. Cannot check payment status."
+            elif "server error" in error_msg.lower():
+                user_message = "NowPayments service is temporarily unavailable. Please try again later."
+            else:
+                user_message = f"Status check failed: {error_msg}"
+            
             return self._create_provider_response(
                 success=False,
-                raw_response={'error': str(e)},
-                error_message=f'Status check failed: {e}'
+                raw_response={'error': error_msg, 'error_type': type(e).__name__},
+                error_message=user_message
             )
     
     def get_supported_currencies(self) -> ServiceOperationResult:

django_cfg/apps/payments/services/providers/registry.py

@@ -24,10 +24,10 @@ class ProviderRegistry:
     
     def __init__(self):
         """Initialize provider registry."""
-        # Use PaymentConfigService for configuration
-        from ...config.constance import get_payment_config_service
+        # Use PaymentsConfigManager for configuration from BaseCfgAutoModule
+        from ...config.django_cfg_integration import PaymentsConfigManager
 
-        self.config_service = get_payment_config_service()
+        self.config_manager = PaymentsConfigManager
         self._providers: Dict[str, BaseProvider] = {}
 
         self._provider_classes: Dict[str, Type[BaseProvider]] = {
@@ -50,9 +50,9 @@ class ProviderRegistry:
         try:
             logger.info("Initializing provider registry")
             
-            # Get all provider configurations
+            # Get all provider configurations from BaseCfgAutoModule
             try:
-                provider_configs = self.config_service.get_all_provider_configs()
+                provider_configs = self.config_manager.get_all_provider_configs()
             except Exception as e:
                 return ServiceOperationResult(
                     success=False,

django_cfg/apps/payments/services/types/requests.py

@@ -24,8 +24,8 @@ class PaymentCreateRequest(BaseModel):
     
     user_id: int = Field(gt=0, description="User ID")
     amount_usd: float = Field(gt=1.0, le=50000.0, description="Amount in USD")
-    currency_code: Literal['BTC', 'ETH', 'LTC', 'XMR', 'USDT', 'USDC', 'ADA', 'DOT'] = Field(
-        description="Cryptocurrency code"
+    currency_code: str = Field(
+        min_length=2, max_length=10, description="Cryptocurrency code"
     )
     provider: Literal['nowpayments'] = Field(default='nowpayments', description="Payment provider")
     callback_url: Optional[str] = Field(None, description="Success callback URL")
@@ -36,11 +36,23 @@ class PaymentCreateRequest(BaseModel):
     @field_validator('currency_code')
     @classmethod
     def validate_currency(cls, v: str) -> str:
-        """Validate currency is supported."""
-        supported = ['BTC', 'ETH', 'LTC', 'XMR', 'USDT', 'USDC', 'ADA', 'DOT']
-        if v.upper() not in supported:
-            raise ValueError(f"Currency {v} not supported. Supported: {', '.join(supported)}")
-        return v.upper()
+        """Validate currency is supported by checking database."""
+        from django_cfg.apps.payments.models import Currency
+        
+        currency_code = v.upper().strip()
+        
+        # Check if currency exists in database and is active
+        try:
+            currency = Currency.objects.get(code=currency_code, is_active=True)
+            return currency_code
+        except Currency.DoesNotExist:
+            # Get list of active currencies for error message
+            active_currencies = Currency.objects.filter(is_active=True).values_list('code', flat=True)[:10]
+            currency_list = ', '.join(active_currencies) + ('...' if len(active_currencies) == 10 else '')
+            raise ValueError(f"Currency {currency_code} not found or inactive. Available: {currency_list}")
+        except Exception:
+            # Fallback validation if database is not available
+            return currency_code
     
     @field_validator('callback_url', 'cancel_url')
     @classmethod

django_cfg/apps/payments/signals/payment_signals.py

@@ -17,16 +17,45 @@ logger = get_logger("payment_signals")
 
 
 @receiver(pre_save, sender=UniversalPayment)
-def store_original_status(sender, instance: UniversalPayment, **kwargs):
-    """Store original status for change detection."""
+def handle_status_changes(sender, instance: UniversalPayment, **kwargs):
+    """
+    Handle status changes and update status_changed_at field.
+    
+    This signal automatically updates status_changed_at when status changes,
+    ensuring consistent tracking across all update methods.
+    """
     if instance.pk:
         try:
             original = UniversalPayment.objects.get(pk=instance.pk)
             instance._original_status = original.status
+            
+            # Check if status has changed
+            if original.status != instance.status:
+                instance.status_changed_at = timezone.now()
+                
+                # Set completed_at if status changed to completed
+                if instance.status == 'completed' and not instance.completed_at:
+                    instance.completed_at = timezone.now()
+                
+                logger.debug(f"Status change detected in pre_save", extra={
+                    'payment_id': str(instance.id),
+                    'old_status': original.status,
+                    'new_status': instance.status,
+                    'status_changed_at': instance.status_changed_at.isoformat()
+                })
         except UniversalPayment.DoesNotExist:
             instance._original_status = None
     else:
+        # New object - set status_changed_at if status is set
         instance._original_status = None
+        if instance.status and not instance.status_changed_at:
+            instance.status_changed_at = timezone.now()
+            
+            logger.debug(f"New payment status set in pre_save", extra={
+                'payment_id': 'new',
+                'status': instance.status,
+                'status_changed_at': instance.status_changed_at.isoformat()
+            })
 
 
 @receiver(post_save, sender=UniversalPayment)

django_cfg/apps/payments/static/payments/js/api-client.js

@@ -149,7 +149,11 @@ class PaymentAPIClient {
         rates: (params = {}) => this.get(`${this.baseURL}/currencies/rates/`, params),
         
         // Convert currency
-        convert: (from, to, amount) => this.post(`${this.baseURL}/currencies/convert/`, { from, to, amount }),
+        convert: (from, to, amount) => this.post(`${this.baseURL}/currencies/convert/`, { 
+            from_currency: from, 
+            to_currency: to, 
+            amount: amount 
+        }),
         
         // Get provider-specific currency configurations
         providerConfigs: (provider) => this.get(`${this.baseURL}/provider-currencies/`, { provider, page_size: 1000 }),
@@ -297,6 +301,7 @@ class PaymentAPIClient {
             delete: (id) => this.delete(`${this.adminURL}/api/payments/${id}/`),
             cancel: (id) => this.post(`${this.adminURL}/api/payments/${id}/cancel/`),
             refund: (id) => this.post(`${this.adminURL}/api/payments/${id}/refund/`),
+            refreshStatus: (id) => this.post(`${this.adminURL}/api/payments/${id}/refresh_status/`),
             stats: () => this.get(`${this.adminURL}/api/payments/stats/`)
         },
         

django_cfg/apps/payments/static/payments/js/payment-detail.js

@@ -0,0 +1,167 @@
+/**
+ * Payment Detail Page JavaScript
+ * Handles payment detail page functionality including AJAX status refresh
+ */
+
+function paymentDetail() {
+    return {
+        loading: false,
+        showQRCode: false,
+        paymentId: null,
+        
+        init(paymentId) {
+            this.paymentId = paymentId;
+            // Show QR code by default if payment address exists
+            const payAddress = document.querySelector('[data-field="pay_address"]');
+            if (payAddress && payAddress.textContent.trim()) {
+                this.showQRCode = true;
+            }
+        },
+        
+        async refreshPaymentStatus() {
+            this.loading = true;
+            try {
+                // Use the existing PaymentAPI client
+                const data = await PaymentAPI.admin.payments.refreshStatus(this.paymentId);
+                
+                if (data.success) {
+                    // Show success notification
+                    PaymentAPI.utils.showNotification(data.message, 'success');
+                    
+                    // Update payment data on page without full reload
+                    this.updatePaymentData(data.payment);
+                } else {
+                    // Show error notification
+                    PaymentAPI.utils.showNotification(data.message || 'Failed to refresh payment status', 'error');
+                }
+            } catch (error) {
+                console.error('Failed to refresh payment status:', error);
+                PaymentAPI.utils.showNotification('Network error while refreshing status', 'error');
+            } finally {
+                this.loading = false;
+            }
+        },
+        
+        updatePaymentData(paymentData) {
+            // Update status badge
+            const statusBadge = document.querySelector('.payment-status-badge');
+            if (statusBadge && paymentData.status) {
+                statusBadge.textContent = paymentData.status.toUpperCase();
+                statusBadge.className = `payment-status-badge inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ${this.getStatusBadgeClass(paymentData.status)}`;
+            }
+            
+            // Update other fields that might have changed
+            const fields = {
+                'pay_amount': paymentData.pay_amount,
+                'transaction_hash': paymentData.transaction_hash,
+                'pay_address': paymentData.pay_address,
+                'payment_url': paymentData.payment_url,
+                'expires_at': paymentData.expires_at,
+                'confirmed_at': paymentData.confirmed_at,
+                'updated_at': paymentData.updated_at,
+                'status_changed_at': paymentData.status_changed_at
+            };
+            
+            Object.entries(fields).forEach(([field, value]) => {
+                const element = document.querySelector(`[data-field="${field}"]`);
+                if (element && value !== null && value !== undefined) {
+                    if (field.includes('_at') && value) {
+                        // Format datetime fields
+                        element.textContent = new Date(value).toLocaleString();
+                    } else if (field === 'pay_amount' && paymentData.currency) {
+                        // Format pay_amount with currency
+                        element.textContent = `${parseFloat(value).toFixed(8)} ${paymentData.currency.code}`;
+                    } else {
+                        element.textContent = value;
+                    }
+                }
+            });
+            
+            // Update error info if present
+            if (paymentData.error_info) {
+                const errorElement = document.querySelector('[data-field="error_info"]');
+                if (errorElement) {
+                    errorElement.textContent = JSON.stringify(paymentData.error_info, null, 2);
+                }
+            }
+            
+            // Update QR code visibility if pay_address changed
+            if (paymentData.pay_address && !this.showQRCode) {
+                this.showQRCode = true;
+            }
+        },
+        
+        getStatusBadgeClass(status) {
+            const statusClasses = {
+                'pending': 'bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-300',
+                'confirming': 'bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-300',
+                'completed': 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-300',
+                'confirmed': 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-300',
+                'failed': 'bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-300',
+                'cancelled': 'bg-gray-100 text-gray-800 dark:bg-gray-900 dark:text-gray-300',
+                'expired': 'bg-orange-100 text-orange-800 dark:bg-orange-900 dark:text-orange-300',
+                'refunded': 'bg-purple-100 text-purple-800 dark:bg-purple-900 dark:text-purple-300'
+            };
+            return statusClasses[status] || 'bg-gray-100 text-gray-800 dark:bg-gray-900 dark:text-gray-300';
+        },
+        
+        async cancelPayment() {
+            if (!confirm('Are you sure you want to cancel this payment?')) {
+                return;
+            }
+            
+            this.loading = true;
+            try {
+                const data = await PaymentAPI.admin.payments.cancel(this.paymentId);
+                PaymentAPI.utils.showNotification('Payment cancelled successfully', 'success');
+                
+                // Update payment data
+                this.updatePaymentData(data);
+            } catch (error) {
+                console.error('Failed to cancel payment:', error);
+                PaymentAPI.utils.showNotification('Failed to cancel payment', 'error');
+            } finally {
+                this.loading = false;
+            }
+        },
+        
+        exportDetails() {
+            // Get payment data from the page
+            const paymentData = {
+                id: this.paymentId,
+                status: document.querySelector('.payment-status-badge')?.textContent || 'Unknown',
+                amount_usd: document.querySelector('[data-field="amount_usd"]')?.textContent || '',
+                pay_amount: document.querySelector('[data-field="pay_amount"]')?.textContent || '',
+                currency: document.querySelector('[data-field="currency"]')?.textContent || '',
+                provider: document.querySelector('[data-field="provider"]')?.textContent || '',
+                pay_address: document.querySelector('[data-field="pay_address"]')?.textContent || '',
+                transaction_hash: document.querySelector('[data-field="transaction_hash"]')?.textContent || '',
+                created_at: document.querySelector('[data-field="created_at"]')?.textContent || '',
+                updated_at: document.querySelector('[data-field="updated_at"]')?.textContent || ''
+            };
+            
+            // Create CSV content
+            const csvContent = Object.entries(paymentData)
+                .map(([key, value]) => `${key},${value}`)
+                .join('\n');
+            
+            // Download CSV
+            const blob = new Blob([csvContent], { type: 'text/csv' });
+            const url = window.URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = `payment_${this.paymentId}_details.csv`;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            window.URL.revokeObjectURL(url);
+        }
+    };
+}
+
+// Auto-initialize if PaymentAPI is available
+document.addEventListener('DOMContentLoaded', function() {
+    if (typeof PaymentAPI === 'undefined') {
+        console.warn('PaymentAPI not found. Make sure api-client.js is loaded before payment-detail.js');
+    }
+});

django_cfg/apps/payments/static/payments/js/payment-form.js

@@ -22,6 +22,7 @@ function paymentForm() {
         ],
         conversionResult: null,
         users: [],
+        errorMessage: '',
 
         async init() {
             console.log('🚀 PaymentForm: Initializing...');
@@ -85,29 +86,20 @@ function paymentForm() {
                     return;
                 }
                 
-                const data = await PaymentAPI.currencies.byProvider(this.form.provider);
-                console.log('📊 Provider currencies API response:', data);
-                this.currencies = data.results || data.currencies || [];
+                // Use the provider-currencies API endpoint directly
+                const response = await PaymentAPI.request(`/api/payments/provider-currencies/by_provider/?provider=${this.form.provider}`);
+                console.log('📊 Provider currencies API response:', response);
                 
-                // Transform provider currency data for display
-                this.currencies = this.currencies.map(pc => ({
-                    code: pc.currency?.code || pc.provider_currency_code,
-                    name: pc.currency?.name || pc.provider_currency_code,
-                    type: pc.currency?.currency_type || 'unknown',
-                    symbol: pc.currency?.symbol || '',
-                    network: pc.network?.code || null,
-                    network_name: pc.network?.name || null,
-                    min_amount: pc.min_amount,
-                    max_amount: pc.max_amount,
-                    fee_percentage: pc.fee_percentage,
-                    fixed_fee: pc.fixed_fee,
-                    provider_code: pc.provider_currency_code
-                }));
+                // Extract currencies for the specific provider
+                const providerData = response.currencies_by_provider?.[this.form.provider];
+                this.currencies = providerData?.currencies || [];
+                
+                console.log('🔍 Sample currency structure:', this.currencies[0]);
                 
                 console.log('✅ Loaded provider currencies:', this.currencies.length);
                 
                 // If current currency is not supported by provider, reset it
-                if (this.form.currency_code && !this.currencies.find(c => c.code === this.form.currency_code)) {
+                if (this.form.currency_code && !this.currencies.find(c => c.provider_currency_code === this.form.currency_code)) {
                     console.log('⚠️ Current currency not supported by provider, resetting');
                     this.form.currency_code = '';
                     this.conversionResult = null;
@@ -179,11 +171,15 @@ function paymentForm() {
             if (!this.form.amount_usd || !this.form.currency_code) return;
             
             try {
-                const result = await PaymentAPI.currencies.convert('USD', this.form.currency_code, this.form.amount_usd);
+                // Get the original currency code for conversion (not provider code)
+                const currencyInfo = this.getCurrencyInfo(this.form.currency_code);
+                const originalCurrencyCode = currencyInfo.currency?.code || this.form.currency_code;
+                
+                const result = await PaymentAPI.currencies.convert('USD', originalCurrencyCode, this.form.amount_usd);
                 this.conversionResult = {
                     amount: result.converted_amount,
                     rate: result.rate,
-                    currency: this.form.currency_code
+                    currency: originalCurrencyCode
                 };
             } catch (error) {
                 console.error('Currency conversion failed:', error);
@@ -191,10 +187,10 @@ function paymentForm() {
             }
         },
 
-        getCurrencyInfo(code) {
-            return this.currencies.find(c => c.code === code) || 
-                   this.allCurrencies.find(c => c.code === code) || 
-                   { code, name: code, type: 'unknown' };
+        getCurrencyInfo(providerCurrencyCode) {
+            return this.currencies.find(c => c.provider_currency_code === providerCurrencyCode) || 
+                   this.allCurrencies.find(c => c.code === providerCurrencyCode) || 
+                   { provider_currency_code: providerCurrencyCode, currency: { code: providerCurrencyCode, name: providerCurrencyCode, currency_type: 'unknown' } };
         },
 
         validateForm() {
@@ -208,10 +204,18 @@ function paymentForm() {
             return errors;
         },
 
+        clearError() {
+            this.errorMessage = '';
+        },
+
         async submitForm() {
+            // Clear previous error
+            this.clearError();
+            
             const errors = this.validateForm();
             if (errors.length > 0) {
-                PaymentAPI.utils.showNotification(errors.join(', '), 'error');
+                this.errorMessage = errors.join(', ');
+                PaymentAPI.utils.showNotification('Please fix form errors', 'error');
                 return;
             }
 
@@ -223,7 +227,12 @@ function paymentForm() {
                 window.location.href = `/cfg/admin/django_cfg_payments/admin/payments/${data.id}/`;
             } catch (error) {
                 console.error('Error:', error);
-                PaymentAPI.utils.showNotification(error.message || 'Failed to create payment', 'error');
+                
+                // Show detailed error in form
+                this.errorMessage = error.message || 'Failed to create payment';
+                
+                // Show brief notification
+                PaymentAPI.utils.showNotification('Payment creation failed', 'error');
             } finally {
                 this.loading = false;
             }

django_cfg/apps/payments/templatetags/payment_tags.py

@@ -464,3 +464,11 @@ def divide(value, arg):
         return float(value) / float(arg)
     except (ValueError, TypeError, ZeroDivisionError):
         return 0
+
+
+
+
+
+
+
+

django_cfg/apps/payments/urls.py

@@ -11,7 +11,7 @@ from rest_framework_nested import routers
 from .views.api import (
     PaymentViewSet, UserPaymentViewSet, PaymentCreateView, PaymentStatusView,
     UserBalanceViewSet, TransactionViewSet, UserTransactionViewSet,
-    CurrencyViewSet, NetworkViewSet, ProviderCurrencyViewSet, CurrencyConversionView, CurrencyRatesView, SupportedCurrenciesView,
+    CurrencyViewSet, NetworkViewSet, ProviderCurrencyViewSet, CurrencyRatesView, SupportedCurrenciesView,
     SubscriptionViewSet, UserSubscriptionViewSet, EndpointGroupViewSet, TariffViewSet,
     APIKeyViewSet, UserAPIKeyViewSet, APIKeyCreateView, APIKeyValidateView,
     UniversalWebhookView, webhook_health_check, webhook_stats, supported_providers,
@@ -60,7 +60,8 @@ urlpatterns = [
     path('payments/create/', PaymentCreateView.as_view(), name='payment-create'),
     path('payments/status/<uuid:pk>/', PaymentStatusView.as_view(), name='payment-status'),
     
-    path('currencies/convert/', CurrencyConversionView.as_view(), name='currency-convert'),
+    # Note: currencies/convert/ is handled by CurrencyViewSet action
+    # path('currencies/convert/', CurrencyConversionView.as_view(), name='currency-convert'),
     path('currencies/rates/', CurrencyRatesView.as_view(), name='currency-rates'),
     path('currencies/supported/', SupportedCurrenciesView.as_view(), name='currencies-supported'),
     

django_cfg/apps/payments/views/api/currencies.py

@@ -34,6 +34,9 @@ class CurrencyViewSet(ReadOnlyPaymentViewSet):
     Read-only access to currency information with conversion capabilities.
     """
     
+    # Allow POST for conversion action
+    http_method_names = ['get', 'head', 'options', 'post']
+    
     queryset = Currency.objects.filter(is_active=True)
     serializer_class = CurrencySerializer
     permission_classes = [permissions.IsAuthenticated]

django_cfg/apps/payments/views/serializers/currencies.py

@@ -165,14 +165,18 @@ class CurrencyConversionSerializer(serializers.Serializer):
     def save(self) -> Dict[str, Any]:
         """Perform currency conversion using CurrencyService."""
         try:
-            currency_service = get_currency_service()
-            result = currency_service.convert_currency(
+            from django_cfg.apps.payments.services.types.requests import CurrencyConversionRequest
+            
+            # Create request object
+            request = CurrencyConversionRequest(
                 from_currency=self.validated_data['from_currency'],
                 to_currency=self.validated_data['to_currency'],
-                amount=self.validated_data['amount'],
-                provider=self.validated_data.get('provider', 'nowpayments')
+                amount=self.validated_data['amount']
             )
             
+            currency_service = get_currency_service()
+            result = currency_service.convert_currency(request)
+            
             if result.success:
                 return {
                     'success': True,
@@ -311,9 +315,18 @@ class SupportedCurrenciesSerializer(serializers.Serializer):
             )
             
             if result.success:
+                # Extract currencies from result.data structure
+                currencies_data = result.data.get('currencies', []) if isinstance(result.data, dict) else []
+                count = result.data.get('count', 0) if isinstance(result.data, dict) else len(currencies_data)
+                provider = result.data.get('provider', 'nowpayments') if isinstance(result.data, dict) else 'nowpayments'
+                
                 return {
                     'success': True,
-                    'currencies': result.data,
+                    'currencies': {
+                        'currencies': currencies_data,
+                        'count': count,
+                        'provider': provider
+                    },
                     'message': result.message
                 }
             else:

django_cfg/apps/tasks/admin/tasks_admin.py

@@ -58,8 +58,8 @@ if DRAMATIQ_AVAILABLE:
     class TaskQueueAdminMixin(OptimizedModelAdmin, DisplayMixin, StandaloneActionsMixin):
         """Mixin for task queue management functionality."""
         
-        change_list_template = 'admin/tasks/taskqueue/change_list.html'
-        actions_list = ['start_workers', 'clear_queues', 'refresh_status']
+        # change_list_template = 'admin/tasks/taskqueue/change_list.html'
+        # actions_list = ['start_workers', 'clear_queues', 'refresh_status']
         
         def has_add_permission(self, request):
             return False