596 lines
23 KiB
Python
596 lines
23 KiB
Python
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,
|
|
)
|
|
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
|
|
|
|
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)
|
|
|
|
# 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),
|
|
"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"
|