from django.shortcuts import render, get_object_or_404 from rest_framework import generics, permissions from rest_framework.permissions import IsAuthenticated from rest_framework.response import Response from rest_framework import status from order.models import * from product.models import * from ..serializers import * from ..services.product_boosting import apply_boosting_logic from django.db import transaction from suscription.custom_pagination import CustomPagination from Help_Support.decorators import cache_response from rest_framework.exceptions import ValidationError from setting.views import * from decimal import Decimal from rest_framework.views import APIView from rest_framework import viewsets from rest_framework.generics import UpdateAPIView from rest_framework.decorators import action import requests from rest_framework.permissions import AllowAny from login_signup.custom_permissions import IsCustomAdmin from Help_Support.decorators import cache_response import logging logger = logging.getLogger(__name__) def check_payment_status(transaction_id): flutterwave_secret_key = settings.FLUTTERWAVE_SECRET_KEY url = f"https://api.flutterwave.com/v3/transactions/{transaction_id}/verify" headers = { "Authorization": f"Bearer {flutterwave_secret_key}", "Content-Type": "application/json", } try: response = requests.get(url, headers=headers) response_data = response.json() return response_data except Exception as e: return { "status": False, "message": str(e), "data": None } class SubscriptionViewSet(viewsets.ModelViewSet): serializer_class = PlanPurchaseSerializer permission_classes = [IsAuthenticated] def get_queryset(self): return PlanPurchase.objects.filter(vendor=self.request.user).order_by("-created_at") def list(self, request, *args, **kwargs): queryset = self.get_queryset() page = self.paginate_queryset(queryset) if page is not None: serializer = self.get_serializer(page, many=True, context={'request': request}) paginated_response = self.get_paginated_response(serializer.data) return Response({ "status": True, "message": "Subscription transaction listing retrieved successfully", "data": paginated_response.data }) serializer = self.get_serializer(queryset, many=True, context={'request': request}) return Response({ "status": True, "message": "Subscription transaction listing retrieved successfully", "data": serializer.data }) def create(self, request, *args, **kwargs): data = request.data.copy() data["vendor"] = request.user.id if not data.get('main_category'): data['main_category'] = request.user.main_category.id if request.user.main_category else None vendor = request.user transaction_id = data.get('transaction_id') logger.info('Subscription Plan API Call') plan_purchase = PlanPurchase.objects.filter(transaction_id=transaction_id).first() if plan_purchase: if plan_purchase.payment_status == 'successful': return Response({ "status": True, "message": "Subscription already available", "data": PlanPurchaseSerializer(plan_purchase).data }, status=status.HTTP_201_CREATED) transaction_result = check_payment_status(transaction_id) # Print response for debugging print("Flutterwave Response:", transaction_result) logger.info('📦 Transaction Details from API: %s', transaction_result) response_data = transaction_result.get("data") logger.info('Response-------: %s', response_data) logger.info('Response-------Status: %s', response_data.get("status")) if response_data.get("status") == "success" or response_data.get("status") == "successful": logger.info('Subscription Process Start-------') # return Response({ # "status": True, # "message": "dattaa", # "data": transaction_result.get('data') # }, status=status.HTTP_201_CREATED) meta_data = response_data.get("meta", {}) data["main_category"] = meta_data.get("main_category") data["categories_plan"] = meta_data.get("plan_id") data["plan_duration"] = meta_data.get("duration_id") data["amount"] = response_data.get("amount") data["payment_method"] = "mobile_money" if response_data.get("payment_type") == 'mobilemoneytz' else "credit_card" data["payment_status"] = response_data.get("status") data["duration_months"] = None month_value = meta_data.get("month", "") if month_value: month_number = month_value.split("_")[1] data["duration_months"] = int(month_number) serializer = self.get_serializer(data=data) serializer.is_valid(raise_exception=True) main_category = serializer.validated_data.get('main_category') logger.info('-------serializer.validated_data-------', serializer.validated_data) if not main_category: return Response({"error": "Invalid main_category ID."}, status=status.HTTP_400_BAD_REQUEST) # existing_plan = PlanPurchase.objects.filter( # vendor=request.user, main_category=main_category, status='active', payment_status="successful" # ).first() existing_plans = PlanPurchase.objects.filter( vendor=request.user, main_category=main_category, status='active', payment_status="successful" ) existing_plans.update(status='expired') categories_plan = serializer.validated_data.get('categories_plan') durations_months = serializer.validated_data.get('duration_months', 12) start_date = now().date() end_date = start_date + relativedelta(months=durations_months) # if existing_plan: # existing_plan.status = 'expired' # existing_plan.save() # else: # if categories_plan is None: # categories_plan = CategoriesPlan.objects.filter(main_category=main_category, name='FREE').first() product_limit = serializer.validated_data.get('plan_duration').product_limit if serializer.validated_data.get('plan_duration') else None # if categories_plan.name == 'FREE' : # product_limit = 1 purchase = PlanPurchase.objects.create( vendor=request.user, main_category=main_category, categories_plan=categories_plan, plan_duration=serializer.validated_data.get('plan_duration'), price=serializer.validated_data.get('price'), duration_months=durations_months, product_limit=product_limit, amount=serializer.validated_data.get('amount', 0.00), tx_ref=serializer.validated_data.get('tx_ref', None), start_date=start_date, end_date=end_date, transaction_id=serializer.validated_data.get('transaction_id', None), payment_status=serializer.validated_data.get('payment_status', 'successful'), payment_method=serializer.validated_data.get('payment_method', 'successful'), # status='active', status=PlanPurchase.Status.Active ) if existing_plans.exists(): vendor_id = vendor.id Product.objects.filter( user_id=vendor_id, is_boosted=True ).update(is_boosted=False) active_paid_products = Product.objects.filter( user_id=vendor_id, payment_status="paid", status="active" ).order_by('-id') active_paid_count = active_paid_products.count() logger.info('🧑‍💼 active product count: %s', active_paid_count) logger.info('🧑‍💼 new plan limit: %s', product_limit) logger.info('🧑‍💼 new active plan count: %s', active_paid_count) if active_paid_count > product_limit: logger.info('🧑‍💼 new active plan count: %s', active_paid_count) extra_count = active_paid_count - product_limit extra_product_ids = list( active_paid_products.values_list('id', flat=True)[:extra_count] ) logger.info('🧑‍💼 Inactivate products: %s', extra_product_ids) Product.objects.filter(id__in=extra_product_ids).update(status="inactive") purchase.products_added = min(active_paid_count, product_limit) purchase.save() # expired_product_ids = list( # Product.objects.filter( # user_id=vendor_id, # # is_expired=True # ).exclude(payment_status="paid").order_by('-updated_at').values_list('id', flat=True)[:product_limit] # ) # # updated_count = expired_products.update(is_expired=False, payment_status="paid") # updated_count = Product.objects.filter(id__in=expired_product_ids).update(is_expired=False, payment_status="paid") apply_boosting_logic(vendor=vendor, purchase=purchase) logger.info("✅ Subscription created for Vendor") return Response({ "status": True, "message": "Subscription created successfully", "data": PlanPurchaseSerializer(purchase).data }, status=status.HTTP_201_CREATED) else: return Response({ "status": False, "message": transaction_result.get("message"), "data": None }, status=status.HTTP_400_BAD_REQUEST) class ActiveSubscriptionView(APIView): permission_classes = [IsAuthenticated] def get(self, request): vendor = request.user active_subscription = PlanPurchase.objects.filter( vendor=vendor.id, payment_status=PlanPurchase.PaymentStatus.SUCCESS, # status=PlanPurchase.Status.Active, # end_date__gte=now() ).order_by('-created_at').first() if active_subscription: serializer = ActiveSubscriptionSerializer(active_subscription) return Response({ "status": True, "message": "Active Subscription fetch successfully", "data": serializer.data }, status=status.HTTP_200_OK) return Response({"message": "No active subscription found"}, status=404)