Bernard Siebens
127d0e338e
Refactored club detail templates to modularize common UI components. Standardized layout, interactions, and styles across admin, billing, and feature cards for consistency and reusability.
554 lines
22 KiB
Python
554 lines
22 KiB
Python
from contextlib import contextmanager
|
|
|
|
from django.contrib import messages
|
|
from django.contrib.auth import get_user_model
|
|
from django.db.models import Count
|
|
from django.http import HttpResponse
|
|
from django.shortcuts import get_object_or_404, redirect
|
|
from django.urls import reverse
|
|
from django.utils import timezone
|
|
from django.utils.formats import date_format
|
|
from django.views.generic import CreateView, DetailView, FormView, ListView, TemplateView, UpdateView, View
|
|
from waffle import get_waffle_flag_model, get_waffle_switch_model
|
|
|
|
from billing.models import Due, Tier, TierPrice
|
|
from billing.services import BillingError
|
|
from billing.services.dues import next_period_start, open_period, reactivate, record_payment, subscribe, waive
|
|
from billing.services.invoices import invoice_pdf, issue_invoice
|
|
from club.models import Club, ClubRole
|
|
from features.models import Maintenance
|
|
|
|
from .forms import ClubAdminForm, ClubForm, DuePaymentForm, FlagForm, MaintenanceForm, OpenPeriodForm, PlatformAdminForm, SubscriptionForm, TierForm, TierPriceForm
|
|
from .mixins import PlatformStaffRequiredMixin, PlatformSuperuserRequiredMixin, RedirectOnInvalidMixin
|
|
from .services.admins import grant_club_admin, revoke_club_admin
|
|
from .services.platform_admins import (
|
|
PlatformAdminError,
|
|
grant_platform_access,
|
|
platform_admins,
|
|
revoke_platform_access,
|
|
set_platform_access,
|
|
)
|
|
from .services.statistics import club_attention, club_charts, club_statistics, clubs_with_health, flag_adoption, flags_for_club, onboarding_funnel, platform_attention, platform_charts, platform_totals
|
|
|
|
Flag = get_waffle_flag_model()
|
|
Switch = get_waffle_switch_model()
|
|
|
|
|
|
@contextmanager
|
|
def suppress_billing_errors(request):
|
|
"""Turn a BillingError into an error message rather than letting it propagate.
|
|
|
|
Fits call sites that fall through to the same redirect on the happy and unhappy path
|
|
alike — the success message is set inside the block, the failure message by this
|
|
context manager, and whichever fired, the caller's next line runs unchanged.
|
|
"""
|
|
try:
|
|
yield
|
|
except BillingError as error:
|
|
messages.error(request, str(error))
|
|
|
|
|
|
class DashboardView(PlatformStaffRequiredMixin, TemplateView):
|
|
template_name = "controlpanel/dashboard.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(
|
|
nav="dashboard",
|
|
totals=platform_totals(),
|
|
attention=platform_attention(),
|
|
funnel=onboarding_funnel(),
|
|
flags=flag_adoption(),
|
|
charts=platform_charts(),
|
|
clubs=clubs_with_health(),
|
|
today=timezone.localdate(),
|
|
**kwargs,
|
|
)
|
|
|
|
|
|
class ClubListView(PlatformStaffRequiredMixin, ListView):
|
|
template_name = "controlpanel/club_list.html"
|
|
context_object_name = "clubs"
|
|
|
|
@property
|
|
def show_archived(self):
|
|
return self.request.GET.get("archived") == "1"
|
|
|
|
def get_queryset(self):
|
|
clubs = Club.objects.archived() if self.show_archived else Club.objects.active()
|
|
search = self.request.GET.get("q", "").strip()
|
|
if search:
|
|
clubs = clubs.filter(name__icontains=search)
|
|
return clubs_with_health(clubs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(nav="clubs", show_archived=self.show_archived, search=self.request.GET.get("q", ""), today=timezone.localdate(), **kwargs)
|
|
|
|
|
|
class ClubCreateView(PlatformStaffRequiredMixin, CreateView):
|
|
model = Club
|
|
form_class = ClubForm
|
|
template_name = "controlpanel/club_form.html"
|
|
|
|
def form_valid(self, form):
|
|
response = super().form_valid(form)
|
|
messages.success(self.request, f"Club “{self.object}” created.")
|
|
return response
|
|
|
|
def get_success_url(self):
|
|
return reverse("controlpanel:club_detail", args=[self.object.pk])
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(nav="clubs", **kwargs)
|
|
|
|
|
|
class ClubUpdateView(PlatformStaffRequiredMixin, UpdateView):
|
|
model = Club
|
|
form_class = ClubForm
|
|
template_name = "controlpanel/club_form.html"
|
|
|
|
def form_valid(self, form):
|
|
response = super().form_valid(form)
|
|
messages.success(self.request, f"Club “{self.object}” updated.")
|
|
return response
|
|
|
|
def get_success_url(self):
|
|
return reverse("controlpanel:club_detail", args=[self.object.pk])
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(nav="clubs", update_view=True, **kwargs)
|
|
|
|
|
|
class ClubDetailView(PlatformStaffRequiredMixin, DetailView):
|
|
model = Club
|
|
template_name = "controlpanel/club_detail.html"
|
|
context_object_name = "club"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
subscription = getattr(self.object, "subscription", None)
|
|
next_start = next_period_start(self.object)
|
|
|
|
# Bound per-row so each due's "Add payment" modal can render its own form without
|
|
# the template calling DuePaymentForm(initial=...) itself.
|
|
dues = list(self.object.dues.select_related("tier", "invoice").prefetch_related("payments"))
|
|
for due in dues:
|
|
if due.is_owing:
|
|
due.payment_form = DuePaymentForm(initial={"amount": due.balance})
|
|
|
|
return super().get_context_data(
|
|
nav="clubs",
|
|
groups=club_statistics(self.object),
|
|
attention=club_attention(self.object),
|
|
charts=club_charts(self.object),
|
|
subscription=subscription,
|
|
dues=dues,
|
|
today=timezone.localdate(),
|
|
admins=ClubRole.objects.filter(club=self.object, role=ClubRole.Roles.ADMIN).select_related("member", "member__user"),
|
|
flags=flags_for_club(self.object),
|
|
open_period_form=OpenPeriodForm(),
|
|
open_period_blurb=f"Next period starts {date_format(next_start, 'j M Y')} unless you say otherwise. By default it continues from the end of the last one, so a lapsed year is still owed — pick a start date to forgive the gap.",
|
|
subscription_form=SubscriptionForm(instance=subscription) if subscription else SubscriptionForm(),
|
|
**kwargs,
|
|
)
|
|
|
|
|
|
class ClubArchiveView(PlatformStaffRequiredMixin, View):
|
|
"""Clubs are archived, never destroyed — their data (and invoices) are kept."""
|
|
|
|
def post(self, request, pk):
|
|
club = get_object_or_404(Club, pk=pk)
|
|
club.archive()
|
|
messages.warning(request, f"Club “{club}” archived. Its subdomain no longer resolves.")
|
|
return redirect("controlpanel:club_detail", pk=club.pk)
|
|
|
|
|
|
class ClubRestoreView(PlatformStaffRequiredMixin, View):
|
|
def post(self, request, pk):
|
|
club = get_object_or_404(Club, pk=pk)
|
|
club.restore()
|
|
messages.success(request, f"Club “{club}” restored.")
|
|
return redirect("controlpanel:club_detail", pk=club.pk)
|
|
|
|
|
|
class ClubAdminAddView(PlatformStaffRequiredMixin, FormView):
|
|
form_class = ClubAdminForm
|
|
template_name = "controlpanel/club_admin_form.html"
|
|
|
|
@property
|
|
def club(self):
|
|
return get_object_or_404(Club, pk=self.kwargs["pk"])
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(nav="clubs", club=self.club, **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
role = grant_club_admin(self.club, **form.cleaned_data)
|
|
messages.success(self.request, f"{role.member} is now an admin of {role.club}. They must set up two-factor authentication before they can sign in.")
|
|
return redirect("controlpanel:club_detail", pk=self.kwargs["pk"])
|
|
|
|
|
|
class ClubAdminRemoveView(PlatformStaffRequiredMixin, View):
|
|
def post(self, request, pk, role_pk):
|
|
role = get_object_or_404(ClubRole, pk=role_pk, club_id=pk, role=ClubRole.Roles.ADMIN)
|
|
member = role.member
|
|
revoke_club_admin(role)
|
|
messages.warning(request, f"{member} is no longer an admin of this club.")
|
|
return redirect("controlpanel:club_detail", pk=pk)
|
|
|
|
|
|
class ClubFeatureToggleView(PlatformStaffRequiredMixin, View):
|
|
"""Turn a feature on or off for one club."""
|
|
|
|
def post(self, request, pk, flag_pk):
|
|
club = get_object_or_404(Club, pk=pk)
|
|
flag = get_object_or_404(Flag, pk=flag_pk)
|
|
|
|
if flag.clubs.filter(pk=club.pk).exists():
|
|
flag.clubs.remove(club)
|
|
messages.warning(request, f"“{flag.name}” turned off for {club}.")
|
|
else:
|
|
flag.clubs.add(club)
|
|
messages.success(request, f"“{flag.name}” turned on for {club}.")
|
|
|
|
return redirect("controlpanel:club_detail", pk=club.pk)
|
|
|
|
|
|
class FeatureListView(PlatformStaffRequiredMixin, TemplateView):
|
|
template_name = "controlpanel/features.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(
|
|
nav="features",
|
|
flags=Flag.objects.prefetch_related("clubs").order_by("name"),
|
|
switches=Switch.objects.order_by("name"),
|
|
maintenance=Maintenance.current(),
|
|
maintenance_form=MaintenanceForm(),
|
|
**kwargs,
|
|
)
|
|
|
|
|
|
class MaintenanceView(PlatformStaffRequiredMixin, View):
|
|
"""Close the platform, or open it again."""
|
|
|
|
def post(self, request):
|
|
if Maintenance.is_on():
|
|
Maintenance.stop()
|
|
messages.success(request, "Maintenance ended. The clubs are back.")
|
|
else:
|
|
form = MaintenanceForm(request.POST)
|
|
message = form.cleaned_data["message"] if form.is_valid() else ""
|
|
Maintenance.start(message=message, user=request.user)
|
|
messages.warning(request, "Platform closed. Every club subdomain now serves a maintenance page, and the scheduled jobs stand down.")
|
|
|
|
return redirect("controlpanel:features")
|
|
|
|
|
|
class FlagCreateView(PlatformStaffRequiredMixin, CreateView):
|
|
model = Flag
|
|
form_class = FlagForm
|
|
template_name = "controlpanel/flag_form.html"
|
|
success_url = None
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(nav="features", **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
response = super().form_valid(form)
|
|
messages.success(self.request, f"Feature “{self.object.name}” created.")
|
|
return response
|
|
|
|
def get_success_url(self):
|
|
return reverse("controlpanel:features")
|
|
|
|
|
|
class FlagUpdateView(PlatformStaffRequiredMixin, UpdateView):
|
|
model = Flag
|
|
form_class = FlagForm
|
|
template_name = "controlpanel/flag_form.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(nav="features", **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
response = super().form_valid(form)
|
|
messages.success(self.request, f"Feature “{self.object.name}” updated.")
|
|
return response
|
|
|
|
def get_success_url(self):
|
|
return reverse("controlpanel:features")
|
|
|
|
|
|
class SwitchToggleView(PlatformStaffRequiredMixin, View):
|
|
"""Global kill-switch: on or off for the whole platform."""
|
|
|
|
def post(self, request, pk):
|
|
switch = get_object_or_404(Switch, pk=pk)
|
|
switch.active = not switch.active
|
|
switch.save()
|
|
messages.success(request, f"Switch “{switch.name}” is now {'on' if switch.active else 'off'}.")
|
|
return redirect("controlpanel:features")
|
|
|
|
|
|
class PlatformAdminListView(PlatformSuperuserRequiredMixin, TemplateView):
|
|
template_name = "controlpanel/admins.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(nav="admins", admins=platform_admins(), **kwargs)
|
|
|
|
|
|
class PlatformAdminAddView(PlatformSuperuserRequiredMixin, FormView):
|
|
form_class = PlatformAdminForm
|
|
template_name = "controlpanel/admin_form.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
return super().get_context_data(nav="admins", **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
user = grant_platform_access(form.cleaned_data["email"], is_superuser=form.cleaned_data["is_superuser"])
|
|
messages.success(self.request, f"{user.email} now has platform access. They must set up two-factor authentication before they can sign in.")
|
|
return redirect("controlpanel:admins")
|
|
|
|
|
|
class PlatformAdminUpdateView(PlatformSuperuserRequiredMixin, View):
|
|
def post(self, request, pk):
|
|
user = get_object_or_404(get_user_model(), pk=pk)
|
|
try:
|
|
set_platform_access(
|
|
request.user,
|
|
user,
|
|
is_staff=request.POST.get("is_staff") == "1",
|
|
is_superuser=request.POST.get("is_superuser") == "1",
|
|
)
|
|
except PlatformAdminError as error:
|
|
messages.error(request, str(error))
|
|
else:
|
|
messages.success(request, f"Updated platform access for {user.email}.")
|
|
return redirect("controlpanel:admins")
|
|
|
|
|
|
class PlatformAdminRevokeView(PlatformSuperuserRequiredMixin, View):
|
|
def post(self, request, pk):
|
|
user = get_object_or_404(get_user_model(), pk=pk)
|
|
try:
|
|
revoke_platform_access(request.user, user)
|
|
except PlatformAdminError as error:
|
|
messages.error(request, str(error))
|
|
else:
|
|
messages.warning(request, f"{user.email} no longer has platform access.")
|
|
return redirect("controlpanel:admins")
|
|
|
|
|
|
class BillingView(PlatformStaffRequiredMixin, TemplateView):
|
|
"""Tiers and their prices, plus every period we are owed money for."""
|
|
|
|
template_name = "controlpanel/billing.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
today = timezone.localdate()
|
|
|
|
# Bound per-row so each "Edit" / "New price" modal can render its own form: the
|
|
# template can't call TierForm(instance=tier) itself, so the form rides along on
|
|
# the object it belongs to.
|
|
tiers = list(Tier.objects.prefetch_related("prices").annotate(club_count=Count("subscriptions")))
|
|
for tier in tiers:
|
|
tier.edit_form = TierForm(instance=tier)
|
|
tier.price_form = TierPriceForm()
|
|
|
|
owing = list(Due.objects.filter(status__in=Due.OWING).select_related("club", "tier").order_by("grace_until"))
|
|
for due in owing:
|
|
due.payment_form = DuePaymentForm(initial={"amount": due.balance})
|
|
|
|
return super().get_context_data(
|
|
nav="billing",
|
|
tiers=tiers,
|
|
tier_form=TierForm(),
|
|
owing=owing,
|
|
today=today,
|
|
**kwargs,
|
|
)
|
|
|
|
|
|
class TierCreateView(PlatformStaffRequiredMixin, RedirectOnInvalidMixin, CreateView):
|
|
"""Reachable only via the "New plan" modal on the billing page — POST-only, and there
|
|
is no standalone template to render on GET or on a rejected submission."""
|
|
|
|
model = Tier
|
|
form_class = TierForm
|
|
http_method_names = ["post"]
|
|
invalid_redirect_url_name = "controlpanel:billing"
|
|
|
|
def get_success_url(self):
|
|
messages.success(self.request, f"Tier “{self.object}” created. Give it a price before billing anyone.")
|
|
return reverse("controlpanel:billing")
|
|
|
|
|
|
class TierUpdateView(PlatformStaffRequiredMixin, RedirectOnInvalidMixin, UpdateView):
|
|
"""Reachable only via a tier's "Edit" modal on the billing page — POST-only, and there
|
|
is no standalone template to render on GET or on a rejected submission."""
|
|
|
|
model = Tier
|
|
form_class = TierForm
|
|
http_method_names = ["post"]
|
|
invalid_redirect_url_name = "controlpanel:billing"
|
|
|
|
def get_success_url(self):
|
|
messages.success(self.request, f"Tier “{self.object}” updated.")
|
|
return reverse("controlpanel:billing")
|
|
|
|
|
|
class TierPriceCreateView(PlatformStaffRequiredMixin, RedirectOnInvalidMixin, CreateView):
|
|
"""A rate change is a new dated price, never an edit of the old one — periods already
|
|
billed keep the amount they were billed at.
|
|
|
|
Reachable only via a tier's "New price" modal on the billing page — POST-only, and
|
|
there is no standalone template to render on GET or on a rejected submission.
|
|
"""
|
|
|
|
model = TierPrice
|
|
form_class = TierPriceForm
|
|
http_method_names = ["post"]
|
|
invalid_redirect_url_name = "controlpanel:billing"
|
|
|
|
@property
|
|
def tier(self):
|
|
return get_object_or_404(Tier, pk=self.kwargs["pk"])
|
|
|
|
def form_valid(self, form):
|
|
form.instance.tier = self.tier
|
|
response = super().form_valid(form)
|
|
messages.success(self.request, f"{self.tier} is €{self.object.amount} for periods opening from {self.object.active_from}.")
|
|
return response
|
|
|
|
def get_success_url(self):
|
|
return reverse("controlpanel:billing")
|
|
|
|
|
|
class SubscribeClubView(PlatformStaffRequiredMixin, RedirectOnInvalidMixin, FormView):
|
|
"""Put a club on a tier, which opens its first period.
|
|
|
|
Reachable only via the "Change plan" modal on the club detail page — POST-only, and
|
|
there is no standalone template to render on GET or on a rejected submission.
|
|
"""
|
|
|
|
form_class = SubscriptionForm
|
|
http_method_names = ["post"]
|
|
invalid_redirect_url_name = "controlpanel:club_detail"
|
|
|
|
@property
|
|
def club(self):
|
|
return get_object_or_404(Club, pk=self.kwargs["pk"])
|
|
|
|
def get_invalid_redirect_kwargs(self):
|
|
return {"pk": self.club.pk}
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
subscription = getattr(self.club, "subscription", None)
|
|
if subscription:
|
|
kwargs["instance"] = subscription
|
|
return kwargs
|
|
|
|
def form_valid(self, form):
|
|
club = self.club
|
|
existing = getattr(club, "subscription", None)
|
|
with suppress_billing_errors(self.request):
|
|
if existing:
|
|
# Changing tier does not re-bill: the current period keeps the amount it was
|
|
# issued at, and the new rate applies from the next one.
|
|
subscription = form.save(commit=False)
|
|
subscription.club = club
|
|
subscription.save()
|
|
messages.success(self.request, f"{club} is now on {subscription.tier}. The current period keeps the amount it was billed at.")
|
|
else:
|
|
subscribe(club, form.cleaned_data["tier"], start=form.cleaned_data.get("start"), auto_archive=form.cleaned_data["auto_archive"], auto_renew=form.cleaned_data["auto_renew"])
|
|
messages.success(self.request, f"{club} is on {form.cleaned_data['tier']}. Its first period is open.")
|
|
|
|
return redirect("controlpanel:club_detail", pk=club.pk)
|
|
|
|
|
|
class RecordPaymentView(PlatformStaffRequiredMixin, RedirectOnInvalidMixin, FormView):
|
|
"""Reachable only via a due's "Record payment" modal on the club or billing page —
|
|
POST-only, and there is no standalone template to render on GET or on a rejected
|
|
submission."""
|
|
|
|
form_class = DuePaymentForm
|
|
http_method_names = ["post"]
|
|
invalid_redirect_url_name = "controlpanel:club_detail"
|
|
|
|
@property
|
|
def due(self):
|
|
return get_object_or_404(Due.objects.select_related("club", "tier"), pk=self.kwargs["pk"])
|
|
|
|
def get_invalid_redirect_kwargs(self):
|
|
return {"pk": self.due.club_id}
|
|
|
|
def form_valid(self, form):
|
|
due = self.due
|
|
with suppress_billing_errors(self.request):
|
|
record_payment(
|
|
due,
|
|
form.cleaned_data["amount"],
|
|
method=form.cleaned_data["method"],
|
|
reference=form.cleaned_data["reference"],
|
|
paid_at=form.cleaned_data["paid_at"],
|
|
note=form.cleaned_data["note"],
|
|
user=self.request.user,
|
|
)
|
|
due.refresh_from_db()
|
|
messages.success(self.request, f"€{form.cleaned_data['amount']} recorded. {due.get_status_display().capitalize()} — €{due.balance} outstanding.")
|
|
|
|
return redirect("controlpanel:club_detail", pk=due.club_id)
|
|
|
|
|
|
class WaiveDueView(PlatformStaffRequiredMixin, View):
|
|
def post(self, request, pk):
|
|
due = get_object_or_404(Due, pk=pk)
|
|
with suppress_billing_errors(request):
|
|
waive(due)
|
|
messages.warning(request, f"Period {due.period_start} to {due.period_end} waived. Nothing is owed and the club will not be archived for it.")
|
|
|
|
return redirect("controlpanel:club_detail", pk=due.club_id)
|
|
|
|
|
|
class OpenPeriodView(PlatformStaffRequiredMixin, RedirectOnInvalidMixin, FormView):
|
|
"""Renew a club, or reactivate an archived one.
|
|
|
|
Reachable only via the "Open period" modal on the club detail page — POST-only, and
|
|
there is no standalone template to render on GET or on a rejected submission.
|
|
"""
|
|
|
|
form_class = OpenPeriodForm
|
|
http_method_names = ["post"]
|
|
invalid_redirect_url_name = "controlpanel:club_detail"
|
|
|
|
@property
|
|
def club(self):
|
|
return get_object_or_404(Club, pk=self.kwargs["pk"])
|
|
|
|
def get_invalid_redirect_kwargs(self):
|
|
return {"pk": self.club.pk}
|
|
|
|
def form_valid(self, form):
|
|
club = self.club
|
|
start = form.cleaned_data.get("start")
|
|
with suppress_billing_errors(self.request):
|
|
due = reactivate(club, start=start) if club.is_archived else open_period(club, start=start)
|
|
messages.success(self.request, f"Period {due.period_start} to {due.period_end} opened for €{due.amount}. Invoice {due.invoice.number}.")
|
|
|
|
return redirect("controlpanel:club_detail", pk=club.pk)
|
|
|
|
|
|
class InvoicePdfView(PlatformStaffRequiredMixin, View):
|
|
def get(self, request, pk):
|
|
due = get_object_or_404(Due.objects.select_related("club", "tier", "invoice"), pk=pk)
|
|
invoice = issue_invoice(due)
|
|
try:
|
|
pdf = invoice_pdf(invoice)
|
|
except BillingError as error:
|
|
# The native PDF libraries are missing: say so rather than 500.
|
|
messages.error(request, str(error))
|
|
return redirect("controlpanel:club_detail", pk=due.club_id)
|
|
|
|
response = HttpResponse(pdf, content_type="application/pdf")
|
|
response["Content-Disposition"] = f'attachment; filename="{invoice.number}.pdf"'
|
|
return response
|