uncloud-mravi/uncloud_pay/views.py

461 lines
17 KiB
Python
Raw Normal View History

from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic.base import TemplateView, View
2021-09-10 07:58:42 +00:00
from django.views.generic import DetailView
2020-02-27 10:21:38 +00:00
from django.shortcuts import render
2021-09-10 07:58:42 +00:00
from django.views.decorators.cache import cache_control
from django.db import transaction
2020-02-27 11:38:04 +00:00
from django.contrib.auth import get_user_model
2020-04-15 13:17:38 +00:00
from rest_framework import viewsets, mixins, permissions, status, views
from rest_framework.renderers import TemplateHTMLRenderer
2020-02-27 11:10:26 +00:00
from rest_framework.response import Response
2020-02-27 11:38:04 +00:00
from rest_framework.decorators import action
from rest_framework.reverse import reverse
from rest_framework.decorators import renderer_classes
from vat_validator import validate_vat, vies
from vat_validator.countries import EU_COUNTRY_CODES
2020-05-07 13:38:49 +00:00
from hardcopy import bytestring_to_pdf
from django.core.files.temp import NamedTemporaryFile
2021-09-10 07:58:42 +00:00
from django.views.generic.list import ListView
from django.http import FileResponse, HttpResponseRedirect
2020-05-07 13:38:49 +00:00
from django.template.loader import render_to_string
2021-09-10 07:58:42 +00:00
from wkhtmltopdf.views import PDFTemplateResponse
from copy import deepcopy
2020-02-27 10:21:38 +00:00
2020-02-27 14:50:46 +00:00
import json
import logging
2020-02-27 14:50:46 +00:00
from .models import *
from .serializers import *
2021-01-01 11:41:54 +00:00
from .selectors import *
from .utils import get_order_total_with_vat
2021-01-01 11:41:54 +00:00
2020-02-27 11:10:26 +00:00
from datetime import datetime
from vat_validator import sanitize_vat
import uncloud_pay.stripe as uncloud_stripe
from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator
from django.http import JsonResponse
import stripe
2020-02-27 10:21:38 +00:00
logger = logging.getLogger(__name__)
class PricingView(View):
def get(self, request, **args):
vat_rate = False
vat_validation_status = False
2021-08-16 08:46:59 +00:00
address = False
2021-08-24 12:25:28 +00:00
selected_country = request.GET.get('country', False)
2021-08-16 08:46:59 +00:00
if self.request.user and self.request.user.is_authenticated:
2021-08-24 12:25:28 +00:00
address = get_billing_address_for_user(self.request.user)
if address and (address.country == selected_country or not selected_country):
vat_rate = VATRate.get_vat_rate(address)
vat_validation_status = "verified" if address.vat_number_validated_on and address.vat_number_verified else False
2021-08-24 12:25:28 +00:00
elif selected_country:
vat_rate = VATRate.get_vat_rate_for_country(selected_country)
vat_validation_status = False
pricing = get_order_total_with_vat(
request.GET.get('cores'),
request.GET.get('memory'),
request.GET.get('storage'),
pricing_name = args['name'],
vat_rate = vat_rate * 100,
vat_validation_status = vat_validation_status
)
return JsonResponse(pricing)
class CardActivateView(View):
def post(self, request, **args):
card_id = request.POST.get('card_id')
if card_id:
matched_card = StripeCreditCard.objects.filter(owner=self.request.user, id=card_id).first()
matched_card.activate()
return JsonResponse({'success': 1})
else:
return JsonResponse({'error': "Please select a card"})
class RegisterCard(TemplateView):
2020-12-25 16:33:01 +00:00
template_name = "uncloud_pay/register_stripe.html"
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_context_data(self, **kwargs):
customer_id = uncloud_stripe.get_customer_id_for(self.request.user)
setup_intent = uncloud_stripe.create_setup_intent(customer_id)
context = super().get_context_data(**kwargs)
context['client_secret'] = setup_intent.client_secret
context['username'] = self.request.user.username
context['stripe_pk'] = uncloud_stripe.public_api_key
return context
2021-09-10 07:58:42 +00:00
class OrderSuccessView(DetailView):
template_name = "uncloud_pay/order_success.html"
context_object_name = "order"
model = Order
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
@cache_control(no_cache=True, must_revalidate=True, no_store=True)
def get(self, request, *args, **kwargs):
if ('order' not in request.session or ('bill_id' not in request.session)):
return HttpResponseRedirect(reverse('nextcloud:index'))
context = {
'order': self.request.session.get('order'),
'bill_id': self.request.session['bill_id'],
'balance': get_balance_for_user(self.request.user)
}
return render(request, self.template_name, context)
class InvoiceDownloadView(View):
template = 'uncloud_pay/invoice.html'
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_context_data(self, **kwargs):
context = {'base_url': f'{self.request.scheme}://{self.request.get_host()}'}
return context
def get(self, request, bill_id):
cmd_options = settings.REPORT_FORMAT
context = self.get_context_data()
bill = Bill.objects.get(owner=self.request.user, id=bill_id)
if bill:
context['bill'] = bill
context['vat_rate'] = str(round(bill.vat_rate * 100, 2))
context['tax_amount'] = round(bill.vat_rate * bill.subtotal, 2)
return PDFTemplateResponse(request=request,
template=self.template,
filename = f"bill-{bill_id}.pdf",
cmd_options= cmd_options,
footer_template= 'uncloud_pay/includes/invoice_footer.html',
context= context)
class PaymentsView(ListView):
template_name = "uncloud_pay/payments.html"
model = Payment
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_context_data(self, **kwargs):
context = super(PaymentsView, self).get_context_data(**kwargs)
context.update({
'balance': get_balance_for_user(self.request.user),
'type': self.request.GET.get('type')
})
return context
def get_queryset(self):
if self.request.GET.get('type'):
return Payment.objects.filter(owner=self.request.user, type=self.request.GET.get('type')).order_by('-timestamp')
return Payment.objects.filter(owner=self.request.user).order_by('-timestamp')
class CardsView(ListView):
template_name = "uncloud_pay/cards.html"
model = StripeCreditCard
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_context_data(self, **kwargs):
context = super(CardsView, self).get_context_data(**kwargs)
customer_id = uncloud_stripe.get_customer_id_for(self.request.user)
setup_intent = uncloud_stripe.create_setup_intent(customer_id)
context = super().get_context_data(**kwargs)
context.update({
'balance': get_balance_for_user(self.request.user),
'client_secret': setup_intent.client_secret,
'username': self.request.user.username,
'stripe_pk':uncloud_stripe.public_api_key,
'min_amount': settings.MIN_PER_TRANSACTION
})
return context
def get_queryset(self):
uncloud_stripe.sync_cards_for_user(self.request.user)
return StripeCreditCard.objects.filter(owner=self.request.user).order_by('-active')
class BillsView(ListView):
template_name = "uncloud_pay/bills.html"
model = Bill
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_context_data(self, **kwargs):
context = super(BillsView, self).get_context_data(**kwargs)
context = super().get_context_data(**kwargs)
context.update({
'balance': get_balance_for_user(self.request.user),
})
return context
def get_queryset(self):
return Bill.objects.filter(owner=self.request.user).order_by('-creation_date')
2020-12-26 10:22:51 +00:00
2020-12-28 22:35:34 +00:00
class CreditCardViewSet(mixins.RetrieveModelMixin,
mixins.UpdateModelMixin,
mixins.DestroyModelMixin,
mixins.ListModelMixin,
viewsets.GenericViewSet):
2020-12-26 10:22:51 +00:00
2020-12-28 22:35:34 +00:00
serializer_class = StripeCreditCardSerializer
permission_classes = [permissions.IsAuthenticated]
2020-12-26 10:22:51 +00:00
2020-12-28 22:35:34 +00:00
def list(self, request):
uncloud_stripe.sync_cards_for_user(self.request.user)
return super().list(request)
2020-12-26 10:22:51 +00:00
2020-12-28 22:35:34 +00:00
def get_queryset(self):
return StripeCreditCard.objects.filter(owner=self.request.user)
2020-12-29 00:43:33 +00:00
class PaymentViewSet(viewsets.ModelViewSet):
2020-12-28 22:35:34 +00:00
serializer_class = PaymentSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return Payment.objects.filter(owner=self.request.user)
2020-12-26 10:22:51 +00:00
2021-01-01 11:41:54 +00:00
class BalanceViewSet(viewsets.ViewSet):
permission_classes = [permissions.IsAuthenticated]
def list(self, request):
serializer = BalanceSerializer(data={
'balance': get_balance_for_user(self.request.user)
})
serializer.is_valid()
return Response(serializer.data)
2020-12-29 00:43:33 +00:00
class ListCards(TemplateView):
2020-12-28 22:35:34 +00:00
template_name = "uncloud_pay/list_stripe.html"
2020-12-26 10:22:51 +00:00
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
2020-12-26 10:22:51 +00:00
def get_context_data(self, **kwargs):
customer_id = uncloud_stripe.get_customer_id_for(self.request.user)
cards = uncloud_stripe.get_customer_cards(customer_id)
context = super().get_context_data(**kwargs)
context['cards'] = cards
context['username'] = self.request.user
return context
2020-03-05 09:27:33 +00:00
###
# Bills and Orders.
class BillViewSet(viewsets.ReadOnlyModelViewSet):
serializer_class = BillSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return Bill.objects.filter(owner=self.request.user)
@action(detail=False, methods=['get'])
2020-03-05 09:27:33 +00:00
def unpaid(self, request):
serializer = self.get_serializer(
Bill.get_unpaid_for(self.request.user),
many=True)
return Response(serializer.data)
2020-03-05 09:27:33 +00:00
2020-05-07 13:38:49 +00:00
@action(detail=True, methods=['get'])
def download(self, *args, **kwargs):
2020-08-01 12:05:56 +00:00
"""
Allow to download
"""
2020-05-07 13:38:49 +00:00
bill = self.get_object()
2020-10-25 12:52:36 +00:00
provider = UncloudProvider.get_provider()
2020-05-07 13:38:49 +00:00
output_file = NamedTemporaryFile()
bill_html = render_to_string("bill.html.j2", {'bill': bill})
bytestring_to_pdf(bill_html.encode('utf-8'), output_file)
response = FileResponse(output_file, content_type="application/pdf")
response['Content-Disposition'] = 'filename="{}_{}.pdf"'.format(
bill.reference, bill.uuid
)
return response
2020-03-05 09:27:33 +00:00
class OrderViewSet(viewsets.ReadOnlyModelViewSet):
serializer_class = OrderSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return Order.objects.filter(owner=self.request.user)
2021-06-20 09:51:27 +00:00
class VATRateViewSet(viewsets.ReadOnlyModelViewSet):
serializer_class = VATRateSerializer
permission_classes = [permissions.IsAuthenticated]
queryset = VATRate.objects.all()
2020-04-15 13:17:38 +00:00
class BillingAddressViewSet(mixins.CreateModelMixin,
mixins.RetrieveModelMixin,
mixins.UpdateModelMixin,
mixins.ListModelMixin,
viewsets.GenericViewSet):
permission_classes = [permissions.IsAuthenticated]
def get_serializer_class(self):
if self.action == 'update':
return UpdateBillingAddressSerializer
else:
return BillingAddressSerializer
def get_queryset(self):
return self.request.user.billing_addresses.all()
2020-04-15 13:17:38 +00:00
def create(self, request):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
# Validate VAT numbers.
country = serializer.validated_data["country"]
# We ignore empty VAT numbers.
2020-05-02 18:42:09 +00:00
if 'vat_number' in serializer.validated_data and serializer.validated_data["vat_number"] != "":
vat_number = serializer.validated_data["vat_number"]
if not validate_vat(country, vat_number):
return Response(
{'error': 'Malformed VAT number.'},
status=status.HTTP_400_BAD_REQUEST)
elif country in EU_COUNTRY_CODES:
# XXX: make a synchroneous call to a third patry API here might not be a good idea..
try:
vies_state = vies.check_vat(country, vat_number)
if not vies_state.valid:
return Response(
{'error': 'European VAT number does not exist in VIES.'},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.warning(e)
return Response(
{'error': 'Could not validate EU VAT number against VIES. Try again later..'},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
2020-04-15 13:17:38 +00:00
serializer.save(owner=request.user)
return Response(serializer.data)
###
2020-05-07 10:45:06 +00:00
# Admin stuff.
class AdminPaymentViewSet(viewsets.ModelViewSet):
serializer_class = PaymentSerializer
permission_classes = [permissions.IsAdminUser]
def get_queryset(self):
2020-02-27 11:42:24 +00:00
return Payment.objects.all()
def create(self, request):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save(timestamp=datetime.now())
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
# Bills are generated from orders and should not be created or updated by hand.
class AdminBillViewSet(BillViewSet):
serializer_class = BillSerializer
permission_classes = [permissions.IsAdminUser]
def get_queryset(self):
2020-02-27 11:42:24 +00:00
return Bill.objects.all()
@action(detail=False, methods=['get'])
def unpaid(self, request):
unpaid_bills = []
# XXX: works but we can do better than number of users + 1 SQL requests...
for user in get_user_model().objects.all():
unpaid_bills = unpaid_bills + Bill.get_unpaid_for(self.request.user)
serializer = self.get_serializer(unpaid_bills, many=True)
return Response(serializer.data)
2020-02-27 11:42:24 +00:00
2020-05-08 08:42:04 +00:00
@action(detail=False, methods=['post'])
def generate(self, request):
users = get_user_model().objects.all()
generated_bills = []
for user in users:
now = timezone.now()
generated_bills = generated_bills + Bill.generate_for(
year=now.year,
month=now.month,
user=user)
return Response(
map(lambda b: b.reference, generated_bills),
status=status.HTTP_200_OK)
class AdminOrderViewSet(mixins.ListModelMixin,
mixins.RetrieveModelMixin,
mixins.CreateModelMixin,
mixins.UpdateModelMixin,
viewsets.GenericViewSet):
2020-05-07 13:38:49 +00:00
serializer_class = OrderSerializer
2020-05-07 10:45:06 +00:00
permission_classes = [permissions.IsAdminUser]
2020-02-27 11:42:24 +00:00
2020-05-07 10:05:26 +00:00
def get_serializer(self, *args, **kwargs):
2020-05-07 13:38:49 +00:00
return self.serializer_class(*args, **kwargs, admin=True)
2020-05-07 10:05:26 +00:00
2020-02-27 11:42:24 +00:00
def get_queryset(self):
return Order.objects.all()
2020-05-08 07:31:46 +00:00
# Updates create a new order and terminate the 'old' one.
@transaction.atomic
def update(self, request, *args, **kwargs):
order = self.get_object()
partial = kwargs.pop('partial', False)
serializer = self.get_serializer(order, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
# Clone existing order for replacement.
replacing_order = deepcopy(order)
# Yes, that's how you make a new entry in DB:
# https://docs.djangoproject.com/en/3.0/topics/db/queries/#copying-model-instances
replacing_order.pk = None
for attr, value in serializer.validated_data.items():
setattr(replacing_order, attr, value)
# Save replacing order and terminate 'previous' one.
replacing_order.save()
order.replaced_by = replacing_order
order.save()
order.terminate()
return Response(replacing_order)
2020-05-08 07:31:46 +00:00
@action(detail=True, methods=['post'])
def terminate(self, request, pk):
order = self.get_object()
if order.is_terminated:
return Response(
{'error': 'Order is already terminated.'},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
order.terminate()
return Response({}, status=status.HTTP_200_OK)