680 lines
23 KiB
Python
680 lines
23 KiB
Python
import logging
|
|
from collections import OrderedDict
|
|
|
|
from django.conf import settings
|
|
from django.contrib import messages
|
|
from django.contrib.auth.mixins import LoginRequiredMixin
|
|
from django.db.models import Count
|
|
from django.http import (
|
|
Http404,
|
|
HttpResponse,
|
|
HttpResponseBadRequest,
|
|
HttpResponseRedirect,
|
|
)
|
|
from django.shortcuts import get_object_or_404
|
|
from django.urls import reverse, reverse_lazy
|
|
from django.utils import timezone
|
|
from django.utils.decorators import method_decorator
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django.views.generic import DetailView, FormView, ListView, View
|
|
from django.views.generic.base import RedirectView
|
|
from django.views.generic.detail import SingleObjectMixin
|
|
from shop.models import (
|
|
CreditNote,
|
|
EpayCallback,
|
|
EpayPayment,
|
|
Order,
|
|
OrderProductRelation,
|
|
Product,
|
|
ProductCategory,
|
|
)
|
|
from vendor.coinify.coinify_callback import CoinifyCallback
|
|
|
|
from .coinify import (
|
|
create_coinify_invoice,
|
|
process_coinify_invoice_json,
|
|
save_coinify_callback,
|
|
)
|
|
from .epay import calculate_epay_hash, validate_epay_callback
|
|
from .forms import OrderProductRelationForm, OrderProductRelationFormSet
|
|
|
|
logger = logging.getLogger("bornhack.%s" % __name__)
|
|
|
|
|
|
# Mixins
|
|
class EnsureCreditNoteHasPDFMixin(SingleObjectMixin):
|
|
model = CreditNote
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not self.get_object().pdf:
|
|
messages.error(request, "This creditnote has no PDF yet!")
|
|
return HttpResponseRedirect(reverse_lazy("shop:creditnote_list"))
|
|
|
|
return super(EnsureCreditNoteHasPDFMixin, self).dispatch(
|
|
request, *args, **kwargs
|
|
)
|
|
|
|
|
|
class EnsureUserOwnsCreditNoteMixin(SingleObjectMixin):
|
|
model = CreditNote
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
# If the user does not own this creditnote OR is not staff
|
|
if not request.user.is_staff:
|
|
if self.get_object().user != request.user:
|
|
raise Http404("CreditNote not found")
|
|
|
|
return super(EnsureUserOwnsCreditNoteMixin, self).dispatch(
|
|
request, *args, **kwargs
|
|
)
|
|
|
|
|
|
class EnsureUserOwnsOrderMixin(SingleObjectMixin):
|
|
model = Order
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
# If the user does not own this order OR is not staff
|
|
if not request.user.is_staff:
|
|
if self.get_object().user != request.user:
|
|
raise Http404("Order not found")
|
|
|
|
return super(EnsureUserOwnsOrderMixin, self).dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class EnsureUnpaidOrderMixin(SingleObjectMixin):
|
|
model = Order
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if self.get_object().paid:
|
|
messages.error(request, "This order is already paid for!")
|
|
return HttpResponseRedirect(
|
|
reverse_lazy("shop:order_detail", kwargs={"pk": self.get_object().pk})
|
|
)
|
|
|
|
return super(EnsureUnpaidOrderMixin, self).dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class EnsurePaidOrderMixin(SingleObjectMixin):
|
|
model = Order
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not self.get_object().paid:
|
|
messages.error(request, "This order is not paid for!")
|
|
return HttpResponseRedirect(
|
|
reverse_lazy("shop:order_detail", kwargs={"pk": self.get_object().pk})
|
|
)
|
|
|
|
return super(EnsurePaidOrderMixin, self).dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class EnsureClosedOrderMixin(SingleObjectMixin):
|
|
model = Order
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if self.get_object().open is not None:
|
|
messages.error(request, "This order is still open!")
|
|
return HttpResponseRedirect(
|
|
reverse_lazy("shop:order_detail", kwargs={"pk": self.get_object().pk})
|
|
)
|
|
|
|
return super(EnsureClosedOrderMixin, self).dispatch(request, *args, **kwargs)
|
|
|
|
|
|
class EnsureOrderHasProductsMixin(SingleObjectMixin):
|
|
model = Order
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if not self.get_object().products.count() > 0:
|
|
messages.error(request, "This order has no products!")
|
|
return HttpResponseRedirect(reverse_lazy("shop:index"))
|
|
|
|
return super(EnsureOrderHasProductsMixin, self).dispatch(
|
|
request, *args, **kwargs
|
|
)
|
|
|
|
|
|
class EnsureOrderIsNotCancelledMixin(SingleObjectMixin):
|
|
model = Order
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if self.get_object().cancelled:
|
|
messages.error(
|
|
request, "Order #{} is cancelled!".format(self.get_object().id)
|
|
)
|
|
return HttpResponseRedirect(reverse_lazy("shop:index"))
|
|
|
|
return super(EnsureOrderIsNotCancelledMixin, self).dispatch(
|
|
request, *args, **kwargs
|
|
)
|
|
|
|
|
|
# Shop views
|
|
class ShopIndexView(ListView):
|
|
model = Product
|
|
template_name = "shop_index.html"
|
|
context_object_name = "products"
|
|
|
|
def get_queryset(self):
|
|
queryset = super(ShopIndexView, self).get_queryset()
|
|
return queryset.available().order_by(
|
|
"category__weight", "category__name", "price", "name"
|
|
)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(ShopIndexView, self).get_context_data(**kwargs)
|
|
|
|
if "category" in self.request.GET:
|
|
category = self.request.GET.get("category")
|
|
|
|
# is this a public category
|
|
try:
|
|
categoryobj = ProductCategory.objects.get(slug=category)
|
|
if not categoryobj.public:
|
|
raise Http404("Category not found")
|
|
except ProductCategory.DoesNotExist:
|
|
raise Http404("Category not found")
|
|
|
|
# filter products by the chosen category
|
|
context["products"] = context["products"].filter(category__slug=category)
|
|
context["current_category"] = categoryobj
|
|
context["categories"] = ProductCategory.objects.annotate(
|
|
num_products=Count("products")
|
|
).filter(
|
|
num_products__gt=0,
|
|
public=True,
|
|
products__available_in__contains=timezone.now(),
|
|
)
|
|
return context
|
|
|
|
|
|
class ProductDetailView(FormView, DetailView):
|
|
model = Product
|
|
template_name = "product_detail.html"
|
|
form_class = OrderProductRelationForm
|
|
context_object_name = "product"
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
if hasattr(self, "opr"):
|
|
kwargs["instance"] = self.opr
|
|
return kwargs
|
|
|
|
def get_initial(self):
|
|
if hasattr(self, "opr"):
|
|
return {"quantity": self.opr.quantity}
|
|
return None
|
|
|
|
def get_context_data(self, **kwargs):
|
|
# If the OrderProductRelation already exists it has a primary key in the database
|
|
if self.request.user.is_authenticated and self.opr.pk:
|
|
kwargs["already_in_order"] = True
|
|
|
|
return super().get_context_data(**kwargs)
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
if not self.object.category.public:
|
|
# this product is not publicly available
|
|
raise Http404("Product not found")
|
|
|
|
if self.request.user.is_authenticated:
|
|
try:
|
|
self.opr = OrderProductRelation.objects.get(
|
|
order__user=self.request.user,
|
|
order__open__isnull=False,
|
|
product=self.object,
|
|
)
|
|
except OrderProductRelation.DoesNotExist:
|
|
self.opr = OrderProductRelation(product=self.get_object(), quantity=1)
|
|
|
|
return super(ProductDetailView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
opr = form.save(commit=False)
|
|
|
|
if not opr.pk:
|
|
opr.order, _ = Order.objects.get_or_create(
|
|
user=self.request.user, open=True, cancelled=False
|
|
)
|
|
|
|
opr.save()
|
|
|
|
messages.info(
|
|
self.request,
|
|
"{}x {} has been added to your order.".format(
|
|
opr.quantity, opr.product.name
|
|
),
|
|
)
|
|
|
|
# done
|
|
return super(ProductDetailView, self).form_valid(form)
|
|
|
|
def get_success_url(self):
|
|
return reverse("shop:index")
|
|
|
|
|
|
class OrderListView(LoginRequiredMixin, ListView):
|
|
model = Order
|
|
template_name = "order_list.html"
|
|
context_object_name = "orders"
|
|
|
|
def get_queryset(self):
|
|
queryset = super(OrderListView, self).get_queryset()
|
|
return queryset.filter(user=self.request.user).not_cancelled()
|
|
|
|
|
|
class OrderDetailView(
|
|
LoginRequiredMixin,
|
|
EnsureUserOwnsOrderMixin,
|
|
EnsureOrderHasProductsMixin,
|
|
EnsureOrderIsNotCancelledMixin,
|
|
DetailView,
|
|
):
|
|
model = Order
|
|
template_name = "order_detail.html"
|
|
context_object_name = "order"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
if "order_product_formset" not in kwargs:
|
|
kwargs["order_product_formset"] = OrderProductRelationFormSet(
|
|
queryset=OrderProductRelation.objects.filter(order=self.get_object())
|
|
)
|
|
|
|
return super().get_context_data(**kwargs)
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
order = self.get_object()
|
|
if order.open is None and not order.paid:
|
|
return HttpResponseRedirect(
|
|
reverse("shop:order_review_and_pay", kwargs={"pk": order.pk})
|
|
)
|
|
return super().get(request, *args, **kwargs)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
order = self.object
|
|
|
|
# First check if the user is removing a product from the order.
|
|
product_remove = request.POST.get("remove_product")
|
|
if product_remove:
|
|
order.orderproductrelation_set.filter(pk=product_remove).delete()
|
|
if not order.products.count() > 0:
|
|
order.mark_as_cancelled()
|
|
messages.info(request, "Order cancelled!")
|
|
return HttpResponseRedirect(reverse_lazy("shop:index"))
|
|
|
|
# Then see if the user is cancelling the order.
|
|
elif "cancel_order" in request.POST:
|
|
order.mark_as_cancelled()
|
|
messages.info(request, "Order cancelled!")
|
|
return HttpResponseRedirect(reverse_lazy("shop:index"))
|
|
|
|
# The user is not removing products or cancelling the order,
|
|
# so from now on we do stuff that require us to check stock.
|
|
# We use a formset for this to be able to display exactly
|
|
# which product is not in stock if that is the case.
|
|
else:
|
|
formset = OrderProductRelationFormSet(
|
|
request.POST, queryset=OrderProductRelation.objects.filter(order=order)
|
|
)
|
|
|
|
# If the formset is not valid it means that we cannot fulfill the order, so return and inform the user.
|
|
if not formset.is_valid():
|
|
messages.error(
|
|
request,
|
|
"Some of the products you are ordering are out of stock. Review the order and try again.",
|
|
)
|
|
return self.render_to_response(
|
|
self.get_context_data(order_product_formset=formset)
|
|
)
|
|
|
|
# No stock issues, proceed to check if the user is updating or proceeding to review and pay the order.
|
|
if "update_order" or "review_and_pay" in request.POST:
|
|
# We have already made sure the formset is valid, so just save it to update quantities.
|
|
formset.save()
|
|
|
|
order.customer_comment = request.POST.get("customer_comment") or ""
|
|
order.invoice_address = request.POST.get("invoice_address") or ""
|
|
order.save()
|
|
|
|
if "review_and_pay" in request.POST:
|
|
return HttpResponseRedirect(
|
|
reverse("shop:order_review_and_pay", kwargs={"pk": order.pk})
|
|
)
|
|
|
|
return super(OrderDetailView, self).get(request, *args, **kwargs)
|
|
|
|
|
|
class OrderReviewAndPayView(
|
|
LoginRequiredMixin,
|
|
EnsureUserOwnsOrderMixin,
|
|
EnsureOrderHasProductsMixin,
|
|
EnsureUnpaidOrderMixin,
|
|
EnsureOrderIsNotCancelledMixin,
|
|
DetailView,
|
|
):
|
|
template_name = "order_review.html"
|
|
context_object_name = "order"
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
order = self.object
|
|
|
|
payment_method = request.POST.get("payment_method")
|
|
if payment_method in order.PAYMENT_METHODS:
|
|
if not request.POST.get("accept_terms"):
|
|
messages.error(
|
|
request,
|
|
"You need to accept the general terms and conditions before you can continue!",
|
|
)
|
|
return self.render_to_response(self.get_context_data())
|
|
|
|
# Set payment method and mark the order as closed
|
|
order.payment_method = payment_method
|
|
order.open = None
|
|
order.save()
|
|
|
|
reverses = {
|
|
Order.CREDIT_CARD: reverse_lazy(
|
|
"shop:epay_form", kwargs={"pk": order.id}
|
|
),
|
|
Order.BLOCKCHAIN: reverse_lazy(
|
|
"shop:coinify_pay", kwargs={"pk": order.id}
|
|
),
|
|
Order.BANK_TRANSFER: reverse_lazy(
|
|
"shop:bank_transfer", kwargs={"pk": order.id}
|
|
),
|
|
Order.CASH: reverse_lazy("shop:cash", kwargs={"pk": order.id}),
|
|
}
|
|
|
|
return HttpResponseRedirect(reverses[payment_method])
|
|
|
|
|
|
class DownloadInvoiceView(
|
|
LoginRequiredMixin, EnsureUserOwnsOrderMixin, SingleObjectMixin, View
|
|
):
|
|
model = Order
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
"""
|
|
The file we return is determined by the orders paid status.
|
|
If the order is unpaid we return a proforma invoice PDF
|
|
If the order is paid we return a normal Invoice PDF
|
|
"""
|
|
if self.get_object().paid:
|
|
pdfobj = self.get_object().invoice
|
|
else:
|
|
pdfobj = self.get_object()
|
|
|
|
if not pdfobj.pdf:
|
|
messages.error(request, "No PDF has been generated yet!")
|
|
return HttpResponseRedirect(
|
|
reverse_lazy("shop:order_detail", kwargs={"pk": self.get_object().pk})
|
|
)
|
|
response = HttpResponse(content_type="application/pdf")
|
|
response["Content-Disposition"] = 'attachment; filename="%s"' % pdfobj.filename
|
|
response.write(pdfobj.pdf.read())
|
|
return response
|
|
|
|
|
|
class CreditNoteListView(LoginRequiredMixin, ListView):
|
|
model = CreditNote
|
|
template_name = "creditnote_list.html"
|
|
context_object_name = "creditnotes"
|
|
|
|
def get_queryset(self):
|
|
queryset = super().get_queryset()
|
|
return queryset.filter(user=self.request.user)
|
|
|
|
|
|
class DownloadCreditNoteView(
|
|
LoginRequiredMixin,
|
|
EnsureUserOwnsCreditNoteMixin,
|
|
EnsureCreditNoteHasPDFMixin,
|
|
SingleObjectMixin,
|
|
View,
|
|
):
|
|
model = CreditNote
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
response = HttpResponse(content_type="application/pdf")
|
|
response["Content-Disposition"] = (
|
|
'attachment; filename="%s"' % self.get_object().filename
|
|
)
|
|
response.write(self.get_object().pdf.read())
|
|
return response
|
|
|
|
|
|
class OrderMarkAsPaidView(LoginRequiredMixin, SingleObjectMixin, View):
|
|
|
|
model = Order
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
if not request.user.is_staff:
|
|
messages.error(request, "You do not have permissions to do that.")
|
|
return HttpResponseRedirect(reverse_lazy("shop:index"))
|
|
else:
|
|
messages.success(request, "The order has been marked as paid.")
|
|
order = self.get_object()
|
|
order.mark_as_paid()
|
|
return HttpResponseRedirect(request.META.get("HTTP_REFERER"))
|
|
|
|
|
|
# Epay views
|
|
class EpayFormView(
|
|
LoginRequiredMixin,
|
|
EnsureUserOwnsOrderMixin,
|
|
EnsureUnpaidOrderMixin,
|
|
EnsureClosedOrderMixin,
|
|
EnsureOrderHasProductsMixin,
|
|
DetailView,
|
|
):
|
|
model = Order
|
|
template_name = "epay_form.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
order = self.get_object()
|
|
context = super(EpayFormView, self).get_context_data(**kwargs)
|
|
context["merchant_number"] = settings.EPAY_MERCHANT_NUMBER
|
|
context["description"] = order.description
|
|
context["amount"] = order.total * 100
|
|
context["order_id"] = order.pk
|
|
context["accept_url"] = order.get_epay_accept_url(self.request)
|
|
context["cancel_url"] = order.get_cancel_url(self.request)
|
|
context["callback_url"] = order.get_epay_callback_url(self.request)
|
|
context["epay_hash"] = calculate_epay_hash(order, self.request)
|
|
return context
|
|
|
|
|
|
class EpayCallbackView(SingleObjectMixin, View):
|
|
model = Order
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
callback = EpayCallback.objects.create(payload=request.GET)
|
|
|
|
if "orderid" in request.GET:
|
|
query = OrderedDict(
|
|
[tuple(x.split("=")) for x in request.META["QUERY_STRING"].split("&")]
|
|
)
|
|
order = get_object_or_404(Order, pk=query.get("orderid"))
|
|
if order.pk != self.get_object().pk:
|
|
logger.error("bad epay callback, orders do not match!")
|
|
return HttpResponse(status=400)
|
|
|
|
if validate_epay_callback(query):
|
|
callback.md5valid = True
|
|
callback.save()
|
|
else:
|
|
logger.error("bad epay callback!")
|
|
return HttpResponse(status=400)
|
|
|
|
if order.paid:
|
|
# this order is already paid, perhaps we are seeing a double callback?
|
|
return HttpResponse("OK")
|
|
|
|
# epay callback is valid - has the order been paid in full?
|
|
if int(query["amount"]) == order.total * 100:
|
|
# create an EpayPayment object linking the callback to the order
|
|
EpayPayment.objects.create(
|
|
order=order, callback=callback, txnid=query.get("txnid")
|
|
)
|
|
# and mark order as paid (this will create tickets)
|
|
order.mark_as_paid(request)
|
|
else:
|
|
logger.error("valid epay callback with wrong amount detected")
|
|
else:
|
|
return HttpResponse(status=400)
|
|
|
|
return HttpResponse("OK")
|
|
|
|
|
|
class EpayThanksView(
|
|
LoginRequiredMixin, EnsureUserOwnsOrderMixin, EnsureClosedOrderMixin, DetailView
|
|
):
|
|
model = Order
|
|
template_name = "epay_thanks.html"
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if request.GET:
|
|
# epay redirects the user back to our accepturl with a long
|
|
# and ugly querystring, redirect user to the clean url
|
|
return HttpResponseRedirect(
|
|
reverse("shop:epay_thanks", kwargs={"pk": self.get_object().pk})
|
|
)
|
|
|
|
return super(EpayThanksView, self).dispatch(request, *args, **kwargs)
|
|
|
|
|
|
# Bank Transfer view
|
|
|
|
|
|
class BankTransferView(
|
|
LoginRequiredMixin,
|
|
EnsureUserOwnsOrderMixin,
|
|
EnsureUnpaidOrderMixin,
|
|
EnsureOrderHasProductsMixin,
|
|
DetailView,
|
|
):
|
|
model = Order
|
|
template_name = "bank_transfer.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(BankTransferView, self).get_context_data(**kwargs)
|
|
context["iban"] = settings.BANKACCOUNT_IBAN
|
|
context["swiftbic"] = settings.BANKACCOUNT_SWIFTBIC
|
|
context["orderid"] = self.get_object().pk
|
|
context["regno"] = settings.BANKACCOUNT_REG
|
|
context["accountno"] = settings.BANKACCOUNT_ACCOUNT
|
|
context["total"] = self.get_object().total
|
|
return context
|
|
|
|
|
|
# Cash payment view
|
|
|
|
|
|
class CashView(
|
|
LoginRequiredMixin,
|
|
EnsureUserOwnsOrderMixin,
|
|
EnsureUnpaidOrderMixin,
|
|
EnsureOrderHasProductsMixin,
|
|
DetailView,
|
|
):
|
|
model = Order
|
|
template_name = "cash.html"
|
|
|
|
|
|
# Coinify views
|
|
|
|
|
|
class CoinifyRedirectView(
|
|
LoginRequiredMixin,
|
|
EnsureUserOwnsOrderMixin,
|
|
EnsureUnpaidOrderMixin,
|
|
EnsureClosedOrderMixin,
|
|
EnsureOrderHasProductsMixin,
|
|
SingleObjectMixin,
|
|
RedirectView,
|
|
):
|
|
model = Order
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
order = self.get_object()
|
|
|
|
# create a new coinify invoice if needed
|
|
if not order.coinifyapiinvoice:
|
|
coinifyinvoice = create_coinify_invoice(order, request)
|
|
if not coinifyinvoice:
|
|
messages.error(
|
|
request,
|
|
"There was a problem with the payment provider. Please try again later",
|
|
)
|
|
return HttpResponseRedirect(
|
|
reverse_lazy(
|
|
"shop:order_detail", kwargs={"pk": self.get_object().pk}
|
|
)
|
|
)
|
|
|
|
return super(CoinifyRedirectView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_redirect_url(self, *args, **kwargs):
|
|
return self.get_object().coinifyapiinvoice.invoicejson["payment_url"]
|
|
|
|
|
|
class CoinifyCallbackView(SingleObjectMixin, View):
|
|
model = Order
|
|
|
|
@method_decorator(csrf_exempt)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(CoinifyCallbackView, self).dispatch(*args, **kwargs)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
# save callback and parse json payload
|
|
callbackobject = save_coinify_callback(request, self.get_object())
|
|
|
|
# do we have a json body?
|
|
if not callbackobject.payload:
|
|
# no, return an error
|
|
logger.error(
|
|
"unable to parse JSON body in callback for order %s"
|
|
% callbackobject.order.id
|
|
)
|
|
return HttpResponseBadRequest("unable to parse json")
|
|
|
|
# initiate SDK
|
|
sdk = CoinifyCallback(settings.COINIFY_IPN_SECRET.encode("utf-8"))
|
|
|
|
# attemt to validate the callbackc
|
|
if sdk.validate_callback(
|
|
request.body, request.META["HTTP_X_COINIFY_CALLBACK_SIGNATURE"]
|
|
):
|
|
# mark callback as valid in db
|
|
callbackobject.valid = True
|
|
callbackobject.save()
|
|
else:
|
|
logger.error("invalid coinify callback detected")
|
|
return HttpResponseBadRequest("something is fucky")
|
|
|
|
if (
|
|
callbackobject.payload["event"] == "invoice_state_change"
|
|
or callbackobject.payload["event"] == "invoice_manual_resend"
|
|
):
|
|
process_coinify_invoice_json(
|
|
invoicejson=callbackobject.payload["data"],
|
|
order=self.get_object(),
|
|
request=request,
|
|
)
|
|
return HttpResponse("OK")
|
|
else:
|
|
logger.error(
|
|
"unsupported callback event %s" % callbackobject.payload["event"]
|
|
)
|
|
return HttpResponseBadRequest("unsupported event")
|
|
|
|
|
|
class CoinifyThanksView(
|
|
LoginRequiredMixin, EnsureUserOwnsOrderMixin, EnsureClosedOrderMixin, DetailView
|
|
):
|
|
model = Order
|
|
template_name = "coinify_thanks.html"
|