Files
WYGIWYH/app/apps/splits/views.py
T
Herculino Trotta 77bf2d7bdb feat(splits): add split expenses for shared group costs
Track expenses shared with other people (trips, flats, dinners) and settle
up with the fewest payments.

- Events with WYGIWYH users and people without an account, who join through
  a share link and pick a password on first sign-in
- Equal, exact, percentage and share-weight splits that always add up
- Balances, a minimal settle-up plan and an activity feed showing what each
  item means for you
- Link items to your own transactions; recording a payment marks planned
  ones as paid
- Share menu: printable PDF report and PNG images of the summary, settle-up
  and balances (adds modern-screenshot)
- Only the two people involved or the organizer can record a payment;
  members can leave events they don't organize
2026-11-20 19:43:23 -03:00

1442 lines
46 KiB
Python

from decimal import Decimal, InvalidOperation
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.core.exceptions import PermissionDenied
from django.db import transaction as db_transaction
from django.http import FileResponse, Http404, HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from django.views.decorators.http import require_http_methods
from apps.common.decorators.htmx import only_htmx
from apps.splits.auth import (
SplitActor,
accessible_events,
user_display_name,
clear_external_session,
get_external_actor,
get_external_participant_from_session,
get_wygiwyh_actor,
set_external_session,
)
from apps.splits.forms import (
AddExternalParticipantForm,
AddWygiwyhParticipantForm,
ExternalAuthForm,
SplitEventForm,
SplitExpenseForm,
SplitPaymentForm,
SplitTransactionSyncForm,
)
from apps.splits.models import (
SplitAttachment,
SplitEvent,
SplitExpense,
SplitParticipant,
SplitPayment,
SplitTransactionLink,
)
from apps.splits.services.settlement import get_event_settlement_summary
from apps.splits.services.membership import leave_event
from apps.splits.services.splitting import replace_expense_shares
from apps.splits.services.wygiwyh_sync import (
build_default_sync_description,
create_and_link_transaction,
expected_transaction_type_for_kind,
link_existing_transaction,
settle_pending_links_for_payment,
)
def _portal_urls(actor: SplitActor) -> dict:
event = actor.event
if actor.is_external_portal:
tok = event.share_token
return {
"event_detail": reverse("split_external_event_detail", kwargs={"share_token": tok}),
"event_content": reverse("split_external_event_content", kwargs={"share_token": tok}),
"report": reverse("split_external_event_report", kwargs={"share_token": tok}),
"expense_add": reverse("split_external_expense_add", kwargs={"share_token": tok}),
"payment_add": reverse("split_external_payment_add", kwargs={"share_token": tok}),
"expense_edit_name": "split_external_expense_edit",
"expense_delete_name": "split_external_expense_delete",
"payment_edit_name": "split_external_payment_edit",
"payment_delete_name": "split_external_payment_delete",
"attachment_download_name": "split_external_attachment_download",
"attachment_delete_name": "split_external_attachment_delete",
"url_kwarg_key": "share_token",
"url_kwarg_val": tok,
}
return {
"event_detail": reverse("split_event_detail", kwargs={"event_id": event.id}),
"event_content": reverse("split_event_content", kwargs={"event_id": event.id}),
"report": reverse("split_event_report", kwargs={"event_id": event.id}),
"expense_add": reverse("split_expense_add", kwargs={"event_id": event.id}),
"payment_add": reverse("split_payment_add", kwargs={"event_id": event.id}),
"expense_edit_name": "split_expense_edit",
"expense_delete_name": "split_expense_delete",
"payment_edit_name": "split_payment_edit",
"payment_delete_name": "split_payment_delete",
"attachment_download_name": "split_attachment_download",
"attachment_delete_name": "split_attachment_delete",
"url_kwarg_key": "event_id",
"url_kwarg_val": event.id,
}
def _build_event_context(request, actor: SplitActor) -> dict:
event = actor.event
summary = get_event_settlement_summary(event)
expenses = list(
event.expenses.select_related("paid_by", "created_by_participant")
.prefetch_related("shares__participant", "attachments")
.all()
)
payments = list(
event.payments.select_related(
"from_participant", "to_participant", "created_by_participant"
)
.prefetch_related("attachments")
.all()
)
# Map WYGIWYH transaction links for the current logged-in WYGIWYH user
expense_links: dict[int, list[SplitTransactionLink]] = {}
payment_links: dict[int, list[SplitTransactionLink]] = {}
settlement_out_links: dict[int, list[SplitTransactionLink]] = {}
settlement_in_links: dict[int, list[SplitTransactionLink]] = {}
if actor.is_wygiwyh_user:
user_links = (
SplitTransactionLink.objects.filter(
event=event,
user=actor.user,
transaction__deleted=False,
)
.select_related("transaction", "transaction__account", "transaction__account__currency", "counterparty")
.all()
)
for link in user_links:
if link.expense_id:
expense_links.setdefault(link.expense_id, []).append(link)
elif link.payment_id:
payment_links.setdefault(link.payment_id, []).append(link)
elif link.kind == SplitTransactionLink.Kind.SETTLEMENT_OUT and link.counterparty_id:
settlement_out_links.setdefault(link.counterparty_id, []).append(link)
elif link.kind == SplitTransactionLink.Kind.SETTLEMENT_IN and link.counterparty_id:
settlement_in_links.setdefault(link.counterparty_id, []).append(link)
me_id = actor.participant.id if actor.participant else None
# Only money that moved through the user's own accounts can be synced (matches sync views)
sync_id = me_id if actor.is_wygiwyh_user else None
for exp in expenses:
exp.can_edit = actor.can_edit_item(
created_by_id=exp.created_by_participant_id,
primary_participant_id=exp.paid_by_id,
)
exp.can_sync = sync_id is not None and exp.paid_by_id == sync_id
exp.user_tx_links = expense_links.get(exp.id, [])
# What this expense means for the viewer: > 0 lent, < 0 borrowed, None not involved
my_share = next((s.amount for s in exp.shares.all() if s.participant_id == me_id), None)
if exp.paid_by_id == me_id:
exp.my_delta = exp.amount - (my_share or 0)
else:
exp.my_delta = -my_share if my_share is not None else None
exp.my_delta_abs = abs(exp.my_delta) if exp.my_delta is not None else None
for pay in payments:
pay.is_payment = True
pay.can_edit = actor.can_edit_item(
created_by_id=pay.created_by_participant_id,
primary_participant_id=pay.from_participant_id,
)
pay.can_sync = sync_id is not None and sync_id in (
pay.from_participant_id,
pay.to_participant_id,
)
pay.user_tx_links = payment_links.get(pay.id, [])
activity = sorted(
[*expenses, *payments], key=lambda i: (i.date, i.created_at), reverse=True
)
# Diverging bar per person, scaled to the largest balance
max_abs = max((abs(b.net_balance) for b in summary["balances"]), default=0)
balance_rows = [
{
"balance": b,
"bar": int(abs(b.net_balance) * 50 / max_abs) if max_abs else 0,
}
for b in summary["balances"]
]
enriched_transfers = []
for t in summary["transfers"]:
user_direction = None
counterparty = None
links = []
if actor.is_wygiwyh_user and actor.participant:
if t.from_participant.id == actor.participant.id:
user_direction = "out"
counterparty = t.to_participant
links = settlement_out_links.get(counterparty.id, [])
elif t.to_participant.id == actor.participant.id:
user_direction = "in"
counterparty = t.from_participant
links = settlement_in_links.get(counterparty.id, [])
enriched_transfers.append(
{
"transfer": t,
"user_direction": user_direction,
"counterparty": counterparty,
"tx_links": links,
"can_record": actor.can_record_payment(
t.from_participant.id, t.to_participant.id
),
}
)
my_balance = (
summary["balances_by_id"].get(actor.participant.id)
if actor.participant
else None
)
share_url = request.build_absolute_uri(
reverse("split_external_auth", kwargs={"share_token": event.share_token})
)
active_participants_count = sum(
1 for b in summary["balances"] if b.participant.is_active
)
return {
"event": event,
"actor": actor,
"urls": _portal_urls(actor),
"balance_rows": balance_rows,
"transfers": enriched_transfers,
"total_spent": summary["total_spent"],
"my_balance": my_balance,
"my_balance_abs": abs(my_balance.net_balance) if my_balance else None,
"me_id": me_id,
"active_participants_count": active_participants_count,
"activity": activity,
"expense_count": len(expenses),
"payment_count": len(payments),
"share_url": share_url,
}
def _save_expense_from_form(
form: SplitExpenseForm,
*,
actor: SplitActor,
files,
) -> SplitExpense:
with db_transaction.atomic():
expense: SplitExpense = form.save(commit=False)
expense.event = actor.event
if not expense.pk:
expense.created_by_participant = actor.participant
expense.save()
replace_expense_shares(expense, form.computed_shares)
for f in files:
SplitAttachment.objects.create(
event=actor.event,
expense=expense,
file=f,
original_name=f.name,
content_type=getattr(f, "content_type", ""),
size=f.size,
uploaded_by=actor.participant,
)
return expense
def _save_payment_from_form(
form: SplitPaymentForm,
*,
actor: SplitActor,
files,
) -> SplitPayment:
is_new = not form.instance.pk
with db_transaction.atomic():
payment: SplitPayment = form.save(commit=False)
payment.event = actor.event
if is_new:
payment.created_by_participant = actor.participant
payment.save()
for f in files:
SplitAttachment.objects.create(
event=actor.event,
payment=payment,
file=f,
original_name=f.name,
content_type=getattr(f, "content_type", ""),
size=f.size,
uploaded_by=actor.participant,
)
if is_new:
settle_pending_links_for_payment(payment)
return payment
def _build_expense_form_context(
form: SplitExpenseForm,
actor: SplitActor,
*,
expense: SplitExpense | None = None,
post_url: str,
) -> dict:
# Build per-participant initial state for the share selector UI
if form.is_bound:
selected_ids = set()
for raw in form.data.getlist("share_participants"):
try:
selected_ids.add(int(raw))
except (TypeError, ValueError):
pass
rows = []
for p in form.available_participants:
rows.append(
{
"participant": p,
"selected": p.id in selected_ids,
"value": form.data.get(f"share_value_{p.id}", ""),
}
)
elif expense and expense.pk:
share_map = {s.participant_id: s for s in expense.shares.all()}
rows = []
for p in form.available_participants:
s = share_map.get(p.id)
val = ""
if s:
if expense.split_type == SplitExpense.SplitType.EXACT:
val = f"{s.amount.normalize():f}"
elif expense.split_type == SplitExpense.SplitType.PERCENTAGE and s.percentage is not None:
val = f"{s.percentage.normalize():f}"
elif expense.split_type == SplitExpense.SplitType.SHARES and s.shares is not None:
val = f"{s.shares.normalize():f}"
rows.append(
{
"participant": p,
"selected": s is not None,
"value": val,
}
)
else:
rows = [
{
"participant": p,
"selected": True,
"value": "",
}
for p in form.available_participants
]
return {
"form": form,
"event": actor.event,
"actor": actor,
"expense": expense,
"participant_rows": rows,
"post_url": post_url,
"urls": _portal_urls(actor),
}
# =============================================================================
# WYGIWYH User Views
# =============================================================================
@login_required
def event_index(request):
return render(request, "splits/pages/event_index.html")
@only_htmx
@login_required
def event_list(request):
show_archived = request.GET.get("archived") == "1"
events_qs = (
accessible_events(request.user)
.select_related("currency", "creator")
.prefetch_related("participants")
)
if not show_archived:
events_qs = events_qs.filter(is_archived=False)
event_cards = []
for event in events_qs:
summary = get_event_settlement_summary(event)
me = event.get_wygiwyh_participant(request.user)
my_bal = summary["balances_by_id"].get(me.id) if me else None
event_cards.append(
{
"event": event,
"total_spent": summary["total_spent"],
"my_balance": my_bal,
"participant_count": sum(
1 for p in event.participants.all() if p.is_active
),
"is_creator": event.can_manage(request.user),
}
)
return render(
request,
"splits/fragments/event/list.html",
{
"event_cards": event_cards,
"show_archived": show_archived,
},
)
@only_htmx
@login_required
def event_add(request):
if request.method == "POST":
form = SplitEventForm(request.POST)
if form.is_valid():
with db_transaction.atomic():
event = form.save(commit=False)
event.creator = request.user
event.save()
SplitParticipant.objects.create(
event=event,
user=request.user,
name=user_display_name(request.user),
is_external=False,
is_active=True,
)
messages.success(request, _("Split event created successfully"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, hide_offcanvas"},
)
else:
form = SplitEventForm()
return render(request, "splits/fragments/event/add.html", {"form": form})
@login_required
def event_detail(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
return render(
request,
"splits/pages/event_detail.html",
{
"event": actor.event,
"actor": actor,
"urls": _portal_urls(actor),
},
)
@only_htmx
@login_required
def event_content(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
ctx = _build_event_context(request, actor)
return render(request, "splits/fragments/event/content.html", ctx)
@login_required
def event_report(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
return render(
request, "splits/pages/event_report.html", _build_event_context(request, actor)
)
@only_htmx
@login_required
def event_edit(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
if not actor.is_creator:
raise PermissionDenied
if request.method == "POST":
form = SplitEventForm(request.POST, instance=actor.event)
if form.is_valid():
form.save()
messages.success(request, _("Event updated successfully"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, hide_offcanvas"},
)
else:
form = SplitEventForm(instance=actor.event)
return render(
request,
"splits/fragments/event/edit.html",
{"form": form, "event": actor.event},
)
@only_htmx
@login_required
@require_http_methods(["DELETE"])
def event_delete(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
if not actor.is_creator:
raise PermissionDenied
actor.event.delete()
messages.success(request, _("Event deleted successfully"))
return HttpResponse(
status=204,
headers={
"HX-Redirect": reverse("split_event_index"),
},
)
@only_htmx
@login_required
@require_http_methods(["POST"])
def event_leave(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
if actor.is_creator or not actor.participant:
raise PermissionDenied
leave_event(actor)
messages.success(request, _("You left %(name)s") % {"name": actor.event.name})
return HttpResponse(
status=204,
headers={"HX-Redirect": reverse("split_event_index")},
)
# =============================================================================
# Participants & Share Link Management (Creator only)
# =============================================================================
def _render_participants_manage(request, actor: SplitActor, wygiwyh_form=None, external_form=None):
event = actor.event
participants = list(event.participants.select_related("user").all())
for p in participants:
p.has_contribs = p.has_contributions()
p.deletable = p.can_be_deleted()
share_url = request.build_absolute_uri(
reverse("split_external_auth", kwargs={"share_token": event.share_token})
)
return render(
request,
"splits/fragments/participants/manage.html",
{
"event": event,
"participants": participants,
"wygiwyh_form": wygiwyh_form or AddWygiwyhParticipantForm(event=event),
"external_form": external_form or AddExternalParticipantForm(event=event),
"share_url": share_url,
},
)
@only_htmx
@login_required
def participants_manage(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
if not actor.is_creator:
raise PermissionDenied
return _render_participants_manage(request, actor)
@only_htmx
@login_required
@require_http_methods(["POST"])
def participant_add_wygiwyh(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
if not actor.is_creator:
raise PermissionDenied
form = AddWygiwyhParticipantForm(request.POST, event=actor.event)
if form.is_valid():
u = form.cleaned_data["user"]
base_name = user_display_name(u)
name = base_name
suffix = 2
while actor.event.participants.filter(name__iexact=name).exists():
name = f"{base_name} ({suffix})"
suffix += 1
SplitParticipant.objects.create(
event=actor.event,
user=u,
name=name,
is_external=False,
is_active=True,
)
messages.success(request, _("Added %(name)s to the event") % {"name": name})
resp = _render_participants_manage(request, actor)
resp["HX-Trigger"] = "updated, toasts"
return resp
return _render_participants_manage(request, actor, wygiwyh_form=form)
@only_htmx
@login_required
@require_http_methods(["POST"])
def participant_add_external(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
if not actor.is_creator:
raise PermissionDenied
form = AddExternalParticipantForm(request.POST, event=actor.event)
if form.is_valid():
name = form.cleaned_data["name"]
SplitParticipant.objects.create(
event=actor.event,
user=None,
name=name,
is_external=True,
is_active=True,
)
messages.success(
request,
_("Added external participant %(name)s") % {"name": name},
)
resp = _render_participants_manage(request, actor)
resp["HX-Trigger"] = "updated, toasts"
return resp
return _render_participants_manage(request, actor, external_form=form)
@only_htmx
@login_required
@require_http_methods(["POST"])
def participant_toggle_active(request, event_id, participant_id):
actor = get_wygiwyh_actor(request, event_id)
if not actor.is_creator:
raise PermissionDenied
participant = get_object_or_404(
SplitParticipant, id=participant_id, event=actor.event
)
if participant.is_creator:
messages.error(request, _("The event creator cannot be deactivated."))
else:
participant.is_active = not participant.is_active
participant.save(update_fields=["is_active"])
if participant.is_active:
messages.success(
request, _("Reactivated %(name)s") % {"name": participant.name}
)
else:
messages.success(
request,
_("Deactivated %(name)s (contributions preserved)")
% {"name": participant.name},
)
resp = _render_participants_manage(request, actor)
resp["HX-Trigger"] = "updated, toasts"
return resp
@only_htmx
@login_required
@require_http_methods(["DELETE"])
def participant_delete(request, event_id, participant_id):
actor = get_wygiwyh_actor(request, event_id)
if not actor.is_creator:
raise PermissionDenied
participant = get_object_or_404(
SplitParticipant, id=participant_id, event=actor.event
)
if participant.can_be_deleted():
name = participant.name
participant.delete()
messages.success(request, _("Removed %(name)s") % {"name": name})
else:
messages.error(
request,
_(
"%(name)s has existing contributions and cannot be deleted. Deactivate them instead."
)
% {"name": participant.name},
)
resp = _render_participants_manage(request, actor)
resp["HX-Trigger"] = "updated, toasts"
return resp
@only_htmx
@login_required
@require_http_methods(["POST"])
def participant_reset_password(request, event_id, participant_id):
actor = get_wygiwyh_actor(request, event_id)
if not actor.is_creator:
raise PermissionDenied
participant = get_object_or_404(
SplitParticipant, id=participant_id, event=actor.event, is_external=True
)
participant.reset_external_password()
messages.success(
request,
_("Password reset for %(name)s. They can set a new password on next login.")
% {"name": participant.name},
)
resp = _render_participants_manage(request, actor)
resp["HX-Trigger"] = "updated, toasts"
return resp
@only_htmx
@login_required
@require_http_methods(["POST"])
def event_regenerate_link(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
if not actor.is_creator:
raise PermissionDenied
actor.event.regenerate_share_token()
messages.success(
request,
_("Share link regenerated. Existing external sessions have been signed out."),
)
resp = _render_participants_manage(request, actor)
resp["HX-Trigger"] = "updated, toasts"
return resp
# =============================================================================
# Shared Expense / Payment / Attachment Handlers (WYGIWYH + External)
# =============================================================================
def _handle_expense_add(request, actor: SplitActor):
urls = _portal_urls(actor)
if request.method == "POST":
form = SplitExpenseForm(
request.POST,
request.FILES,
event=actor.event,
default_payer=actor.participant,
)
if form.is_valid():
_save_expense_from_form(
form,
actor=actor,
files=form.cleaned_data.get("attachments") or [],
)
messages.success(request, _("Expense added successfully"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, hide_offcanvas, toasts"},
)
else:
form = SplitExpenseForm(event=actor.event, default_payer=actor.participant)
ctx = _build_expense_form_context(form, actor, post_url=urls["expense_add"])
return render(request, "splits/fragments/expense/form.html", ctx)
def _handle_expense_edit(request, actor: SplitActor, expense_id: int):
expense = get_object_or_404(
SplitExpense.objects.prefetch_related("shares__participant", "attachments"),
id=expense_id,
event=actor.event,
)
if not actor.can_edit_item(
created_by_id=expense.created_by_participant_id,
primary_participant_id=expense.paid_by_id,
):
raise PermissionDenied
urls = _portal_urls(actor)
post_url = reverse(
urls["expense_edit_name"],
kwargs={urls["url_kwarg_key"]: urls["url_kwarg_val"], "expense_id": expense.id},
)
if request.method == "POST":
form = SplitExpenseForm(
request.POST,
request.FILES,
instance=expense,
event=actor.event,
)
if form.is_valid():
_save_expense_from_form(
form,
actor=actor,
files=form.cleaned_data.get("attachments") or [],
)
messages.success(request, _("Expense updated successfully"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, hide_offcanvas, toasts"},
)
else:
form = SplitExpenseForm(instance=expense, event=actor.event)
ctx = _build_expense_form_context(form, actor, expense=expense, post_url=post_url)
return render(request, "splits/fragments/expense/form.html", ctx)
def _handle_expense_delete(request, actor: SplitActor, expense_id: int):
expense = get_object_or_404(SplitExpense, id=expense_id, event=actor.event)
if not actor.can_edit_item(
created_by_id=expense.created_by_participant_id,
primary_participant_id=expense.paid_by_id,
):
raise PermissionDenied
for att in expense.attachments.all():
att.file.delete(save=False)
expense.delete()
messages.success(request, _("Expense deleted successfully"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, hide_offcanvas, toasts"},
)
def _handle_payment_add(request, actor: SplitActor):
urls = _portal_urls(actor)
initial = {}
if request.method == "GET":
if request.GET.get("from"):
initial["from_participant"] = request.GET.get("from")
elif actor.participant:
initial["from_participant"] = actor.participant.id
if request.GET.get("to"):
initial["to_participant"] = request.GET.get("to")
try:
# Settle-up links send a plain "12.34", not the user's number format
initial["amount"] = Decimal(request.GET["amount"])
except (KeyError, InvalidOperation):
pass
if request.method == "POST":
form = SplitPaymentForm(request.POST, request.FILES, event=actor.event, actor=actor)
if form.is_valid():
_save_payment_from_form(
form,
actor=actor,
files=form.cleaned_data.get("attachments") or [],
)
messages.success(request, _("Payment recorded successfully"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, hide_offcanvas, toasts"},
)
else:
form = SplitPaymentForm(event=actor.event, actor=actor, initial=initial)
return render(
request,
"splits/fragments/payment/form.html",
{
"form": form,
"event": actor.event,
"actor": actor,
"payment": None,
"post_url": urls["payment_add"],
"urls": urls,
},
)
def _handle_payment_edit(request, actor: SplitActor, payment_id: int):
payment = get_object_or_404(
SplitPayment.objects.prefetch_related("attachments"),
id=payment_id,
event=actor.event,
)
if not actor.can_edit_item(
created_by_id=payment.created_by_participant_id,
primary_participant_id=payment.from_participant_id,
):
raise PermissionDenied
urls = _portal_urls(actor)
post_url = reverse(
urls["payment_edit_name"],
kwargs={urls["url_kwarg_key"]: urls["url_kwarg_val"], "payment_id": payment.id},
)
if request.method == "POST":
form = SplitPaymentForm(
request.POST, request.FILES, instance=payment, event=actor.event, actor=actor
)
if form.is_valid():
_save_payment_from_form(
form,
actor=actor,
files=form.cleaned_data.get("attachments") or [],
)
messages.success(request, _("Payment updated successfully"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, hide_offcanvas, toasts"},
)
else:
form = SplitPaymentForm(instance=payment, event=actor.event, actor=actor)
return render(
request,
"splits/fragments/payment/form.html",
{
"form": form,
"event": actor.event,
"actor": actor,
"payment": payment,
"post_url": post_url,
"urls": urls,
},
)
def _handle_payment_delete(request, actor: SplitActor, payment_id: int):
payment = get_object_or_404(SplitPayment, id=payment_id, event=actor.event)
if not actor.can_edit_item(
created_by_id=payment.created_by_participant_id,
primary_participant_id=payment.from_participant_id,
):
raise PermissionDenied
for att in payment.attachments.all():
att.file.delete(save=False)
payment.delete()
messages.success(request, _("Payment deleted successfully"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, hide_offcanvas, toasts"},
)
INLINE_SAFE_CONTENT_TYPES = {
"application/pdf",
"image/gif",
"image/jpeg",
"image/png",
"image/webp",
}
def _handle_attachment_download(actor: SplitActor, attachment_id):
att = get_object_or_404(SplitAttachment, id=attachment_id, event=actor.event)
# Anonymous external participants upload these, so never render HTML/SVG inline
return FileResponse(
att.file.open("rb"),
as_attachment=att.content_type not in INLINE_SAFE_CONTENT_TYPES,
filename=att.original_name,
content_type=att.content_type or "application/octet-stream",
)
def _handle_attachment_delete(request, actor: SplitActor, attachment_id):
att = get_object_or_404(SplitAttachment, id=attachment_id, event=actor.event)
can_delete = actor.is_creator or (
actor.participant and att.uploaded_by_id == actor.participant.id
)
if not can_delete and att.expense_id:
can_delete = actor.can_edit_item(
created_by_id=att.expense.created_by_participant_id,
primary_participant_id=att.expense.paid_by_id,
)
if not can_delete and att.payment_id:
can_delete = actor.can_edit_item(
created_by_id=att.payment.created_by_participant_id,
primary_participant_id=att.payment.from_participant_id,
)
if not can_delete:
raise PermissionDenied
att.file.delete(save=False)
att.delete()
messages.success(request, _("Attachment deleted"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, toasts"},
)
# WYGIWYH wrappers
@only_htmx
@login_required
def expense_add(request, event_id):
return _handle_expense_add(request, get_wygiwyh_actor(request, event_id))
@only_htmx
@login_required
def expense_edit(request, event_id, expense_id):
return _handle_expense_edit(request, get_wygiwyh_actor(request, event_id), expense_id)
@only_htmx
@login_required
@require_http_methods(["DELETE"])
def expense_delete(request, event_id, expense_id):
return _handle_expense_delete(request, get_wygiwyh_actor(request, event_id), expense_id)
@only_htmx
@login_required
def payment_add(request, event_id):
return _handle_payment_add(request, get_wygiwyh_actor(request, event_id))
@only_htmx
@login_required
def payment_edit(request, event_id, payment_id):
return _handle_payment_edit(request, get_wygiwyh_actor(request, event_id), payment_id)
@only_htmx
@login_required
@require_http_methods(["DELETE"])
def payment_delete(request, event_id, payment_id):
return _handle_payment_delete(request, get_wygiwyh_actor(request, event_id), payment_id)
@login_required
@require_http_methods(["GET"])
def attachment_download(request, event_id, attachment_id):
return _handle_attachment_download(get_wygiwyh_actor(request, event_id), attachment_id)
@only_htmx
@login_required
@require_http_methods(["DELETE"])
def attachment_delete(request, event_id, attachment_id):
return _handle_attachment_delete(request, get_wygiwyh_actor(request, event_id), attachment_id)
# =============================================================================
# WYGIWYH Transaction Integration Views
# =============================================================================
def _handle_sync_view(
request,
*,
actor: SplitActor,
kind: str,
default_amount: Decimal,
default_date,
default_notes: str,
post_url: str,
title: str,
expense: SplitExpense | None = None,
payment: SplitPayment | None = None,
counterparty: SplitParticipant | None = None,
default_is_paid: bool = True,
):
tx_type = expected_transaction_type_for_kind(kind)
default_desc = build_default_sync_description(
event=actor.event,
kind=kind,
expense=expense,
payment=payment,
counterparty=counterparty,
)
if request.method == "POST":
form = SplitTransactionSyncForm(
request.POST,
user=actor.user,
event=actor.event,
tx_type=tx_type,
)
if form.is_valid():
if form.cleaned_data["mode"] == SplitTransactionSyncForm.Mode.CREATE:
create_and_link_transaction(
user=actor.user,
event=actor.event,
kind=kind,
account=form.cleaned_data["account"],
amount=form.cleaned_data["amount"],
date=form.cleaned_data["date"],
description=form.cleaned_data["description"] or default_desc,
is_paid=form.cleaned_data["is_paid"],
category=form.cleaned_data.get("category"),
tags=form.cleaned_data.get("tags") or [],
entities=form.cleaned_data.get("entities") or [],
notes=form.cleaned_data.get("notes", ""),
expense=expense,
payment=payment,
counterparty=counterparty,
)
messages.success(
request, _("Transaction created and linked")
)
else:
link_existing_transaction(
user=actor.user,
event=actor.event,
kind=kind,
tx=form.cleaned_data["existing_transaction"],
expense=expense,
payment=payment,
counterparty=counterparty,
)
messages.success(
request, _("Transaction linked")
)
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, hide_offcanvas, toasts"},
)
else:
form = SplitTransactionSyncForm(
user=actor.user,
event=actor.event,
tx_type=tx_type,
initial={
"mode": SplitTransactionSyncForm.Mode.CREATE,
"amount": default_amount,
"date": default_date,
"description": default_desc,
"is_paid": default_is_paid,
"notes": default_notes,
},
)
return render(
request,
"splits/fragments/sync/form.html",
{
"form": form,
"event": actor.event,
"post_url": post_url,
"title": title,
"tx_type": tx_type,
},
)
@only_htmx
@login_required
def sync_expense(request, event_id, expense_id):
actor = get_wygiwyh_actor(request, event_id)
# Only the payer's money left one of their accounts
expense = get_object_or_404(
SplitExpense,
id=expense_id,
event=actor.event,
paid_by=actor.participant,
)
return _handle_sync_view(
request,
actor=actor,
kind=SplitTransactionLink.Kind.EXPENSE,
default_amount=expense.amount,
default_date=expense.date,
default_notes=expense.notes,
post_url=reverse(
"split_sync_expense",
kwargs={"event_id": actor.event.id, "expense_id": expense.id},
),
title=_("Add expense to my transactions"),
expense=expense,
default_is_paid=True,
)
@only_htmx
@login_required
def sync_payment(request, event_id, payment_id):
actor = get_wygiwyh_actor(request, event_id)
payment = get_object_or_404(
SplitPayment.objects.select_related("from_participant", "to_participant"),
id=payment_id,
event=actor.event,
)
me = actor.participant.id if actor.participant else None
if payment.to_participant_id == me:
kind = SplitTransactionLink.Kind.PAYMENT_IN
counterparty = payment.from_participant
title = _("Add received payment to my transactions")
elif payment.from_participant_id == me:
kind = SplitTransactionLink.Kind.PAYMENT_OUT
counterparty = payment.to_participant
title = _("Add sent payment to my transactions")
else:
raise Http404
return _handle_sync_view(
request,
actor=actor,
kind=kind,
default_amount=payment.amount,
default_date=payment.date,
default_notes=payment.notes,
post_url=reverse(
"split_sync_payment",
kwargs={"event_id": actor.event.id, "payment_id": payment.id},
),
title=title,
payment=payment,
counterparty=counterparty,
default_is_paid=True,
)
@only_htmx
@login_required
def sync_settlement(request, event_id):
actor = get_wygiwyh_actor(request, event_id)
direction = request.GET.get("direction") or request.POST.get("direction") or "out"
counterparty_id = request.GET.get("counterparty") or request.POST.get("counterparty")
raw_amount = request.GET.get("amount") or request.POST.get("amount") or "0"
counterparty = get_object_or_404(
SplitParticipant, id=counterparty_id, event=actor.event
)
try:
amount = Decimal(str(raw_amount))
except InvalidOperation:
amount = Decimal("0")
if direction == "in":
kind = SplitTransactionLink.Kind.SETTLEMENT_IN
title = _("Expected payment from %(name)s") % {
"name": counterparty.name
}
else:
kind = SplitTransactionLink.Kind.SETTLEMENT_OUT
title = _("Planned payment to %(name)s") % {
"name": counterparty.name
}
post_url = (
reverse("split_sync_settlement", kwargs={"event_id": actor.event.id})
+ f"?direction={direction}&counterparty={counterparty.id}&amount={amount}"
)
return _handle_sync_view(
request,
actor=actor,
kind=kind,
default_amount=amount,
default_date=timezone.localdate(),
default_notes="",
post_url=post_url,
title=title,
counterparty=counterparty,
default_is_paid=False,
)
@only_htmx
@login_required
@require_http_methods(["DELETE"])
def sync_unlink(request, event_id, link_id):
actor = get_wygiwyh_actor(request, event_id)
link = get_object_or_404(
SplitTransactionLink,
id=link_id,
event=actor.event,
user=actor.user,
)
link.delete()
messages.success(request, _("Transaction unlinked"))
return HttpResponse(
status=204,
headers={"HX-Trigger": "updated, toasts"},
)
# =============================================================================
# External Participant Portal Views (No WYGIWYH Account Required!)
# =============================================================================
def external_auth(request, share_token):
event = get_object_or_404(
SplitEvent.objects.select_related("currency", "creator"),
share_token=share_token,
)
if not event.allow_external_access:
return render(
request,
"splits/pages/external_disabled.html",
{"event": event},
status=403,
)
existing = get_external_participant_from_session(request, event)
if existing:
return redirect("split_external_event_detail", share_token=event.share_token)
external_participants = list(
event.participants.filter(is_external=True, is_active=True).order_by(
"name", "id"
)
)
if request.method == "POST":
form = ExternalAuthForm(request.POST, event=event)
if form.is_valid():
participant: SplitParticipant = form.cleaned_data["participant"]
if not participant.is_claimed:
participant.set_external_password(
form.cleaned_data["password"],
username=form.cleaned_data.get("username", ""),
)
set_external_session(request, event, participant)
return redirect(
"split_external_event_detail", share_token=event.share_token
)
else:
form = ExternalAuthForm(event=event)
return render(
request,
"splits/pages/external_auth.html",
{
"event": event,
"form": form,
"external_participants": external_participants,
"claimed_ids": [p.id for p in external_participants if p.is_claimed],
},
)
@require_http_methods(["POST"])
def external_logout(request, share_token):
event = get_object_or_404(SplitEvent, share_token=share_token)
clear_external_session(request, event)
return redirect("split_external_auth", share_token=event.share_token)
def external_event_detail(request, share_token):
actor = get_external_actor(request, share_token)
if actor is None:
return redirect("split_external_auth", share_token=share_token)
return render(
request,
"splits/pages/external_event_detail.html",
{
"event": actor.event,
"actor": actor,
"urls": _portal_urls(actor),
},
)
@only_htmx
def external_event_content(request, share_token):
actor = get_external_actor(request, share_token)
if actor is None:
return HttpResponse(
status=401,
headers={
"HX-Redirect": reverse(
"split_external_auth", kwargs={"share_token": share_token}
)
},
)
ctx = _build_event_context(request, actor)
return render(request, "splits/fragments/event/content.html", ctx)
def external_event_report(request, share_token):
actor = get_external_actor(request, share_token)
if actor is None:
return redirect("split_external_auth", share_token=share_token)
return render(
request, "splits/pages/event_report.html", _build_event_context(request, actor)
)
@only_htmx
@require_http_methods(["GET"])
def external_toasts(request, share_token):
actor = get_external_actor(request, share_token)
if actor is None:
return HttpResponse(status=204)
return render(request, "common/fragments/toasts.html")
@only_htmx
def external_expense_add(request, share_token):
actor = get_external_actor(request, share_token)
if actor is None:
return HttpResponse(status=401)
return _handle_expense_add(request, actor)
@only_htmx
def external_expense_edit(request, share_token, expense_id):
actor = get_external_actor(request, share_token)
if actor is None:
return HttpResponse(status=401)
return _handle_expense_edit(request, actor, expense_id)
@only_htmx
@require_http_methods(["DELETE"])
def external_expense_delete(request, share_token, expense_id):
actor = get_external_actor(request, share_token)
if actor is None:
return HttpResponse(status=401)
return _handle_expense_delete(request, actor, expense_id)
@only_htmx
def external_payment_add(request, share_token):
actor = get_external_actor(request, share_token)
if actor is None:
return HttpResponse(status=401)
return _handle_payment_add(request, actor)
@only_htmx
def external_payment_edit(request, share_token, payment_id):
actor = get_external_actor(request, share_token)
if actor is None:
return HttpResponse(status=401)
return _handle_payment_edit(request, actor, payment_id)
@only_htmx
@require_http_methods(["DELETE"])
def external_payment_delete(request, share_token, payment_id):
actor = get_external_actor(request, share_token)
if actor is None:
return HttpResponse(status=401)
return _handle_payment_delete(request, actor, payment_id)
@require_http_methods(["GET"])
def external_attachment_download(request, share_token, attachment_id):
actor = get_external_actor(request, share_token)
if actor is None:
return redirect("split_external_auth", share_token=share_token)
return _handle_attachment_download(actor, attachment_id)
@only_htmx
@require_http_methods(["DELETE"])
def external_attachment_delete(request, share_token, attachment_id):
actor = get_external_actor(request, share_token)
if actor is None:
return HttpResponse(status=401)
return _handle_attachment_delete(request, actor, attachment_id)