project initialization

backend/src/core/api/payment_views.py

@@ -0,0 +1,617 @@
+"""
+Payment Management API Views
+Handles payment processing, transactions, and financial management endpoints
+"""
+from rest_framework import viewsets, status, permissions
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+from django.utils import timezone
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+from drf_spectacular.types import OpenApiTypes
+
+from core.models.payment import (
+    PaymentTransaction, PaymentStatus, PaymentMethod, PaymentProvider,
+    RefundTransaction, DisputeTransaction, PaymentWebhook
+)
+from core.models.subscription import Subscription
+from core.services.payment_service import PaymentService
+from core.services.subscription_service import SubscriptionService
+from core.auth.permissions import TenantPermission, IsTenantAdmin
+from core.serializers.payment import (
+    PaymentTransactionSerializer,
+    PaymentCreateSerializer,
+    PaymentUpdateSerializer,
+    RefundTransactionSerializer,
+    DisputeTransactionSerializer,
+    PaymentMethodSerializer,
+    PaymentStatsSerializer,
+    PaymentWebhookSerializer
+)
+
+
+class PaymentTransactionViewSet(viewsets.ModelViewSet):
+    """
+    Payment Transaction ViewSet
+    Provides CRUD operations for payment transactions with comprehensive financial logic
+    """
+
+    permission_classes = [IsAuthenticated, TenantPermission]
+    serializer_class = PaymentTransactionSerializer
+    lookup_field = 'id'
+
+    def get_queryset(self):
+        """
+        Filter payment transactions based on tenant and permissions
+        """
+        user = self.request.user
+        tenant = user.tenant
+
+        if not tenant:
+            return PaymentTransaction.objects.none()
+
+        # Superusers see all transactions
+        if user.is_superuser:
+            return PaymentTransaction.objects.all()
+
+        # Tenant admins/managers see their tenant's transactions
+        if user.role in ['admin', 'manager']:
+            return PaymentTransaction.objects.filter(tenant=tenant)
+
+        # Regular users see only their own transactions
+        return PaymentTransaction.objects.filter(tenant=tenant, user=user)
+
+    def get_serializer_class(self):
+        """
+        Return appropriate serializer based on action
+        """
+        if self.action == 'create':
+            return PaymentCreateSerializer
+        elif self.action in ['update', 'partial_update']:
+            return PaymentUpdateSerializer
+        elif self.action == 'refund':
+            return RefundTransactionSerializer
+        elif self.action == 'dispute':
+            return DisputeTransactionSerializer
+        elif self.action == 'stats':
+            return PaymentStatsSerializer
+        elif self.action == 'methods':
+            return PaymentMethodSerializer
+        elif self.action == 'webhook':
+            return PaymentWebhookSerializer
+        return PaymentTransactionSerializer
+
+    def perform_create(self, serializer):
+        """
+        Create payment transaction with proper initialization
+        """
+        payment_service = PaymentService()
+        transaction = payment_service.create_payment(serializer.validated_data)
+        serializer.instance = transaction
+
+    def perform_update(self, serializer):
+        """
+        Update payment transaction with validation
+        """
+        payment_service = PaymentService()
+        transaction = payment_service.update_payment(
+            self.get_object(),
+            serializer.validated_data
+        )
+        serializer.instance = transaction
+
+    @extend_schema(
+        summary="Process Payment",
+        description="Process payment with various payment methods",
+        request=OpenApiTypes.OBJECT,
+        responses={200: PaymentTransactionSerializer}
+    )
+    @action(detail=True, methods=['post'])
+    def process(self, request, *args, **kwargs):
+        """
+        Process payment transaction
+        """
+        transaction = self.get_object()
+        payment_service = PaymentService()
+
+        try:
+            result = payment_service.process_payment(transaction, request.data)
+            serializer = PaymentTransactionSerializer(result)
+            return Response(serializer.data)
+        except Exception as e:
+            return Response(
+                {'detail': f'Payment processing failed: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    @extend_schema(
+        summary="Refund Payment",
+        description="Refund payment transaction",
+        request=RefundTransactionSerializer,
+        responses={200: RefundTransactionSerializer}
+    )
+    @action(detail=True, methods=['post'])
+    def refund(self, request, *args, **kwargs):
+        """
+        Refund payment transaction
+        """
+        transaction = self.get_object()
+        payment_service = PaymentService()
+
+        try:
+            refund = payment_service.refund_payment(transaction, request.data)
+            serializer = RefundTransactionSerializer(refund)
+            return Response(serializer.data)
+        except Exception as e:
+            return Response(
+                {'detail': f'Refund failed: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    @extend_schema(
+        summary="Dispute Payment",
+        description="Dispute payment transaction",
+        request=DisputeTransactionSerializer,
+        responses={200: DisputeTransactionSerializer}
+    )
+    @action(detail=True, methods=['post'])
+    def dispute(self, request, *args, **kwargs):
+        """
+        Dispute payment transaction
+        """
+        transaction = self.get_object()
+        payment_service = PaymentService()
+
+        try:
+            dispute = payment_service.dispute_payment(transaction, request.data)
+            serializer = DisputeTransactionSerializer(dispute)
+            return Response(serializer.data)
+        except Exception as e:
+            return Response(
+                {'detail': f'Dispute failed: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    @extend_schema(
+        summary="Get Payment Receipt",
+        description="Generate payment receipt",
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=True, methods=['get'])
+    def receipt(self, request, *args, **kwargs):
+        """
+        Get payment receipt
+        """
+        transaction = self.get_object()
+        payment_service = PaymentService()
+
+        try:
+            receipt = payment_service.generate_receipt(transaction)
+            return Response(receipt)
+        except Exception as e:
+            return Response(
+                {'detail': f'Receipt generation failed: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    @extend_schema(
+        summary="Get Payment Stats",
+        description="Retrieve payment statistics",
+        responses={200: PaymentStatsSerializer}
+    )
+    @action(detail=False, methods=['get'])
+    def stats(self, request):
+        """
+        Get payment statistics
+        """
+        tenant = request.user.tenant
+        if not tenant:
+            return Response(
+                {'detail': 'Tenant not found'},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        payment_service = PaymentService()
+        stats = payment_service.get_payment_stats(tenant)
+        serializer = PaymentStatsSerializer(stats)
+        return Response(serializer.data)
+
+    @extend_schema(
+        summary="Get Payment Methods",
+        description="Retrieve available payment methods",
+        responses={200: PaymentMethodSerializer(many=True)}
+    )
+    @action(detail=False, methods=['get'])
+    def methods(self, request):
+        """
+        Get available payment methods
+        """
+        payment_service = PaymentService()
+        methods = payment_service.get_available_payment_methods()
+        serializer = PaymentMethodSerializer(methods, many=True)
+        return Response(serializer.data)
+
+    @extend_schema(
+        summary="Validate Payment Method",
+        description="Validate payment method details",
+        request=OpenApiTypes.OBJECT,
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=False, methods=['post'])
+    def validate_method(self, request):
+        """
+        Validate payment method
+        """
+        payment_service = PaymentService()
+
+        try:
+            validation_result = payment_service.validate_payment_method(request.data)
+            return Response(validation_result)
+        except Exception as e:
+            return Response(
+                {'detail': f'Validation failed: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    @extend_schema(
+        summary="Handle Payment Webhook",
+        description="Process payment provider webhook",
+        request=PaymentWebhookSerializer,
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=False, methods=['post'])
+    def webhook(self, request):
+        """
+        Handle payment webhook
+        """
+        payment_service = PaymentService()
+
+        try:
+            result = payment_service.handle_webhook(request.data)
+            return Response(result)
+        except Exception as e:
+            return Response(
+                {'detail': f'Webhook processing failed: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    @extend_schema(
+        summary="Get Transaction History",
+        description="Retrieve transaction history with filters",
+        parameters=[
+            OpenApiParameter(
+                name='start_date',
+                description='Start date filter',
+                type=OpenApiTypes.DATE
+            ),
+            OpenApiParameter(
+                name='end_date',
+                description='End date filter',
+                type=OpenApiTypes.DATE
+            ),
+            OpenApiParameter(
+                name='status',
+                description='Status filter',
+                type=OpenApiTypes.STR
+            ),
+            OpenApiParameter(
+                name='provider',
+                description='Provider filter',
+                type=OpenApiTypes.STR
+            )
+        ],
+        responses={200: PaymentTransactionSerializer(many=True)}
+    )
+    @action(detail=False, methods=['get'])
+    def history(self, request):
+        """
+        Get transaction history
+        """
+        tenant = request.user.tenant
+        if not tenant:
+            return Response(
+                {'detail': 'Tenant not found'},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        # Parse filters
+        start_date = request.query_params.get('start_date')
+        end_date = request.query_params.get('end_date')
+        status_filter = request.query_params.get('status')
+        provider_filter = request.query_params.get('provider')
+
+        payment_service = PaymentService()
+        transactions = payment_service.get_transaction_history(
+            tenant=tenant,
+            start_date=start_date,
+            end_date=end_date,
+            status=status_filter,
+            provider=provider_filter
+        )
+        serializer = PaymentTransactionSerializer(transactions, many=True)
+        return Response(serializer.data)
+
+    @extend_schema(
+        summary="Get Payment Analytics",
+        description="Retrieve payment analytics and insights",
+        parameters=[
+            OpenApiParameter(
+                name='period',
+                description='Analysis period (day, week, month, year)',
+                type=OpenApiTypes.STR,
+                default='month'
+            )
+        ],
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=False, methods=['get'])
+    def analytics(self, request):
+        """
+        Get payment analytics
+        """
+        tenant = request.user.tenant
+        if not tenant:
+            return Response(
+                {'detail': 'Tenant not found'},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        period = request.query_params.get('period', 'month')
+        payment_service = PaymentService()
+
+        try:
+            analytics = payment_service.get_payment_analytics(tenant, period)
+            return Response(analytics)
+        except Exception as e:
+            return Response(
+                {'detail': f'Analytics retrieval failed: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def get_permissions(self):
+        """
+        Override permissions based on action
+        """
+        if self.action in ['refund', 'dispute', 'stats', 'analytics', 'webhook']:
+            permission_classes = [IsAuthenticated, IsTenantAdmin]
+        elif self.action in ['create', 'update', 'partial_update', 'destroy']:
+            permission_classes = [IsAuthenticated, IsTenantAdmin]
+        else:
+            permission_classes = [IsAuthenticated, TenantPermission]
+
+        return [permission() for permission in permission_classes]
+
+
+class RefundTransactionViewSet(viewsets.ModelViewSet):
+    """
+    Refund Transaction ViewSet
+    Manages refund transactions
+    """
+
+    permission_classes = [IsAuthenticated, IsTenantAdmin]
+    serializer_class = RefundTransactionSerializer
+    lookup_field = 'id'
+
+    def get_queryset(self):
+        """
+        Filter refund transactions based on tenant
+        """
+        user = self.request.user
+        tenant = user.tenant
+
+        if not tenant:
+            return RefundTransaction.objects.none()
+
+        # Superusers see all refunds
+        if user.is_superuser:
+            return RefundTransaction.objects.all()
+
+        return RefundTransaction.objects.filter(payment_transaction__tenant=tenant)
+
+    @extend_schema(
+        summary="Process Refund",
+        description="Process refund transaction",
+        responses={200: RefundTransactionSerializer}
+    )
+    @action(detail=True, methods=['post'])
+    def process(self, request, *args, **kwargs):
+        """
+        Process refund transaction
+        """
+        refund = self.get_object()
+        payment_service = PaymentService()
+
+        try:
+            result = payment_service.process_refund(refund)
+            serializer = RefundTransactionSerializer(result)
+            return Response(serializer.data)
+        except Exception as e:
+            return Response(
+                {'detail': f'Refund processing failed: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    @extend_schema(
+        summary="Cancel Refund",
+        description="Cancel refund transaction",
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=True, methods=['post'])
+    def cancel(self, request, *args, **kwargs):
+        """
+        Cancel refund transaction
+        """
+        refund = self.get_object()
+        payment_service = PaymentService()
+
+        try:
+            payment_service.cancel_refund(refund)
+            return Response({'detail': 'Refund cancelled successfully'})
+        except Exception as e:
+            return Response(
+                {'detail': f'Refund cancellation failed: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+
+class DisputeTransactionViewSet(viewsets.ModelViewSet):
+    """
+    Dispute Transaction ViewSet
+    Manages dispute transactions
+    """
+
+    permission_classes = [IsAuthenticated, IsTenantAdmin]
+    serializer_class = DisputeTransactionSerializer
+    lookup_field = 'id'
+
+    def get_queryset(self):
+        """
+        Filter dispute transactions based on tenant
+        """
+        user = self.request.user
+        tenant = user.tenant
+
+        if not tenant:
+            return DisputeTransaction.objects.none()
+
+        # Superusers see all disputes
+        if user.is_superuser:
+            return DisputeTransaction.objects.all()
+
+        return DisputeTransaction.objects.filter(payment_transaction__tenant=tenant)
+
+    @extend_schema(
+        summary="Submit Evidence",
+        description="Submit evidence for dispute",
+        request=OpenApiTypes.OBJECT,
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=True, methods=['post'])
+    def submit_evidence(self, request, *args, **kwargs):
+        """
+        Submit dispute evidence
+        """
+        dispute = self.get_object()
+        payment_service = PaymentService()
+
+        try:
+            payment_service.submit_dispute_evidence(dispute, request.data)
+            return Response({'detail': 'Evidence submitted successfully'})
+        except Exception as e:
+            return Response(
+                {'detail': f'Evidence submission failed: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    @extend_schema(
+        summary="Escalate Dispute",
+        description="Escalate dispute to payment provider",
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=True, methods=['post'])
+    def escalate(self, request, *args, **kwargs):
+        """
+        Escalate dispute
+        """
+        dispute = self.get_object()
+        payment_service = PaymentService()
+
+        try:
+            payment_service.escalate_dispute(dispute)
+            return Response({'detail': 'Dispute escalated successfully'})
+        except Exception as e:
+            return Response(
+                {'detail': f'Dispute escalation failed: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+
+class PaymentMethodViewSet(viewsets.ReadOnlyModelViewSet):
+    """
+    Payment Method ViewSet
+    Provides read-only access to payment methods
+    """
+
+    permission_classes = [IsAuthenticated, TenantPermission]
+    serializer_class = PaymentMethodSerializer
+    lookup_field = 'id'
+
+    def get_queryset(self):
+        """
+        Return available payment methods
+        """
+        return PaymentMethod.objects.filter(is_active=True)
+
+    @extend_schema(
+        summary="Get Payment Method Fees",
+        description="Retrieve payment method fees",
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=True, methods=['get'])
+    def fees(self, request, *args, **kwargs):
+        """
+        Get payment method fees
+        """
+        payment_method = self.get_object()
+        payment_service = PaymentService()
+
+        try:
+            fees = payment_service.get_payment_method_fees(payment_method)
+            return Response(fees)
+        except Exception as e:
+            return Response(
+                {'detail': f'Fee retrieval failed: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+
+class PublicPaymentViewSet(viewsets.ViewSet):
+    """
+    Public Payment ViewSet
+    Provides public access to payment information
+    """
+
+    permission_classes = [permissions.AllowAny]
+
+    @extend_schema(
+        summary="Get Available Payment Methods",
+        description="Retrieve publicly available payment methods",
+        responses={200: PaymentMethodSerializer(many=True)}
+    )
+    @action(detail=False, methods=['get'])
+    def available_methods(self, request):
+        """
+        Get available payment methods
+        """
+        payment_service = PaymentService()
+        methods = payment_service.get_public_payment_methods()
+        serializer = PaymentMethodSerializer(methods, many=True)
+        return Response(serializer.data)
+
+    @extend_schema(
+        summary="Get Payment Providers",
+        description="Retrieve supported payment providers",
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=False, methods=['get'])
+    def providers(self, request):
+        """
+        Get payment providers
+        """
+        payment_service = PaymentService()
+        providers = payment_service.get_payment_providers()
+        return Response(providers)
+
+    @extend_schema(
+        summary="Get Currency Information",
+        description="Retrieve supported currencies and exchange rates",
+        responses={200: OpenApiTypes.OBJECT}
+    )
+    @action(detail=False, methods=['get'])
+    def currencies(self, request):
+        """
+        Get currency information
+        """
+        payment_service = PaymentService()
+        currencies = payment_service.get_currency_info()
+        return Response(currencies)