def activate_free_trial(self, request, card):
user = User.objects.get(email=request.user.email)
if user.has_used_free_trial:
return Response(status=status.HTTP_400_BAD_REQUEST)
serializer = CardSerializer(
card,
data={
"status": int(CardStatus.ON_FREE_TRIAL),
"next_plan": "",
"free_trial_end": date.today() + timedelta(days=14),
"plan": PlanKind.FREE_TRIAL.value,
},
partial=True,
)
context = CardActivationValidationContext(serializer)
context.is_valid()
serializer.is_valid(raise_exception=True)
serializer.save()
user.has_used_free_trial = True
user.save()
reset_free_trial_draft_cards(request)
return Response(serializer.data)
def create(self, request):
request.data["owner"] = request.user.id
serializer = CardSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def reset_free_trial_draft_cards(request):
free_trial_draft_cards = (get_user_cards(request).filter(
Q(plan=PlanKind.FREE_TRIAL.value)
| Q(next_plan=PlanKind.FREE_TRIAL.value)).exclude(
status=int(CardStatus.ON_FREE_TRIAL)))
for free_card in free_trial_draft_cards:
free_card_serializer = CardSerializer(
free_card,
data={
"status": int(CardStatus.DRAFT),
"next_plan": PlanKind.BASIC.value,
"plan": "",
},
partial=True,
)
free_card_serializer.is_valid(raise_exception=True)
free_card_serializer.save()
def create_with_subscription(self, request):
data = {
"owner": request.user.id,
"status": int(CardStatus.ACTIVE),
"nextPlan": "",
"plan": PlanKind.PREMIUM.value,
"free_trial_end": None
}
card_serializer = CardSerializer(data=data)
card_serializer.is_valid(raise_exception=True)
activation_serializer = CardActivationRequestSerializer(
data=request.data)
activation_serializer.is_valid(raise_exception=True)
# Create Stripe Customer ID and Subscription
customer_id = generate_user_customer_id(request.user,
request.data["payment_method"])
subscription_id = create_subscription(customer_id,
PlanKind.PREMIUM.value,
request.data["payment_method"])
# Create and save card
card = card_serializer.save()
card.subscription_id = subscription_id
card.save()
# Send notification to designers
task = Thread(
target=self.send_card_created_email,
args=(
_("mail_user_new_card_notification_subject"),
render_to_string(
"mailers/new_card_created.html",
{"email": request.user.email},
request=request,
),
),
)
task.start()
return Response(CardSerializer(card).data)
def handle(self, *args, **options):
cards = Card.objects.filter(
status=CardStatus.ON_FREE_TRIAL.value).exclude(free_trial_end=None)
today = date.today()
for card in cards:
if card.free_trial_end < today:
print(f"Ending free trial for card {card.id}")
serializer = CardSerializer(
card,
data={
"status": int(CardStatus.SUBSCRIPTION_INACTIVE),
"plan": "",
"next_plan": PlanKind.PLUS.value,
"free_trial_end": None,
},
partial=True,
)
serializer.is_valid(raise_exception=True)
serializer.save()
print("Ending free trial done")
def activate_plan(self, request, card):
activation_serializer = CardActivationRequestSerializer(
data=request.data)
activation_serializer.is_valid(raise_exception=True)
serializer = CardSerializer(
card,
data={
"status":
int(CardStatus.VIRTUAL)
if card.need_virtual and card.next_plan != PlanKind.BASIC.value
else int(CardStatus.ACTIVE),
**({
"next_plan": "",
"plan": card.next_plan
} if (card.next_plan and card.next_plan != card.plan) else {}),
"free_trial_end":
None,
},
partial=True,
)
context = CardActivationValidationContext(serializer)
context.is_valid()
serializer.is_valid(raise_exception=True)
customer_id = generate_user_customer_id(
request.user,
activation_serializer.data["payment_method"]
if "payment_method" in activation_serializer.data else None,
)
if card.purchase_domain:
domain_infos = get_domain_infos(card)
if not domain_infos["available"]:
return Response(ErrorCodes.UNAVAILABLE_DOMAIN)
price = domain_infos["price"] - domain_infos["rebate"]
need_payment = price > 0
if need_payment:
payment_intent_id = generate_manual_payment_intent(
price, activation_serializer.data["payment_method"],
customer_id)
success, order_id = register_domain(card.purchase_domain)
if not success:
if need_payment:
cancel_payment_intent(payment_intent_id)
return Response(
{"errors": [ErrorCodes.DOMAIN_REGISTRATION_ERROR.value]})
task = Thread(target=self.setup_dns,
args=(
order_id,
card.purchase_domain,
))
task.start()
if need_payment:
charge_payment_intent(payment_intent_id)
Domain.objects.create(owner=request.user,
domain=card.purchase_domain)
card.url = card.purchase_domain
card.purchase_domain = None
if domain_infos["rebate"] > 0:
card.rebate_used = True
card.save()
subscription_plan = card.next_plan or card.plan
if (card.next_plan and
(card.next_plan in PLANS_HAVE_SUBSCRIPTION)) or (
card.status == CardStatus.SUBSCRIPTION_INACTIVE and
(subscription_plan in PLANS_HAVE_SUBSCRIPTION)):
payment_method = activation_serializer.data["payment_method"]
if card.status == CardStatus.SUBSCRIPTION_INACTIVE:
card.subscription_id = create_subscription(
customer_id, subscription_plan, payment_method)
else:
if card.subscription_id:
modify_subscription(card.subscription_id, card.next_plan,
payment_method)
else:
card.subscription_id = create_subscription(
customer_id, card.next_plan, payment_method)
card.save()
serializer.save()
return Response(serializer.data)