from decimal import Decimal from django.shortcuts import render, redirect from django.contrib import messages from django.http import JsonResponse from django.views.decorators.csrf import csrf_exempt import json from rest_framework.decorators import action from rest_framework import viewsets from .base import DummySerializer class PaymentViewSet(viewsets.ModelViewSet): """Handles connecting and displaying cloud storage accounts (Google Drive, Dropbox, OneDrive)""" serializer_class = DummySerializer @action(detail=False, methods=['get', 'post'], url_path=r'') def payment_view(self, request): """Step 4: Payment Processing with Paystack""" base_domain = request.build_absolute_uri('/') user = request.user if not user.is_authenticated: return redirect(f'{base_domain}login/') current_order_id = request.session.get('current_order_id') if not current_order_id: messages.error(request, "Please complete storage selection first") return redirect(f'{base_domain}transfer/storage/') try: from ..models import TransferOrder order = TransferOrder.objects.get(id=current_order_id, user=user) print(order.total_size) if order.status != 'storage_selected': messages.error(request, "Please complete storage selection first") return redirect(f'{base_domain}transfer/storage/') context = { 'base_domain': base_domain, 'user': user, 'order': order, 'current_step': 4, 'selected_files_count': order.total_files, 'total_size_gb': float(order.total_size) } if request.method == 'POST': return self._handle_payment(request, order, context) # GET request - show payment page context.update(self._get_payment_context(order)) return render(request, 'payment.html', context) except TransferOrder.DoesNotExist: messages.error(request, "Order not found") return redirect(f'{base_domain}transfer/new/') def _get_payment_context(self, order): """Prepare payment context with calculated amounts""" # Calculate pricing based on storage type and size base_price = self._calculate_base_price(order.storage_type, order.storage_size) shipping_cost = Decimal('4.99') # Fixed shipping cost tax_rate = Decimal('0.08') # 8% tax subtotal = base_price tax_amount = subtotal * tax_rate total_amount = subtotal + shipping_cost + tax_amount return { 'order_summary': { 'storage_type': order.storage_type, 'storage_size': order.storage_size, 'files_count': order.total_files, 'total_size': f"{order.total_size:.1f} GB", 'subtotal': f"{subtotal:.2f}", 'shipping': f"{shipping_cost:.2f}", 'tax': f"{tax_amount:.2f}", 'total': f"{total_amount:.2f}", }, 'payment_methods': [ {'id': 'card', 'name': 'Credit/Debit Card', 'icon': 'credit-card', 'description': 'Pay securely with your card'}, {'id': 'bank', 'name': 'Bank Transfer', 'icon': 'university', 'description': 'Transfer directly from your bank'}, {'id': 'mobile', 'name': 'Mobile Money', 'icon': 'mobile-alt', 'description': 'Pay with mobile money'}, ], 'paystack_public_key': 'pk_test_dummy_key_1234567890', # Dummy key for development 'order_reference': f"ORD-{order.id}-{order.created_at.strftime('%Y%m%d')}", } #THIS BASICALLY RETURNS THE PRICES OF THE PRODUCT BASED ON THE STORAGE TYPE AND SIZE def _calculate_base_price(self, storage_type, storage_size): """Calculate base price based on storage selection""" print("=== CALCULATING BASE PRICE ===") print(f"DEBUG: storage_type = {storage_type}") print(f"DEBUG: storage_size = {storage_size}") # Parse storage size - handle both GB and TB storage_size_clean = storage_size.upper().strip() print(f"DEBUG: Clean storage size: {storage_size_clean}") try: if 'TB' in storage_size_clean: # Convert TB to GB (1TB = 1000GB) tb_value = float(storage_size_clean.replace('TB', '').strip()) size_gb = int(tb_value * 1000) print(f"DEBUG: Converted {tb_value}TB to {size_gb}GB") elif 'GB' in storage_size_clean: # Already in GB size_gb = int(storage_size_clean.replace('GB', '').strip()) print(f"DEBUG: Parsed {size_gb}GB directly") else: # Assume it's in GB if no unit specified size_gb = int(storage_size_clean) print(f"DEBUG: No unit specified, assuming GB: {size_gb}GB") print(f"DEBUG: Final size in GB: {size_gb}") # Base prices per GB for different storage types price_per_gb = { 'flash_drive': Decimal('2.50'), 'memory_card': Decimal('3.00'), 'external_hdd': Decimal('1.75') } base_price_per_gb = price_per_gb.get(storage_type, Decimal('2.00')) print(f"DEBUG: Price per GB for {storage_type}: ${base_price_per_gb}") base_price = base_price_per_gb * size_gb print(f"DEBUG: Raw base price: ${base_price}") # Minimum charge final_price = max(base_price, Decimal('9.99')) print(f"DEBUG: Final base price (after min charge): ${final_price}") print("=== BASE PRICE CALCULATION COMPLETE ===") return final_price except (ValueError, AttributeError) as e: print(f"ERROR CALCULATING PRICE: {type(e).__name__}: {str(e)}") print(f"DEBUG: Problem parsing storage_size: {storage_size}") # Return a default price if parsing fails default_price = Decimal('9.99') print(f"DEBUG: Returning default price: ${default_price}") return default_price def _handle_payment(self, request, order, context): """Handle payment form submission""" payment_method = request.POST.get('payment_method') email = request.POST.get('email') amount = request.POST.get('amount') if not all([payment_method, email, amount]): messages.error(request, "Please fill all required fields") context.update(self._get_payment_context(order)) return render(request, 'payment.html', context) try: # Initialize Paystack payment (dummy implementation) payment_data = self._initialize_paystack_payment( email=email, amount=amount, order=order ) if payment_data.get('status'): # Store payment reference in session request.session['payment_reference'] = payment_data['data']['reference'] request.session['order_id'] = order.id # Redirect to Paystack payment page (dummy for now) messages.success(request, "Payment initialized successfully") return redirect(payment_data['data']['authorization_url']) else: messages.error(request, f"Payment initialization failed: {payment_data.get('message', 'Unknown error')}") context.update(self._get_payment_context(order)) return render(request, 'payment.html', context) except Exception as e: messages.error(request, f"Payment error: {str(e)}") context.update(self._get_payment_context(order)) return render(request, 'payment.html', context) def _initialize_paystack_payment(self, email, amount, order): """ Initialize Paystack payment (dummy implementation) In production, this would make actual API call to Paystack """ # Dummy Paystack response structure return { "status": True, "message": "Authorization URL created", "data": { "authorization_url": "https://checkout.paystack.com/dummy_checkout_page", "access_code": "dummy_access_code_123", "reference": f"paystack_ref_{order.id}_{order.created_at.strftime('%Y%m%d%H%M%S')}" } } @csrf_exempt def paystack_webhook(self, request): """Handle Paystack webhook for payment verification""" if request.method == 'POST': try: # Dummy webhook processing payload = json.loads(request.body) reference = payload.get('data', {}).get('reference') if payload.get('event') == 'charge.success': # Verify payment with Paystack (dummy) verification_result = self._verify_paystack_payment(reference) if verification_result.get('status'): # Update order status from ..models import TransferOrder order_id = request.session.get('order_id') if order_id: order = TransferOrder.objects.get(id=order_id) order.status = 'payment_completed' order.payment_reference = reference order.save() # Clear session request.session.pop('current_order_id', None) request.session.pop('payment_reference', None) request.session.pop('order_id', None) return JsonResponse({'status': 'success'}) return JsonResponse({'status': 'ignored'}) except Exception as e: return JsonResponse({'status': 'error', 'message': str(e)}, status=400) return JsonResponse({'status': 'invalid_method'}, status=405) def _verify_paystack_payment(self, reference): """Verify Paystack payment (dummy implementation)""" # Dummy verification response return { "status": True, "message": "Verification successful", "data": { "reference": reference, "status": "success", "amount": 100000, # Amount in kobo "currency": "NGN", "gateway_response": "Successful" } }