from decimal import Decimal import json from django.http import HttpResponseBadRequest, HttpResponseRedirect, JsonResponse from django.shortcuts import get_object_or_404, redirect, render import stripe from accounts import resource_action from accounts.models import IAmPrincipal from django.contrib.auth import login import jwt from django.utils import timezone from django.contrib.auth import get_user_model from goodtimes.services import StripeService from manage_coupons.models import Coupon from manage_subscriptions.forms import ( SubscriptionForm, PrincipalSubscriptionForm, SubscriptionUpdateForm, ) from manage_wallets.models import ( PaymentMethod, Transaction, TransactionStatus, TransactionType, ) from .models import ( Subscription, PrincipalSubscription, SubscriptionStatus, ) from django.views import generic from django.contrib.auth.mixins import LoginRequiredMixin from django.urls import reverse, reverse_lazy from django.contrib import messages from goodtimes import constants from django.views.decorators.csrf import csrf_exempt from django.views.decorators.http import require_POST from django.conf import settings from django.views.generic.base import TemplateView from django.db.models import Q from django.db import transaction # Create your views here. class SubscriptionCreateOrUpdateView(LoginRequiredMixin, generic.View): # Set the page_name and resource page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS # Initialize the action as ACTION_CREATE (can change based on logic) action = resource_action.ACTION_CREATE # Default action template_name = "manage_subscriptions/subscription_add.html" model = Subscription form_class = SubscriptionForm success_url = reverse_lazy("manage_subscriptions:subscription_list") error_message = "An error occurred while saving the data." # Determine the success message dynamically based on whether it's an update or create def get_success_message(self): self.success_message = ( constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED ) return self.success_message # Get the object (if exists) based on URL parameter 'pk' def get_object(self): pk = self.kwargs.get("pk") return get_object_or_404(self.model, pk=pk) if pk else None # Add page_name and operation to the context def get_context_data(self, **kwargs): context = { "page_name": self.page_name, "operation": "Add" if not self.object else "Edit", } context.update(kwargs) # Include any additional context data passed to the view return context def get(self, request, *args, **kwargs): self.object = self.get_object() # If an object is found, change action to ACTION_UPDATE if self.object is not None: self.action = resource_action.ACTION_UPDATE if self.object: self.form_class = SubscriptionUpdateForm else: self.form_class = self.form_class form = self.form_class(instance=self.object) context = self.get_context_data(form=form) return render(request, self.template_name, context=context) def post(self, request, *args, **kwargs): self.object = self.get_object() # If an object is found, change action to ACTION_UPDATE if self.object is not None: self.action = resource_action.ACTION_UPDATE if self.object: form = SubscriptionUpdateForm(request.POST, instance=self.object) else: form = self.form_class(request.POST) if not form.is_valid(): print(form.errors) context = self.get_context_data(form=form) return render(request, self.template_name, context=context) # This code ensures that only one free plan can be created by checking for existing free plans before saving a new one. if form.cleaned_data.get("is_free"): if self.model.objects.filter(Q(is_free=True) & Q(active=True)).exists(): messages.error( self.request, "A free plan is already available. Please deactivate the existing one before creating a new one.", ) context = self.get_context_data(form=form) return render(request, self.template_name, context=context) form.save() messages.success(self.request, self.get_success_message()) return redirect(self.success_url) class SubscriptionView(LoginRequiredMixin, generic.ListView): page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS action = resource_action.ACTION_READ model = Subscription template_name = "manage_subscriptions/subscription_list.html" context_object_name = "subscription_obj" def get_queryset(self): queryset = ( super() .get_queryset() .filter(deleted=False) .prefetch_related("principal_types") ) return queryset.order_by("-created_on") def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context["page_name"] = self.page_name return context class SubscriptionDetailView(LoginRequiredMixin, generic.DetailView): page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS action = resource_action.ACTION_READ model = Subscription template_name = "manage_subscriptions/subscription_details.html" context_object_name = "subscription" def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context["page_name"] = self.page_name return context class SubscriptionDeleteView(LoginRequiredMixin, generic.View): page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS action = resource_action.ACTION_DELETE model = Subscription success_url = reverse_lazy("manage_subscriptions:subscription_list") success_message = constants.RECORD_DELETED error_message = constants.RECORD_NOT_FOUND def get(self, request, pk): try: # Retrieve the subscription object subscription = self.model.objects.get(id=pk) subscription.deleted = True subscription.active = False subscription.save() messages.success(request, self.success_message) except self.model.DoesNotExist: messages.error(request, self.error_message) return redirect(self.success_url) class PrincipalSubscriptionCreateOrUpdateView(LoginRequiredMixin, generic.View): # Set the page_name and resource page_name = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS resource = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS # Initialize the action as ACTION_CREATE (can change based on logic) action = resource_action.ACTION_CREATE # Default action template_name = "manage_subscriptions/principal_subscription_add.html" model = PrincipalSubscription form_class = PrincipalSubscriptionForm success_url = reverse_lazy("manage_subscriptions:principal_subscriptions_list") error_message = "An error occurred while saving the data." # Determine the success message dynamically based on whether it's an update or create def get_success_message(self): self.success_message = ( constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED ) return self.success_message # Get the object (if exists) based on URL parameter 'pk' def get_object(self): pk = self.kwargs.get("pk") return get_object_or_404(self.model, pk=pk) if pk else None # Add page_name and operation to the context def get_context_data(self, **kwargs): context = { "page_name": self.page_name, "operation": "Add" if not self.object else "Edit", } context.update(kwargs) # Include any additional context data passed to the view return context def get(self, request, *args, **kwargs): self.object = self.get_object() # If an object is found, change action to ACTION_UPDATE if self.object is not None: self.action = resource_action.ACTION_UPDATE form = self.form_class(instance=self.object) context = self.get_context_data(form=form) return render(request, self.template_name, context=context) def post(self, request, *args, **kwargs): self.object = self.get_object() # If an object is found, change action to ACTION_UPDATE if self.object is not None: self.action = resource_action.ACTION_UPDATE form = self.form_class(request.POST, instance=self.object) if not form.is_valid(): print(form.errors) context = self.get_context_data(form=form) return render(request, self.template_name, context=context) form.save() messages.success(self.request, self.get_success_message()) return redirect(self.success_url) class PrincipalSubscriptionView(LoginRequiredMixin, generic.ListView): page_name = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS resource = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS action = resource_action.ACTION_READ model = PrincipalSubscription template_name = "manage_subscriptions/principal_subscriptions_list.html" context_object_name = "principal_subscription_obj" def get_queryset(self): return super().get_queryset().all() def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context["page_name"] = self.page_name return context class PrincipalSubscriptionDetailView(LoginRequiredMixin, generic.DetailView): page_name = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS resource = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS action = resource_action.ACTION_READ model = PrincipalSubscription template_name = "manage_subscriptions/principal_subscription_details.html" context_object_name = "principal_subscription_obj" def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context["page_name"] = self.page_name return context class PrincipalSubscriptionDeleteView(LoginRequiredMixin, generic.View): page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS action = resource_action.ACTION_DELETE model = PrincipalSubscription success_url = reverse_lazy("manage_subscriptions:principal_subscriptions_list") success_message = constants.RECORD_DELETED error_message = constants.RECORD_NOT_FOUND def get(self, request, pk): try: type_obj = self.model.objects.get(id=pk) type_obj.deleted = True type_obj.active = False type_obj.save() messages.success(request, self.success_message) except self.model.DoesNotExist: messages.success(request, self.error_message) return redirect(self.success_url) class SubscriptionPageView(generic.View): template_name = "stripe_html/index.html" model = Subscription error_url = reverse_lazy("manage_subscriptions:error") def get(self, request): if not request.user.is_authenticated: return HttpResponseRedirect(self.error_url) print("request user is :", request.user) obj = self.model.objects.filter( principal_types=request.user.principal_type, active=True, is_free=False, ) if not obj.exists(): print(f"No pre-define subscription details found in {self.model} table for user_type {request.user.principal_type}") return HttpResponseRedirect(self.error_url) context = { "subscriptions": obj, # "stripeCheckoutUrl": request.build_absolute_uri(reverse("manage_subscriptions:create_checkout_session")), # "couponValidityCheckUrl": request.build_absolute_uri(reverse("manage_subscriptions:validate_coupon")), "stripeCheckoutUrl": settings.STRIPE_CHECKOUT_URL, "couponValidityCheckUrl": settings.COUPON_VALIDITY_CHECK_URL, "stripe_public_key": settings.STRIPE_PUBLISH_KEY } return render(request, self.template_name, context=context) class ActiveSubscriptionView(generic.View): template_name = "stripe_html/active_subscription.html" model = IAmPrincipal def get(self, request, *args, **kwargs): token = request.GET.get("token") print("token: ", token) if token: try: # Decode and validate token payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"]) user = self.model.objects.get(id=payload["user_id"]) # Manually specify the authentication backend user.backend = "django.contrib.auth.backends.ModelBackend" # Log the user in login(request, user) except ( IAmPrincipal.DoesNotExist, jwt.ExpiredSignatureError, jwt.InvalidTokenError, ): return HttpResponseRedirect(reverse("manage_subscriptions:error")) today = timezone.now().date() if request.user.is_authenticated: latest_subscription = PrincipalSubscription.get_active_princial_subscription(request.user) print(f"latest subscription reodr is {latest_subscription}") if not latest_subscription: return HttpResponseRedirect(reverse("manage_subscriptions:stripe")) return render(request, self.template_name, context={"subscription": latest_subscription}) return HttpResponseRedirect(reverse("manage_subscriptions:error")) class CancelAutoSubscriptionView(LoginRequiredMixin, generic.View): model = PrincipalSubscription error_url = reverse_lazy("manage_subscriptions:error") def get(self, request, *args, **kwargs): subscription_id = self.kwargs.get("subscription_id") try: subscription = self.model.objects.get( id=subscription_id, principal=request.user ) except self.model.DoesNotExist: messages.error(request, "Subscription not found.") return redirect("manage_subscriptions:error") try: if subscription.stripe_subscription_id: data = StripeService.cancel_auto_renew_subscription(subscription.stripe_subscription_id) if not data["success"]: return redirect(self.error_url) self.model.cancel_stipe_auto_renew_subscription(subscription) except Exception as e: print(f'an error occur {str(e)}') messages.error(request, f"An error occurred while cancelling the subscription {str(e)}") return redirect(self.error_url) return redirect(reverse_lazy("manage_subscriptions:active")) # def post(self, request, *args, **kwargs): # subscription_id = request.POST.get("subscription_id") # try: # subscription = PrincipalSubscription.objects.get( # id=subscription_id, principal=request.user # ) # except PrincipalSubscription.DoesNotExist: # messages.error(request, "Subscription not found.") # return redirect("manage_subscriptions:cancel") # try: # with transaction.atomic(): # if subscription.is_stripe_subscription: # # Cancel Stripe subscription # stripe.Subscription.modify( # subscription.stripe_subscription_id, cancel_at_period_end=True # ) # # Updating subscription status in the local database # subscription.status = SubscriptionStatus.INACTIVE # subscription.cancelled = True # subscription.auto_renew = False # subscription.cancelled_date_time = timezone.now() # subscription.save() # messages.success(request, "Subscription cancelled successfully.") # return redirect("manage_subscriptions:subscription_cancel_success") # except stripe.error.InvalidRequestError as e: # messages.error(request, f"Stripe error: {str(e)}") # return redirect("manage_subscriptions:subscription_cancel_fails") @csrf_exempt @require_POST def validate_coupon(request): data = json.loads(request.body) coupon_code = data.get("couponCode", None) subscription_id = data.get("subscriptionId", None) final_amount = None try: subscription = Subscription.objects.get(id=subscription_id) except Subscription.DoesNotExist: return JsonResponse({"error": "Subscription not found."}, status=404) # If no coupon code is provided, assume no discount and proceed if not coupon_code: return JsonResponse({"message": "No coupon code provided."}, status=200) # Validating Coupon try: coupon = Coupon.objects.get(coupon_code=coupon_code) if not coupon.is_valid(): return JsonResponse({"error": "Coupon is not valid."}, status=400) # Check discount amount if coupon.discount_amount and coupon.discount_amount > subscription.amount: final_amount = subscription.amount - coupon.discount_amount return JsonResponse( {"error": "Coupon discount amount exceeds subscription amount."}, status=400, ) # Check discount percentage if coupon.discount_percentage: discount = ( coupon.discount_percentage / Decimal("100") ) * subscription.amount if discount > subscription.amount: return JsonResponse( { "error": "Coupon discount percentage exceeds subscription amount." }, status=400, ) final_amount = subscription.amount - discount # Retrieving coupon from Stripe if applicable if coupon.coupon_id: try: stripe_coupon = stripe.Coupon.retrieve(coupon.coupon_id) print("stripe_coupon: ", stripe_coupon) if ( stripe_coupon.max_redemptions and stripe_coupon.times_redeemed >= stripe_coupon.max_redemptions ): return JsonResponse( {"error": "Coupon max redeems reached."}, status=400 ) return JsonResponse( {"data": {"coupon": stripe_coupon, "finalAmount": final_amount}}, status=200, ) except stripe.error.InvalidRequestError: return JsonResponse( {"error": f"Invalid coupon code: {coupon_code}"}, status=400 ) except stripe.error.StripeError as e: return JsonResponse({"error": f"Stripe error: {str(e)}"}, status=400) else: return JsonResponse( { "error": "Coupon is either invalid, expired, or not associated with Stripe." }, status=400, ) except Coupon.DoesNotExist: return JsonResponse({"error": "Coupon not found."}, status=404) @csrf_exempt @require_POST def create_checkout_session(request): stripe.api_key = settings.STRIPE_SECRET_KEY data = json.loads(request.body) subscription_id = data.get("subscriptionId") coupon_code = data.get("couponCode") transaction_amount = data.get("finalAmount") is_recurring = data.get("isRecurring") principal_id = request.user.id print(f"subscription data is {subscription_id}, {coupon_code}, { is_recurring}") try: subscription = Subscription.objects.get(id=subscription_id) except Subscription.DoesNotExist: return JsonResponse({"error": "Subscription not found."}, status=404) # Default transaction amount based on subscription amount session_data = { "payment_method_types": ["card"], "success_url": request.build_absolute_uri("/subscriptions/success/"), "cancel_url": request.build_absolute_uri("/subscriptions/cancel/"), "metadata": { "transaction_amount": str(subscription.amount), "principal": str(principal_id), "principal_email": str(request.user.email), "subscription_id": str(subscription.id), "product_id": subscription.product_id, "couponCode": coupon_code if coupon_code else None, }, } print("session_data: ", session_data) # Coupon Handling if coupon_code: try: stripe_coupon = stripe.Coupon.retrieve(coupon_code) session_data["discounts"] = [{"coupon": stripe_coupon.id}] except stripe.error.InvalidRequestError: return JsonResponse( {"error": f"Invalid coupon code: {coupon_code}"}, status=400 ) except stripe.error.StripeError as e: return JsonResponse({"error": f"Stripe error: {str(e)}"}, status=400) # Creating the Stripe Checkout Session try: if is_recurring and subscription.price_id: session_data["line_items"] = [ { "price": subscription.price_id, "quantity": 1, } ] session_data["mode"] = "subscription" session_data["subscription_data"] = { "metadata": session_data["metadata"], } else: session_data["line_items"] = [ { "price_data": { "currency": "gbp", "product_data": { "name": subscription.title, "description": subscription.short_description, }, "unit_amount": int(subscription.amount * 100), }, "quantity": 1, } ] session_data["mode"] = "payment" checkout_session = stripe.checkout.Session.create(**session_data) return JsonResponse({"sessionId": checkout_session["id"]}) except Exception as e: return JsonResponse({"error": str(e)}, status=500) class ErrorView(TemplateView): template_name = "stripe_html/webview_404.html" class SuccessView(TemplateView): template_name = "stripe_html/success.html" class CancelView(TemplateView): template_name = "stripe_html/cancel.html" class SubscriptionCancelSuccessView(TemplateView): template_name = "stripe_html/subscription_cancel_success.html" class SubscriptionCancelFailsView(TemplateView): template_name = "stripe_html/subscription_cancel_fails.html"