uncloud-mravi/matrixhosting/views.py

305 lines
14 KiB
Python
Raw Normal View History

import logging
import json
import decimal
from django.views.generic.base import TemplateView
from stripe.error import CardError
from django.shortcuts import redirect, render
from django.contrib import messages
from django.utils.translation import get_language, ugettext_lazy as _
from django.contrib.auth.decorators import login_required
from django.views.decorators.cache import cache_control
from django.utils.decorators import method_decorator
from django.views import View
from django.views.generic import FormView, DetailView
from django.views.generic.list import ListView
2021-09-10 07:58:42 +00:00
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from matrixhosting.forms import InitialRequestForm, RequestDomainsNamesForm
from uncloud_pay.forms import BillingAddressForm
from django.urls import reverse
from django.conf import settings
from django.http import (
HttpResponseRedirect, JsonResponse, HttpResponse
)
2021-09-10 07:58:42 +00:00
from django.utils import timezone
from django_q.models import Schedule
from django_q.tasks import schedule
2021-08-04 10:03:55 +00:00
from wkhtmltopdf.views import PDFTemplateResponse
from rest_framework import viewsets, permissions
from uncloud_pay.models import PricingPlan
from uncloud_pay.utils import get_order_total_with_vat
from uncloud_pay.models import *
from uncloud_pay.utils import validate_vat_number
from uncloud_pay.selectors import get_billing_address_for_user, has_enough_balance, get_balance_for_user
import uncloud_pay.stripe as uncloud_stripe
from .models import VMInstance
from .serializers import *
2021-08-04 10:03:55 +00:00
from .utils import *
2021-08-24 12:25:28 +00:00
from ldap.ldapobject import LDAPObject
logger = logging.getLogger(__name__)
class PricingView(TemplateView):
template_name = "matrixhosting/pricing.html"
class IndexView(FormView):
template_name = "matrixhosting/index.html"
form_class = InitialRequestForm
success_url = "/matrixhosting#requestform"
success_message = "Thank you, we will contact you as soon as possible"
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['matrix_vm_pricing'] = PricingPlan.get_default_pricing()
return context
def form_valid(self, form):
self.request.session['order'] = form.cleaned_data
pricing = get_order_total_with_vat(
form.cleaned_data['cores'],
form.cleaned_data['memory'],
form.cleaned_data['storage'],
form.cleaned_data['pricing_name'],
False
)
self.request.session['pricing'] = pricing
return HttpResponseRedirect(reverse('matrix:payment'))
class OrderPaymentView(FormView):
template_name = 'matrixhosting/order_details.html'
success_url = 'matrix:order_confirmation'
form_class = BillingAddressForm
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_context_data(self, **kwargs):
context = super(OrderPaymentView, self).get_context_data(**kwargs)
2021-08-16 08:46:59 +00:00
default_pricing = PricingPlan.get_default_pricing()
if 'billing_address_data' in self.request.session:
billing_address_form = BillingAddressForm(
initial=self.request.session['billing_address_data']
)
else:
old_active = get_billing_address_for_user(self.request.user)
billing_address_form = BillingAddressForm(
instance=old_active
) if old_active else BillingAddressForm(
initial={'active': True, 'owner': self.request.user.id}
)
if self.request.GET.get('product', False):
matched_prod = Product.objects.filter(name=self.request.GET.get('product')).first()
if matched_prod:
self.request.session['order'] = matched_prod.config
details_form = InitialRequestForm(
2021-08-16 08:46:59 +00:00
initial=self.request.session.get('order', {'pricing_name': default_pricing.name})
)
balance = get_balance_for_user(self.request.user)
customer_id = uncloud_stripe.get_customer_id_for(self.request.user)
#TODO optimize this part for better performance
uncloud_stripe.sync_cards_for_user(self.request.user)
cards = uncloud_stripe.get_customer_cards(customer_id)
2021-08-16 08:46:59 +00:00
pricing = self.request.session.get('pricing', {'name': default_pricing.name, 'total': 0})
context.update({
2021-08-16 08:46:59 +00:00
'matrix_vm_pricing': PricingPlan.get_by_name(pricing['name']),
'billing_address_form': billing_address_form,
'details_form': details_form,
'balance': balance,
'cards': cards,
'stripe_key': settings.STRIPE_PUBLIC_KEY,
2021-08-16 08:46:59 +00:00
'show_cards': True if balance < pricing['total'] else False,
})
return context
@cache_control(no_cache=True, must_revalidate=True, no_store=True)
def get(self, request, *args, **kwargs):
for k in ['vat_validation_status', 'token', 'id_payment_method', 'total']:
if request.session.get(k):
request.session.pop(k)
return self.render_to_response(self.get_context_data())
def post(self, request, *args, **kwargs):
details_form = InitialRequestForm(request.POST)
billing_address_form = BillingAddressForm(request.POST)
2021-09-10 07:58:42 +00:00
context = self.get_context_data()
if not details_form.is_valid() or not billing_address_form.is_valid():
context.update({'details_form': details_form,
'billing_address_form': billing_address_form})
return self.render_to_response(context)
address = get_billing_address_for_user(self.request.user)
if address:
form = BillingAddressForm(self.request.POST, instance=address)
else:
form = BillingAddressForm(self.request.POST)
if form.is_valid:
billing_address_ins = form.save()
self.request.session["billing_address_id"] = billing_address_ins.id
self.request.session['billing_address_data'] = billing_address_form.cleaned_data
self.request.session['billing_address_data']['owner'] = self.request.user.id
id_payment_method = self.request.POST.get('id_payment_method', False)
selected_card = False
if id_payment_method and id_payment_method != 'undefined':
uncloud_stripe.attach_payment_method(id_payment_method, self.request.user)
selected_card = StripeCreditCard.objects.filter(card_id=id_payment_method).first()
selected_card.activate()
vat_number = billing_address_form.cleaned_data.get('vat_number').strip()
if vat_number:
customer_id = uncloud_stripe.get_customer_id_for(self.request.user)
validate_result = validate_vat_number(
stripe_customer_id=customer_id,
billing_address_id=billing_address_ins.id
)
if 'error' in validate_result and validate_result['error']:
messages.add_message(
self.request, messages.ERROR, validate_result["error"],
extra_tags='error'
)
return HttpResponseRedirect(
reverse('matrix:payment')
)
self.request.session["vat_validation_status"] = validate_result["status"]
specs = details_form.cleaned_data
vat_rate = VATRate.get_vat_rate(billing_address_ins)
vat_validation_status = "verified" if billing_address_ins.vat_number_validated_on and billing_address_ins.vat_number_verified else False
pricing = get_order_total_with_vat(
2021-09-10 07:58:42 +00:00
specs['cores'], specs['memory'], specs['storage'], context['matrix_vm_pricing'].name,
vat_rate=vat_rate * 100, vat_validation_status = vat_validation_status
)
self.request.session['pricing'] = pricing
self.request.session['order'] = specs
self.request.session['vat_validation_status'] = vat_validation_status
2021-09-10 07:58:42 +00:00
amount = get_balance_for_user(self.request.user) - pricing["total"]
if (amount < 0 and not selected_card):
messages.add_message(
self.request, messages.ERROR, "You haven't enough balance please select credit card to continue",
extra_tags='error'
)
return HttpResponseRedirect(
reverse('matrix:payment')
)
return HttpResponseRedirect(reverse('matrix:order_confirmation'))
class OrderConfirmationView(DetailView):
template_name = "matrixhosting/order_confirmation.html"
context_object_name = "order"
model = Order
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_context_data(self, **kwargs):
context = {
'order': self.request.session.get('order'),
'pricing': self.request.session.get('pricing'),
'balance': get_balance_for_user(self.request.user)
}
return context
@cache_control(no_cache=True, must_revalidate=True, no_store=True)
def get(self, request, *args, **kwargs):
context = self.get_context_data()
context['domains_form'] = RequestDomainsNamesForm(initial={})
if ('order' not in request.session):
return HttpResponseRedirect(reverse('matrix:index'))
elif 'pricing' not in self.request.session or 'vat_validation_status' not in self.request.session:
return HttpResponseRedirect(reverse('matrix:payment'))
total = self.request.session['pricing']['total']
2021-09-10 07:58:42 +00:00
amount = get_balance_for_user(self.request.user) - total
if (amount < 0):
context['stripe_deposit_amount'] = max(amount, settings.MIN_PER_TRANSACTION)
return render(request, self.template_name, context)
def post(self, request, *args, **kwargs):
domains_form = RequestDomainsNamesForm(self.request.POST)
if domains_form.is_valid():
customer = StripeCustomer.objects.get(owner=self.request.user)
billing_address = BillingAddress.objects.get(id=request.session.get('billing_address_id'))
total = self.request.session['pricing']['total']
self.request.session['order']['matrix_domain'] = 'ungleich.ch'
self.request.session['order']['homeserver_domain'] = domains_form.cleaned_data.get('homeserver_name') + ".matrix.ungleich.cloud"
self.request.session['order']['webclient_domain'] = domains_form.cleaned_data.get('webclient_name') + ".matrix.0co2.cloud"
self.request.session['order']['is_open_registration'] = domains_form.cleaned_data.get('is_open_registration')
try:
2021-09-10 07:58:42 +00:00
amount = get_balance_for_user(self.request.user) - total
if (amount < 0):
2021-08-16 08:46:59 +00:00
Payment.deposit(request.user, max(abs(amount), settings.MIN_PER_TRANSACTION), source='stripe')
2021-09-10 07:58:42 +00:00
amount = get_balance_for_user(self.request.user) - total
2021-08-16 08:46:59 +00:00
if (amount < 0):
messages.add_message(
self.request, messages.ERROR, "Please make sure that you have enough balance in your wallet and try again later.",
extra_tags='error'
)
return HttpResponseRedirect(
reverse('matrix:order_confirmation')
)
order, bill = finalize_order(request, customer,
billing_address,
total,
PricingPlan.get_by_name(self.request.session['pricing']['name']),
request.session.get('order'))
2021-08-16 08:46:59 +00:00
if order and bill:
self.request.session['bill_id'] = bill.id
2021-09-10 07:58:42 +00:00
return HttpResponseRedirect(reverse('uncloud_pay:order_success'))
except CardError as e:
messages.add_message(
self.request, messages.ERROR, e.user_message,
extra_tags='error'
)
return HttpResponseRedirect(
reverse('matrix:order_confirmation')
)
context = self.get_context_data()
context['domains_form'] = domains_form
return self.render_to_response(context)
2021-09-10 07:58:42 +00:00
class OrdersView(ListView):
template_name = "matrixhosting/orders.html"
model = Order
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_queryset(self):
2021-08-16 08:46:59 +00:00
return Order.objects.filter(owner=self.request.user).order_by('-creation_date')
def post(self, request, *args, **kwargs):
order = Order.objects.get(id=request.POST.get('order_id', 0))
order.cancel()
2021-09-10 07:58:42 +00:00
if hasattr(order, 'matrix_instance_id'):
last_bill_record = BillRecord.objects.filter(order=order).order_by('id').last()
schedule('matrixhosting.tasks.delete_instance',
order.instance_id,
schedule_type=Schedule.ONCE,
next_run=last_bill_record.ending_date or (timezone.now() + datetime.timedelta(hours=1)))
return JsonResponse({'message': 'Successfully Cancelled'})
class InstancesView(ListView):
template_name = "matrixhosting/instances.html"
model = VMInstance
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_queryset(self):
2021-08-16 08:46:59 +00:00
return VMInstance.objects.filter(owner=self.request.user).order_by('-creation_date')
2021-09-10 07:58:42 +00:00
@require_POST
@csrf_exempt
def handle_k8s_webhook(request):
payload = request.body
print(">>>>>>>>>>>>>>>>>>>>>>>>>>")
print(payload)
return HttpResponse(status=200)