goodtimes/manage_subscriptions/views.py

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"