- {% tournamenturl 'reg-inst-create-team' url_key as url %}
- {% blocktrans trimmed asvar text %}View invoice{% endblocktrans %}
- {% include "components/item-action.html" with icon="dollar-sign" %}
-
- {% endif %}
+
+ {% tournamenturl 'reg-inst-invoice-balance' url_key as url %}
+ {% blocktrans trimmed asvar text %}View invoice{% endblocktrans %}
+ {% include "components/item-action.html" with icon="dollar-sign" %}
+
{{ block.super }} {# this is the Vue table, which is populated with the registered participants #}
diff --git a/tabbycat/registration/templates/payment_connections.html b/tabbycat/registration/templates/payment_connections.html
new file mode 100644
index 00000000000..cfdc1ebb0d6
--- /dev/null
+++ b/tabbycat/registration/templates/payment_connections.html
@@ -0,0 +1,26 @@
+{% extends "base.html" %}
+{% load add_field_css debate_tags i18n %}
+
+{% block content %}
+
+
+
+{% endblock content %}
diff --git a/tabbycat/registration/templates/products_edit.html b/tabbycat/registration/templates/products_edit.html
new file mode 100644
index 00000000000..72ea5935960
--- /dev/null
+++ b/tabbycat/registration/templates/products_edit.html
@@ -0,0 +1,12 @@
+{% extends "base.html" %}
+{% load add_field_css debate_tags i18n %}
+
+{% block head-title %}
🏷️ {% trans "Products" %}{% endblock %}
+{% block page-title %}🏷️{% trans "Products" %}{% endblock %}
+
+{% block content %}
+
+ {% trans "Save Products" as save_text %}
+ {% include "components/formset.html" with double=True %}
+
+{% endblock content %}
diff --git a/tabbycat/registration/types.py b/tabbycat/registration/types.py
new file mode 100644
index 00000000000..819d2908528
--- /dev/null
+++ b/tabbycat/registration/types.py
@@ -0,0 +1,20 @@
+from django.db.models import TextChoices
+from django.utils.translation import gettext_lazy as _
+
+
+class Currency(TextChoices):
+ cad = 'cad', _("Canadian Dollar")
+ eur = 'eur', _("Euro")
+ gbp = 'gbp', _("British Pound")
+ usd = 'usd', _("United States Dollar")
+
+ @property
+ def minor_unit(self):
+ units = {
+ 100: (Currency.cad, Currency.eur, Currency.gbp, Currency.usd),
+ }
+ for val, currencies in units.items():
+ if self in currencies:
+ return val
+ else:
+ return ValueError
diff --git a/tabbycat/registration/urls_admin.py b/tabbycat/registration/urls_admin.py
index 8296d625244..07d95f4d74b 100644
--- a/tabbycat/registration/urls_admin.py
+++ b/tabbycat/registration/urls_admin.py
@@ -30,4 +30,32 @@
path('speakers/questions/',
views.CustomQuestionFormsetView.as_view(question_model=Speaker, success_url='reg-team-list'),
name='reg-speaker-questions'),
+ path('payments/', include([
+ path('', views.AdminPaymentsIndexView.as_view(), name='reg-payments-admin-list'),
+ path('connect/', include([
+ path('', views.PaymentConnectionView.as_view(), name='reg-payments-connect'),
+ path('stripe/', include([
+ path('refresh/', views.StripeAccountRefreshView.as_view(), name='stripe-connect-refresh'),
+ path('return/', views.StripeAccountReturnView.as_view(), name='stripe-connect-return'),
+ ])),
+ path('paypal', include([
+ path('return/', views.PayPalConnectReturnView.as_view(), name='paypal-connect-return'),
+ ])),
+ ])),
+ path('products/', views.CreateProductsView.as_view(), name='reg-products-edit'),
+ path('discount/', views.CreateDiscountView.as_view(), name='reg-create-discount'),
+ path('invoice/', include([
+ path('new/', views.CreateInvoiceView.as_view(), name='reg-create-invoice'),
+ path('
/', views.AdminInvoiceView.as_view(), name='reg-admin-invoice-view'),
+ ])),
+ path('payment/', include([
+ path('new/', views.CreatePaymentView.as_view(), name='reg-create-payment'),
+ path('/', views.AdminPaymentView.as_view(), name='reg-admin-payment-view'),
+ ])),
+ path('balance/', include([
+ path('institution//', views.AdminInstitutionBalanceSummaryView.as_view(), name='reg-admin-institution-balance'),
+ path('team//', views.AdminTeamBalanceSummaryView.as_view(), name='reg-admin-team-balance'),
+ path('person//', views.AdminPersonBalanceSummaryView.as_view(), name='reg-admin-person-balance'),
+ ])),
+ ])),
]
diff --git a/tabbycat/registration/urls_global.py b/tabbycat/registration/urls_global.py
new file mode 100644
index 00000000000..eb48657843b
--- /dev/null
+++ b/tabbycat/registration/urls_global.py
@@ -0,0 +1,12 @@
+from django.urls import include, path
+from django.views.decorators.csrf import csrf_exempt
+
+from . import views
+
+
+urlpatterns = [
+ path('webhooks/', include([
+ path('paypal/', csrf_exempt(views.PayPalWebhookView.as_view()), name='paypal-webhook'),
+ path('stripe/', csrf_exempt(views.StripeWebhookView.as_view()), name='stripe-webhook'),
+ ])),
+]
diff --git a/tabbycat/registration/urls_public.py b/tabbycat/registration/urls_public.py
index 494e60c48cc..3522b35e00e 100644
--- a/tabbycat/registration/urls_public.py
+++ b/tabbycat/registration/urls_public.py
@@ -17,6 +17,12 @@
path('team/',
views.InstitutionalCreateTeamFormView.as_view(),
name='reg-inst-create-team'),
+ path('balance/',
+ views.InstitutionBalanceSummaryView.as_view(),
+ name='reg-inst-invoice-balance'),
+ path('invoices//',
+ views.InstitutionInvoiceView.as_view(),
+ name='reg-inst-invoice'),
])),
])),
path('adjudicator/',
@@ -30,4 +36,13 @@
views.CreateSpeakerFormView.as_view(),
name='reg-create-speaker'),
])),
+ path('payments/', include([
+ path('paypal/', include([
+ path('capture/', views.PayPalCaptureOrderView.as_view(), name='reg-paypal-capture'),
+ ])),
+ path('/', include([
+ path('balance/', views.PrivateUrlBalanceSummaryView.as_view(), name='private-url-payment-balance'),
+ path('invoices//', views.PrivateUrlInvoiceView.as_view(), name='private-url-invoice'),
+ ])),
+ ])),
]
diff --git a/tabbycat/registration/views.py b/tabbycat/registration/views.py
index ee3515c8dcf..e040c545df0 100644
--- a/tabbycat/registration/views.py
+++ b/tabbycat/registration/views.py
@@ -1,29 +1,48 @@
+import base64
+import logging
+import zlib
+from decimal import Decimal
+
+import requests
+import stripe
+from cryptography import x509
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import padding
+from django.conf import settings
from django.contrib import messages
from django.contrib.contenttypes.models import ContentType
from django.contrib.postgres.forms import SimpleArrayField
-from django.db.models import Count, Prefetch, Sum
+from django.core.cache import cache
+from django.db.models import Count, Prefetch, Q, Sum
from django.forms import HiddenInput, modelformset_factory
-from django.http import HttpResponseRedirect
+from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
from django.shortcuts import get_object_or_404
from django.utils.translation import gettext as _, gettext_lazy, ngettext
-from django.views.generic.edit import FormView
+from django.views.generic.base import TemplateView, View
+from django.views.generic.edit import CreateView, FormView
from formtools.wizard.views import SessionWizardView
from actionlog.mixins import LogActionMixin
from actionlog.models import ActionLogEntry
from participants.emoji import EMOJI_NAMES
-from participants.models import Adjudicator, Coach, Speaker, Team, TournamentInstitution
+from participants.models import Adjudicator, Coach, Person, Speaker, Team, TournamentInstitution
from tournaments.mixins import PublicTournamentPageMixin, TournamentMixin
from users.permissions import Permission
-from utils.misc import reverse_tournament
+from utils.misc import redirect_tournament, reverse_tournament
from utils.mixins import AdministratorMixin
from utils.tables import TabbycatTableBuilder
from utils.views import ModelFormSetView, VueTableTemplateView
-from .forms import AdjudicatorForm, InstitutionCoachForm, ParticipantAllocationForm, SpeakerForm, TeamForm, TournamentInstitutionForm
-from .models import Invitation, Question
+from .forms import (AdjudicatorForm, CreatePaymentForm, FinishPayPalIntegrationForm, InstitutionCoachForm,
+ ParticipantAllocationForm, PayPalCaptureOrderForm, PriceItemForm, SpeakerForm, TeamForm, TournamentInstitutionForm)
+from .models import Discount, Invitation, Invoice, InvoicePayment, LineItem, Payment, PaymentConnection, PriceItem, Question
+from .payment_utils import add_item, complete_paypal_order, generate_paypal_order, get_application_fee
+from .types import Currency
from .utils import populate_invitation_url_keys
+logger = logging.getLogger(__name__)
+
class CustomQuestionFormMixin:
@@ -173,6 +192,26 @@ def get_form(self, step=None, data=None, files=None):
form.max_num = self.tournament.pref('speakers_in_team')
return form
+ def populate_cart_object(self, cart_item):
+ cart_item.team = self.object
+
+ def add_to_cart(self, team, speakers):
+ items = self.tournament.priceitem_set.filter(active=True, item_type__in=[PriceItem.ItemType.PARTICIPANT, PriceItem.ItemType.TEAM, PriceItem.ItemType.SPEAKER])
+
+ cart_items = [
+ ci for ci in
+ [
+ add_item(items, PriceItem.ItemType.PARTICIPANT, len(speakers)),
+ add_item(items, PriceItem.ItemType.TEAM, 1),
+ add_item(items, PriceItem.ItemType.SPEAKER, len(speakers)),
+ ]
+ if ci is not None and ci.quantity
+ ]
+ for ci in cart_items:
+ self.populate_cart_object(ci)
+
+ LineItem.objects.bulk_create(cart_items)
+
def done(self, form_list, form_dict, **kwargs):
team = form_dict['team'].save()
if self.tournament.pref('team_name_generator') != 'user':
@@ -202,6 +241,8 @@ def done(self, form_list, form_dict, **kwargs):
len(self.speakers),
) % {'num': len(self.speakers), 'link': invite_url})
+ self.add_to_cart(team, form_dict['speaker'])
+
messages.success(self.request, _("Your team %s has been registered!") % team.short_name)
self.log_action()
return HttpResponseRedirect(self.get_success_url())
@@ -301,9 +342,29 @@ def get_success_url(self):
def form_valid(self, form):
self.object = form.save()
+ self.add_to_cart(self.object)
messages.success(self.request, _("You have been registered as an adjudicator!"))
return super().form_valid(form)
+ def populate_cart_object(self, cart_item, adjudicator):
+ cart_item.person = adjudicator
+
+ def add_to_cart(self, adjudicator):
+ items = self.tournament.priceitem_set.filter(active=True, item_type__in=[PriceItem.ItemType.PARTICIPANT, PriceItem.ItemType.ADJUDICATOR])
+
+ cart_items = [
+ ci for ci in
+ [
+ add_item(items, PriceItem.ItemType.PARTICIPANT, 1),
+ add_item(items, PriceItem.ItemType.ADJUDICATOR, 1),
+ ]
+ if ci is not None
+ ]
+ for ci in cart_items:
+ self.populate_cart_object(ci, adjudicator)
+
+ LineItem.objects.bulk_create(cart_items)
+
class PublicCreateAdjudicatorFormView(BaseCreateAdjudicatorFormView):
@@ -385,6 +446,30 @@ def form_valid(self, form):
team.save()
return super().form_valid(form)
+ def populate_cart_object(self, cart_item, speaker):
+ if speaker.team.institution is not None:
+ if self.tournament.pref('inst_billing_standard') == 'active_participants':
+ cart_item.institution = speaker.team.institution
+ else:
+ cart_item.team = speaker.team
+ cart_item.person = speaker
+
+ def add_to_cart(self, speaker):
+ items = self.tournament.priceitem_set.filter(active=True, item_type__in=[PriceItem.ItemType.PARTICIPANT, PriceItem.ItemType.SPEAKER])
+
+ cart_items = [
+ ci for ci in
+ [
+ add_item(items, PriceItem.ItemType.PARTICIPANT, 1),
+ add_item(items, PriceItem.ItemType.SPEAKER, 1),
+ ]
+ if ci is not None
+ ]
+ for ci in cart_items:
+ self.populate_cart_object(ci, speaker)
+
+ LineItem.objects.bulk_create(cart_items)
+
class InstitutionalLandingPageView(TournamentMixin, InstitutionalRegistrationMixin, VueTableTemplateView):
@@ -431,10 +516,27 @@ def get_form_kwargs(self, step=None):
kwargs.pop('institution')
return kwargs
+ def populate_cart_object(self, cart_item):
+ cart_item.institution = self.institution
+
+ def add_to_cart(self, team, speakers):
+ if self.tournament.pref('inst_billing_standard') == 'active_participants':
+ return super().add_to_cart(team, speakers)
+
class InstitutionalCreateAdjudicatorFormView(InstitutionalRegistrationMixin, BaseCreateAdjudicatorFormView):
public_page_preference = 'institution_participant_registration'
+ def get_page_subtitle(self):
+ return _("from %s") % self.institution.name
+
+ def populate_cart_object(self, cart_item, adjudicator):
+ cart_item.team = self.institution
+
+ def add_to_cart(self, adjudicator):
+ if self.tournament.pref('inst_billing_standard') == 'active_participants':
+ return super().add_to_cart(adjudicator)
+
def handle_question_columns(table: TabbycatTableBuilder, objects, questions=None, suffix=0) -> None:
if questions is None:
@@ -632,3 +734,558 @@ def formset_valid(self, formset):
def get_success_url(self, *args, **kwargs):
return reverse_tournament(self.success_url, self.tournament)
+
+
+class BasePaymentsIndexView(TournamentMixin, VueTableTemplateView):
+ page_emoji = '💰'
+ page_title = gettext_lazy("Payment Status")
+
+ def get_table(self):
+ table = TabbycatTableBuilder(view=self, title=_("Payment Summary"))
+ return table
+
+
+class AdminPaymentsIndexView(AdministratorMixin, BasePaymentsIndexView):
+ template_name = 'answer_tables/payments.html'
+
+ def get_inst_table(self):
+ table = TabbycatTableBuilder(view=self, title=_("Institution Payments"))
+ return table
+
+ def get_team_table(self):
+ table = TabbycatTableBuilder(view=self, title=_("Team Payments"))
+ return table
+
+ def get_adj_table(self):
+ table = TabbycatTableBuilder(view=self, title=_("Adjudicator Payments"))
+ return table
+
+ def get_tables(self):
+ return [self.get_inst_table(), self.get_adj_table(), self.get_team_table()]
+
+
+class CreateProductsView(TournamentMixin, AdministratorMixin, ModelFormSetView):
+ template_name = 'products_edit.html'
+
+ formset_model = PriceItem
+ formset_factory_kwargs = {
+ 'fields': ('tournament', 'item_type', 'name', 'amount', 'active'),
+ 'extra': 2,
+ 'widgets': {
+ 'tournament': HiddenInput(),
+ },
+ 'form': PriceItemForm,
+ }
+
+ url_name = 'reg-products-edit'
+ success_url = 'reg-payments-admin-list'
+
+ def get_formset_queryset(self):
+ return super().get_formset_queryset().filter(tournament=self.tournament)
+
+ def get_formset_kwargs(self):
+ return {
+ 'initial': [{'tournament': self.tournament}] * self.formset_factory_kwargs['extra'],
+ }
+
+ def formset_valid(self, formset):
+ items = formset.save(commit=False)
+
+ stripe_connection = self.tournament.paymentconnection_set.filter(platform=PaymentConnection.Platform.STRIPE).first()
+
+ for item, fields in formset.changed_objects:
+ if stripe_connection:
+ new_data = {
+ 'name': item.name or item.get_item_type_display().capitalize(),
+ }
+ if 'amount' in fields:
+ new_price = stripe.Price.create(
+ product=item.stripe_product_id,
+ currency=item.currency.lower(),
+ unit_amount=item.amount * Currency[item.currency].minor_unit,
+ api_key=settings.STRIPE_PRIVATE_API_KEY,
+ stripe_account=stripe_connection.external_id,
+ )
+ new_data['default_price'] = new_price['id']
+ item.stripe_price_id = new_price['id']
+
+ stripe.Product.modify(
+ item.stripe_product_id,
+ **new_data,
+ api_key=settings.STRIPE_PRIVATE_API_KEY,
+ stripe_account=stripe_connection.external_id,
+ )
+ item.save()
+
+ for item in formset.new_objects:
+ item.tournament = self.tournament # Even with the tournament in the form, avoid it being changed
+ item.currency = self.tournament.pref('billing_currency')
+
+ if stripe_connection:
+ stripe_product = stripe.Product.create(
+ name=item.name or item.get_item_type_display().capitalize(),
+ default_price_data={
+ 'currency': item.currency.lower(),
+ 'unit_amount': item.amount * Currency[item.currency].minor_unit,
+ },
+ api_key=settings.STRIPE_PRIVATE_API_KEY,
+ stripe_account=stripe_connection.external_id,
+ )
+ item.stripe_product_id = stripe_product['id']
+ item.stripe_price_id = stripe_product['default_price']
+ item.save()
+
+ if items:
+ message = ngettext("Saved item: %(list)s",
+ "Saved items: %(list)s",
+ len(items),
+ ) % {'list': ", ".join(item.name or item.get_item_type_display().capitalize() for item in items)}
+ messages.success(self.request, message)
+ else:
+ messages.success(self.request, _("No changes were made to the items."))
+ if "add_more" in self.request.POST:
+ return redirect_tournament(self.url_name, self.tournament)
+ return HttpResponseRedirect(self.get_success_url())
+
+ def get_success_url(self, *args, **kwargs):
+ return reverse_tournament(self.success_url, self.tournament)
+
+
+class PaymentConnectionView(TournamentMixin, AdministratorMixin, TemplateView):
+ template_name = 'payment_connections.html'
+
+ def get_context_data(self, **kwargs):
+ kwargs['has_stripe_connection'] = self.tournament.paymentconnection_set.filter(platform=PaymentConnection.Platform.STRIPE).exists()
+ return super().get_context_data(**kwargs)
+
+ def post(self, request, *args, **kwargs):
+ match request.POST.get('platform'):
+ case 'stripe':
+ return self.connect_stripe()
+ case 'paypal':
+ return self.connect_paypal()
+
+ def connect_stripe(self):
+ if not (connection := self.tournament.paymentconnection_set.filter(platform=PaymentConnection.Platform.STRIPE).first()):
+ account = stripe.Account.create(api_key=settings.STRIPE_PRIVATE_API_KEY)
+ connection = PaymentConnection(tournament=self.tournament, platform=PaymentConnection.Platform.STRIPE, external_id=account['id'], status=PaymentConnection.Status.PENDING)
+ connection.save()
+
+ account_link = stripe.AccountLink.create(
+ api_key=settings.STRIPE_PRIVATE_API_KEY,
+ account=connection.external_id,
+ refresh_url=self.request.build_absolute_uri(reverse_tournament('stripe-connect-refresh', self.tournament)),
+ return_url=self.request.build_absolute_uri(reverse_tournament('stripe-connect-return', self.tournament)),
+ type="account_onboarding",
+ )
+ return HttpResponseRedirect(account_link['url'])
+
+ def connect_paypal(self):
+ if not (connection := self.tournament.paymentconnection_set.filter(platform=PaymentConnection.Platform.PAYPAL).first()):
+ connection = PaymentConnection(
+ tournament=self.tournament,
+ platform=PaymentConnection.Platform.PAYPAL,
+ external_id=f'temp_pp_{self.tournament.id}',
+ status=PaymentConnection.Status.PENDING,
+ )
+ connection.save()
+
+ req = requests.post('https://api-m.sandbox.paypal.com/v2/customer/partner-referrals', headers={'Authorization': 'Bearer x'}, json={
+ "tracking_id": str(connection.id),
+ "operations": [{
+ "operation": "API_INTEGRATION",
+ "api_integration_preference": {
+ "rest_api_integration": {
+ "integration_method": "PAYPAL",
+ "integration_type": "THIRD_PARTY",
+ "third_party_details": {
+ "features": [
+ "PAYMENT",
+ "REFUND",
+ ],
+ },
+ },
+ },
+ }],
+ "products": [
+ "EXPRESS_CHECKOUT",
+ ],
+ "legal_consents": [{
+ "type": "SHARE_DATA_CONSENT",
+ "granted": True,
+ }],
+ "partner_config_override": {
+ 'return_url': self.request.build_absolute_uri(reverse_tournament('paypal-connect-return', self.tournament)),
+ },
+ })
+ return HttpResponseRedirect(next(link['url'] for link in req.json()['links'] if link['rel'] == 'action_url'))
+
+
+class StripeAccountRefreshView(TournamentMixin, AdministratorMixin, View):
+ def get(self, request, *args, **kwargs):
+ messages.error(request, _("Your Stripe could not be linked. Please try again."))
+ return HttpResponseRedirect(reverse_tournament('reg-payments-connect', self.tournament))
+
+
+class StripeAccountReturnView(TournamentMixin, AdministratorMixin, View):
+ def get(self, request, *args, **kwargs):
+ messages.success(request, _("Your Stripe account has been linked"))
+ return HttpResponseRedirect(reverse_tournament('reg-payments-admin-list', self.tournament))
+
+
+class PayPalConnectReturnView(TournamentMixin, AdministratorMixin, FormView):
+ form_class = FinishPayPalIntegrationForm
+
+ def get_initial(self):
+ initial = super().get_initial()
+ initial['tracking_id'] = self.request.GET.get('merchantId')
+ initial['merchant_id'] = self.request.GET.get('merchantIdInPayPal')
+ return initial
+
+ def get_success_url(self):
+ return reverse_tournament('reg-payments-admin-list', self.tournament)
+
+ def form_valid(self, form):
+ connection = PaymentConnection.objects.get(platform=PaymentConnection.Platform.PAYPAL, id=form.cleaned_data['tracking_id'])
+ connection.status = PaymentConnection.Status.CONNECTED
+ connection.external_id = form.cleaned_data['merchant_id']
+ connection.save()
+
+ messages.success(self.request, _("Your PayPal account has been linked"))
+ return super.form_valid(form)
+
+
+class StripeWebhookView(View):
+ def post(self, request, *args, **kwargs):
+ event = None
+ account = request.headers['STRIPE_ACCOUNT']
+
+ try:
+ event = stripe.Webhook.construct_event(
+ request.body,
+ request.headers['STRIPE_SIGNATURE'],
+ settings.STRIPE_WEBHOOK_SECRET,
+ api_key=settings.STRIPE_PRIVATE_API_KEY,
+ stripe_account=account,
+ )
+ except ValueError:
+ return HttpResponse(status=400)
+ except stripe.error.SignatureVerificationError:
+ return HttpResponse(status=400)
+
+ # Handle the event
+ match event.type:
+ case 'account.updated':
+ connections = PaymentConnection.objects.filter(platform=PaymentConnection.Platform.STRIPE, external_id=event.data.object['id'])
+ if len(event.data.object['requirements']['past_due']) > 1:
+ connections.update(status=PaymentConnection.Status.DISCONNECTED)
+ else:
+ connections.update(status=PaymentConnection.Status.CONNECTED)
+ case 'checkout.session.completed':
+ pass
+ case 'checkout.session.expired':
+ pass
+ case _:
+ print('Unhandled event type {}'.format(event['type']))
+
+ return HttpResponse(status=200)
+
+
+class PayPalWebhookView(View):
+ def post(self, request, *args, **kwargs):
+ # data = request.data
+
+ if not PayPalWebhookView.verify_signature(request):
+ return HttpResponse(status=400)
+
+ match request.data.get("event_type"):
+ case 'MERCHANT.ONBOARDING.COMPLETED':
+ self.handle_onboarding_completed(request.data)
+ case 'MERCHANT.PARTNER-CONSENT.REVOKED':
+ pass
+
+ return HttpResponse(status=200)
+
+ @staticmethod
+ def get_certificate(url):
+ return cache.get_or_set(url, requests.get(url).text)
+
+ @staticmethod
+ def verify_signature(request):
+ # Create the validation message
+ transmission_id = request.headers.get("paypal-transmission-id")
+ timestamp = request.headers.get("paypal-transmission-time")
+ crc = zlib.crc32(request.body)
+ message = f"{transmission_id}|{timestamp}|{settings.PAYPAL_WEBHOOK_ID}|{crc}"
+
+ # Decode the base64-encoded signature from the header
+ signature = base64.b64decode(request.headers.get("paypal-transmission-sig"))
+
+ # Load the certificate and extract the public key
+ certificate = PayPalWebhookView.get_certificate(request.headers.get("paypal-cert-url"))
+ cert = x509.load_pem_x509_certificate(certificate.encode("utf-8"), default_backend())
+ public_key = cert.public_key()
+
+ # Validate the message using the signature
+ try:
+ public_key.verify(signature, message.encode("utf-8"), padding.PKCS1v15(), hashes.SHA256())
+ return True
+ except Exception:
+ # Validation failed
+ return False
+
+ def handle_onboarding_completed(self, data):
+ connection = PaymentConnection.objects.get(platform=PaymentConnection.Platform.PAYPAL, external_id=data['resource']['merchant_id'])
+ connection.status = PaymentConnection.Status.CONNECTED
+ connection.save()
+
+
+class CreateInvoiceView(TournamentMixin, AdministratorMixin, CreateView):
+ pass
+
+
+class BaseInvoiceView(TournamentMixin, VueTableTemplateView):
+
+ def get_queryset(self):
+ return self.tournament.invoice_set.prefetch_related('lineitem_set', 'linediscount_set__discount', 'invoicepayment_set__payment')
+
+ @property
+ def invoice(self):
+ return get_object_or_404(self.get_queryset(), pk=self.kwargs['invoice_id'])
+
+ def get_items_table(self):
+ items = self.invoice.lineitem_set.all()
+
+ table = TabbycatTableBuilder(view=self, title=_("Items"))
+ table.add_column({'key': 'item', 'title': _("Item")}, [li.item.name for li in items])
+ table.add_column({'key': 'quantity', 'title': _("Quantity")}, [li.quantity for li in items])
+ table.add_column({'key': 'price', 'title': _("Price")}, [li.item.amount * li.quantity for li in items])
+ return table
+
+ def get_discounts_table(self):
+ discounts = self.invoice.linediscount_set.all()
+
+ table = TabbycatTableBuilder(view=self, title=_("Discounts"))
+ table.add_column({'key': 'note', 'title': _("Note")}, [d.note for d in discounts])
+ table.add_column({'key': 'amount', 'title': _("Amount")}, [d.amount for d in discounts])
+ return table
+
+ def get_payments_table(self):
+ payments = self.invoice.invoicepayment_set.all()
+
+ table = TabbycatTableBuilder(view=self, title=_("Payments"))
+ table.add_column({'key': 'timestamp', 'title': _("Date")}, [p.payment.timestamp for p in payments])
+ table.add_column({'key': 'reference', 'title': _("Reference")}, [p.payment.reference for p in payments])
+ table.add_column({'key': 'status', 'title': _("Status")}, [p.payment.get_status_display() for p in payments])
+ table.add_column({'key': 'amount', 'title': _("Amount")}, [p.amount for p in payments])
+ return table
+
+ def get_tables(self):
+ [self.get_items_table(), self.get_discounts_table(), self.get_payments_table()]
+
+
+class InstitutionInvoiceView(InstitutionalRegistrationMixin, BaseInvoiceView):
+ def get_queryset(self):
+ return super().get_queryset().filter(institution=self.institution)
+
+
+class PrivateUrlInvoiceView(BaseInvoiceView):
+ def get_queryset(self):
+ return super().get_queryset().filter(Q(team__speaker__url_key=self.kwargs['url_key']) | Q(person__url_key=self.kwargs['url_key']))
+
+
+class AdminInvoiceView(AdministratorMixin, BaseInvoiceView):
+ view_permission = Permission.VIEW_INVOICES
+
+
+class BasePaymentView(TournamentMixin, VueTableTemplateView):
+ def get_table(self):
+ table = TabbycatTableBuilder(view=self, title=_("Invoices"))
+ return table
+
+
+class AdminPaymentView(AdministratorMixin, BasePaymentView):
+ view_permission = Permission.VIEW_PAYMENTS
+
+
+class CreateDiscountView(TournamentMixin, AdministratorMixin, CreateView):
+ model = Discount
+
+
+class CreatePaymentView(TournamentMixin, AdministratorMixin, CreateView):
+ model = Payment
+
+
+class BaseBalanceSummaryView(TournamentMixin, VueTableTemplateView, FormView):
+ template_name = 'account_balance.html'
+ form_class = CreatePaymentForm
+
+ tables_orientation = 'rows'
+
+ def dispatch(self, request, *args, **kwargs):
+ self.line_items = LineItem.objects.filter(item__tournament=self.tournament, **self.participant_kwargs)
+ self.invoices = self.tournament.invoice_set.filter(**self.participant_kwargs)
+ self.discounts = self.tournament.discount_set.filter(**self.participant_kwargs)
+ self.payments = Payment.objects.filter(tournament=self.tournament, status=Payment.Status.COMPLETED, **self.participant_kwargs)
+ self.line_items_total = sum([li.item.amount * li.quantity for li in self.line_items])
+ self.amount_total = self.line_items_total - sum([d.amount for d in self.discounts]) - sum([p.amount for p in self.payments])
+ return super().dispatch(request, *args, **kwargs)
+
+ def get_context_data(self, **kwargs):
+ kwargs['total'] = self.amount_total
+ return super().get_context_data(**kwargs)
+
+ def get_invoices_table(self):
+ table = TabbycatTableBuilder(view=self, title=_("Invoices"))
+ table.add_column({'key': 'name', 'title': _("ID")}, [i.pk for i in self.invoices])
+ table.add_column({'key': 'status', 'title': _("Status")}, [i.get_status_display() for i in self.invoices])
+ table.add_column({'key': 'total', 'title': _("Total")}, [i.amount for i in self.invoices])
+ table.add_column({'key': 'due', 'title': _("Amount Due")}, [i.amount - i.amount_paid for i in self.invoices])
+ return table
+
+ def get_items_table(self):
+ table = TabbycatTableBuilder(view=self, title=_("Payment Summary"))
+ table.add_column({'key': 'item', 'title': _("Item")}, [li.item.name or li.item.get_item_type_display().capitalize() for li in self.line_items])
+ table.add_column({'key': 'quantity', 'title': _("Quantity")}, [li.quantity for li in self.line_items])
+ table.add_column({'key': 'invoice', 'title': _("Invoice")}, [li.invoice_id for li in self.line_items])
+ table.add_column({'key': 'price', 'title': _("Price")}, [li.item.amount * li.quantity for li in self.line_items])
+ return table
+
+ def get_discounts_table(self):
+ table = TabbycatTableBuilder(view=self, title=_("Discounts"))
+ table.add_column({'key': 'name', 'title': _("Name")}, [d.note for d in self.discounts])
+ table.add_column({'key': 'amount', 'title': _("Amount")}, [d.amount for d in self.discounts])
+ return table
+
+ def get_tables(self):
+ return [self.get_invoices_table(), self.get_items_table(), self.get_discounts_table()]
+
+ def get_initial(self):
+ initial = super().get_initial()
+ initial['amount'] = self.amount_total
+ return initial
+
+ def get_form_kwargs(self):
+ kwargs = super().get_form_kwargs()
+ kwargs['currency'] = Currency[self.tournament.pref('billing_currency')]
+ kwargs['max_value'] = self.amount_total
+ return kwargs
+
+ def form_valid(self, form):
+ currency = Currency[self.tournament.pref('billing_currency')]
+ payment = Payment.objects.create(
+ reference='',
+ tournament=self.tournament,
+ amount=form.cleaned_data['amount'],
+ currency=currency,
+ method=Payment.Method.OTHER,
+ status=Payment.Status.PENDING,
+ **self.participant_kwargs,
+ )
+ if new_invoice_items := self.line_items.filter(invoice=None):
+ invoice = Invoice(
+ amount=sum(ii.item.amount * ii.quantity for ii in new_invoice_items),
+ currency=currency,
+ tournament=self.tournament,
+ status=Invoice.Status.OPEN,
+ amount_paid=Decimal('0'),
+ **self.participant_kwargs,
+ )
+ invoice.save()
+ InvoicePayment.objects.create(payment=payment, invoice=invoice, amount=invoice.amount, currency=currency)
+ new_invoice_items.update(invoice=invoice)
+
+ payment_connections = {pc.platform: pc for pc in self.tournament.paymentconnection_set.filter(status=PaymentConnection.Status.CONNECTED)}
+ if PaymentConnection.Platform.STRIPE in payment_connections:
+ payment.method = Payment.Method.STRIPE
+ payment.save()
+ return self.create_stripe_checkout(payment_connections[PaymentConnection.Platform.STRIPE], form.cleaned_data['amount'], payment)
+ if PaymentConnection.Platform.PAYPAL in payment_connections:
+ payment.method = Payment.Method.PAYPAL
+ payment.save()
+ return self.create_paypal_checkout(payment_connections[PaymentConnection.Platform.PAYPAL], form.cleaned_data['amount'], payment)
+
+ def create_stripe_checkout(self, connection, amount, payment):
+ use_currency = Currency[self.tournament.pref('billing_currency')]
+ discounts = []
+ if amount < self.line_items_total:
+ coupon = stripe.Coupon.create(
+ name='For partial payment / discounts',
+ amount_off=(self.line_items_total - amount) * use_currency.minor_unit,
+ currency=self.tournament.pref('billing_currency'),
+ max_redemptions=1,
+ api_key=settings.STRIPE_PRIVATE_API_KEY,
+ stripe_account=connection.external_id,
+ )
+ discounts.append({'coupon': coupon['id']})
+
+ session = stripe.checkout.Session.create(
+ success_url=self.request.build_absolute_uri(),
+ line_items=[{"price": li.item.stripe_price_id, "quantity": li.quantity} for li in self.line_items],
+ discounts=discounts,
+ mode="payment",
+ client_reference_id=payment.id,
+ payment_intent_data={'application_fee_amount': int(get_application_fee(amount, use_currency) * use_currency.minor_unit)},
+ api_key=settings.STRIPE_PRIVATE_API_KEY,
+ stripe_account=connection.external_id,
+ )
+ return HttpResponseRedirect(session['url'])
+
+ def create_paypal_checkout(self, connection, amount, payment):
+ return JsonResponse(generate_paypal_order(connection, amount, self.line_items, payment))
+
+
+class InstitutionBalanceSummaryView(BaseBalanceSummaryView):
+
+ def get_t_institution(self):
+ ti = TournamentInstitution.objects.filter(tournament=self.tournament, coach__url_key=self.kwargs['url_key']).select_related('institution')
+ return get_object_or_404(ti)
+
+ @property
+ def institution(self):
+ return self.get_t_institution().institution
+
+ @property
+ def participant_kwargs(self):
+ return {'institution': self.institution}
+
+
+class AdminInstitutionBalanceSummaryView(AdministratorMixin, BaseBalanceSummaryView):
+ view_permission = Permission.VIEW_INVOICES
+
+ @property
+ def participant_kwargs(self):
+ return {'institution': self.kwargs['pk']}
+
+
+class AdminTeamBalanceSummaryView(AdministratorMixin, BaseBalanceSummaryView):
+ view_permission = Permission.VIEW_INVOICES
+
+ @property
+ def participant_kwargs(self):
+ return {'team': self.kwargs['pk']}
+
+
+class AdminPersonBalanceSummaryView(AdministratorMixin, BaseBalanceSummaryView):
+ view_permission = Permission.VIEW_INVOICES
+
+ @property
+ def participant_kwargs(self):
+ return {'person': self.kwargs['pk']}
+
+
+class PrivateUrlBalanceSummaryView(BaseBalanceSummaryView):
+ @property
+ def participant_kwargs(self):
+ person = Person.objects.filter(url_key=self.kwargs['url_key']).select_related('speaker__team', 'adjudicator').get()
+ if person.speaker is not None:
+ return {'team': person.speaker.team}
+ return {'person': person}
+
+
+class PayPalCaptureOrderView(TournamentMixin, FormView):
+ form_class = PayPalCaptureOrderForm
+
+ def form_valid(self, form):
+ connection = self.tournament.paymentconnection_set.filter(status=PaymentConnection.Status.CONNECTED, platform=PaymentConnection.Platform.STRIPE)
+ return JsonResponse(complete_paypal_order(connection, form.cleaned_data['order_id']))
diff --git a/tabbycat/results/models.py b/tabbycat/results/models.py
index 6baac407a2f..bfd002ca96b 100644
--- a/tabbycat/results/models.py
+++ b/tabbycat/results/models.py
@@ -1,18 +1,16 @@
import logging
-from threading import Lock
-from django.conf import settings
from django.core.exceptions import ValidationError
from django.db import models
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from motions.models import RoundMotion
-from tournaments.models import Tournament
from utils.misc import badge_datetime_format, reverse_tournament
from utils.models import UniqueConstraint
from .result import DebateResult
+from .submission_model import Submission
from .utils import readable_ballotsub_result
logger = logging.getLogger(__name__)
@@ -22,87 +20,6 @@ class ScoreField(models.FloatField):
pass
-class Submission(models.Model):
- """Abstract base class to provide functionality common to different
- types of submissions.
-
- The unique_together class attribute of the Meta class MUST be set in
- all subclasses."""
-
- class Submitter(models.TextChoices):
- TABROOM = 'T', _("Tab room")
- PUBLIC = 'P', _("Public")
- AUTOMATION = 'A', _("Automation")
-
- timestamp = models.DateTimeField(auto_now_add=True,
- verbose_name=_("timestamp"))
- version = models.PositiveIntegerField(
- verbose_name=_("version"))
- submitter_type = models.CharField(max_length=1, choices=Submitter.choices,
- verbose_name=_("submitter type"))
- confirmed = models.BooleanField(default=False,
- verbose_name=_("confirmed"))
-
- # relevant for private URL submissions
- private_url = models.BooleanField(default=False,
- verbose_name=_("from private URL"))
- participant_submitter = models.ForeignKey('participants.Person', models.PROTECT,
- blank=True, null=True, related_name="%(app_label)s_%(class)s_participant_submitted",
- verbose_name=_("from participant"))
-
- # only relevant if submitter was in tab room
- submitter = models.ForeignKey(settings.AUTH_USER_MODEL, models.PROTECT,
- blank=True, null=True, related_name="%(app_label)s_%(class)s_submitted",
- verbose_name=_("submitter"))
- confirmer = models.ForeignKey(settings.AUTH_USER_MODEL, models.PROTECT,
- blank=True, null=True, related_name="%(app_label)s_%(class)s_confirmed",
- verbose_name=_("confirmer"))
- confirm_timestamp = models.DateTimeField(blank=True, null=True,
- verbose_name=_("confirm timestamp"))
- ip_address = models.GenericIPAddressField(blank=True, null=True,
- verbose_name=_("IP address"))
-
- save_lock = Lock()
-
- class Meta:
- abstract = True
-
- @property
- def _unique_filter_args(self):
- return dict((arg, getattr(self, arg)) for arg in self._meta.constraints[0].fields
- if arg != 'version')
-
- def _unique_unconfirm_args(self):
- return self._unique_filter_args
-
- def save(self, *args, **kwargs):
- # Use a lock to protect against the possibility that two submissions do this
- # at the same time and get the same version number or both be confirmed.
- with self.save_lock:
-
- # Assign the version field to one more than the current maximum version.
- if self.pk is None:
- existing = self.__class__.objects.filter(**self._unique_filter_args)
- if existing.exists():
- self.version = existing.aggregate(models.Max('version'))['version__max'] + 1
- else:
- self.version = 1
-
- # Check for uniqueness.
- if self.confirmed:
- unconfirmed = self.__class__.objects.filter(confirmed=True,
- **self._unique_unconfirm_args()).exclude(pk=self.pk).update(confirmed=False)
- if unconfirmed > 0:
- logger.info("Unconfirmed %d %s so that %s could be confirmed", unconfirmed, self._meta.verbose_name_plural, self)
-
- super(Submission, self).save(*args, **kwargs)
-
- def clean(self):
- super().clean()
- if self.submitter_type == self.Submitter.TABROOM and self.submitter is None:
- raise ValidationError(_("A tab room ballot must have a user associated."))
-
-
class BallotSubmission(Submission):
"""Represents a single submission of ballots for a debate.
(Not a single motion, but a single submission of all ballots for a debate.)"""
@@ -388,7 +305,7 @@ def clean(self):
class ScoreCriterion(models.Model):
"""Score criterion for speaker score"""
- tournament = models.ForeignKey(Tournament, models.CASCADE,
+ tournament = models.ForeignKey('tournaments.Tournament', models.CASCADE,
verbose_name=_("tournament"))
name = models.CharField(max_length=20,
verbose_name=("name"))
diff --git a/tabbycat/results/submission_model.py b/tabbycat/results/submission_model.py
new file mode 100644
index 00000000000..830dd430326
--- /dev/null
+++ b/tabbycat/results/submission_model.py
@@ -0,0 +1,92 @@
+import logging
+from threading import Lock
+
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+logger = logging.getLogger(__name__)
+
+
+class Submission(models.Model):
+ """Abstract base class to provide functionality common to different
+ types of submissions.
+
+ The unique_together class attribute of the Meta class MUST be set in
+ all subclasses."""
+
+ class Submitter(models.TextChoices):
+ TABROOM = 'T', _("Tab room")
+ PUBLIC = 'P', _("Public")
+ AUTOMATION = 'A', _("Automation")
+
+ timestamp = models.DateTimeField(auto_now_add=True,
+ verbose_name=_("timestamp"))
+ version = models.PositiveIntegerField(
+ verbose_name=_("version"))
+ submitter_type = models.CharField(max_length=1, choices=Submitter.choices,
+ verbose_name=_("submitter type"))
+ confirmed = models.BooleanField(default=False,
+ verbose_name=_("confirmed"))
+
+ # relevant for private URL submissions
+ private_url = models.BooleanField(default=False,
+ verbose_name=_("from private URL"))
+ participant_submitter = models.ForeignKey('participants.Person', models.PROTECT,
+ blank=True, null=True, related_name="%(app_label)s_%(class)s_participant_submitted",
+ verbose_name=_("from participant"))
+
+ # only relevant if submitter was in tab room
+ submitter = models.ForeignKey(settings.AUTH_USER_MODEL, models.PROTECT,
+ blank=True, null=True, related_name="%(app_label)s_%(class)s_submitted",
+ verbose_name=_("submitter"))
+ confirmer = models.ForeignKey(settings.AUTH_USER_MODEL, models.PROTECT,
+ blank=True, null=True, related_name="%(app_label)s_%(class)s_confirmed",
+ verbose_name=_("confirmer"))
+ confirm_timestamp = models.DateTimeField(blank=True, null=True,
+ verbose_name=_("confirm timestamp"))
+ ip_address = models.GenericIPAddressField(blank=True, null=True,
+ verbose_name=_("IP address"))
+
+ save_lock = Lock()
+
+ class Meta:
+ abstract = True
+
+ @property
+ def _unique_filter_args(self):
+ if not self._meta.constraints:
+ return {}
+ return dict((arg, getattr(self, arg)) for arg in self._meta.constraints[0].fields
+ if arg != 'version')
+
+ def _unique_unconfirm_args(self):
+ return self._unique_filter_args
+
+ def save(self, *args, **kwargs):
+ # Use a lock to protect against the possibility that two submissions do this
+ # at the same time and get the same version number or both be confirmed.
+ with self.save_lock:
+
+ # Assign the version field to one more than the current maximum version.
+ if self.pk is None:
+ existing = self.__class__.objects.filter(**self._unique_filter_args)
+ if existing.exists():
+ self.version = existing.aggregate(models.Max('version'))['version__max'] + 1
+ else:
+ self.version = 1
+
+ # Check for uniqueness.
+ if self.confirmed:
+ unconfirmed = self.__class__.objects.filter(confirmed=True,
+ **self._unique_unconfirm_args()).exclude(pk=self.pk).update(confirmed=False)
+ if unconfirmed > 0:
+ logger.info("Unconfirmed %d %s so that %s could be confirmed", unconfirmed, self._meta.verbose_name_plural, self)
+
+ super(Submission, self).save(*args, **kwargs)
+
+ def clean(self):
+ super().clean()
+ if self.submitter_type == self.Submitter.TABROOM and self.submitter is None:
+ raise ValidationError(_("A tab room ballot must have a user associated."))
diff --git a/tabbycat/settings/core.py b/tabbycat/settings/core.py
index 497f0c1ba46..953204e56e2 100644
--- a/tabbycat/settings/core.py
+++ b/tabbycat/settings/core.py
@@ -1,4 +1,5 @@
import os
+from decimal import Decimal
from django.contrib.messages import constants as messages
from django.utils.translation import gettext_lazy as _
@@ -404,3 +405,22 @@
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
+
+# ==============================================================================
+# Payment processors for registration
+# ==============================================================================
+
+STRIPE_PUBLIC_API_KEY = os.environ.get('STRIPE_PUBLIC_API_KEY')
+STRIPE_PRIVATE_API_KEY = os.environ.get('STRIPE_PRIVATE_API_KEY')
+STRIPE_WEBHOOK_SECRET = os.environ.get('STRIPE_WEBHOOK_SECRET')
+
+PAYPAL_CLIENT_ID = os.environ.get('PAYPAL_CLIENT_ID')
+PAYPAL_CLIENT_SECRET = os.environ.get('PAYPAL_CLIENT_SECRET')
+PAYPAL_BUILD_NOTATION_CODE = os.environ.get('PAYPAL_BN_CODE')
+PAYPAL_WEBHOOK_ID = os.environ.get('PAYPAL_WEBHOOK_ID')
+
+PAYMENT_FEE_PERCENTAGE = Decimal('0')
+PAYMENT_FEE_FIXED = {
+ 'cad': Decimal('0'),
+ 'usd': Decimal('0'),
+}
diff --git a/tabbycat/templates/nav/admin_nav.html b/tabbycat/templates/nav/admin_nav.html
index 8f5f34f39b8..ed137177440 100644
--- a/tabbycat/templates/nav/admin_nav.html
+++ b/tabbycat/templates/nav/admin_nav.html
@@ -132,6 +132,10 @@
class="list-group-item" data-parent="#registrationh">
{% trans "Adjudicators" %}
+
+ {% trans "Payments" %}
+