Files
FireworksApp/fireworks_detect/field_notes.py
T
2026-10-14 18:17:27 +02:00

101 lines
3.9 KiB
Python

"""Central access checks and association/reporting services for field notes."""
import uuid
from django.contrib.auth import get_user_model
from django.core import signing
from django.core.exceptions import PermissionDenied
from django.db import transaction
from django.db.models import Q
from django.http import Http404
from .models import Event, PendingEvent, FieldNote, FieldNoteContext, FieldNoteAssociation
def draft_token(user):
if not user.is_authenticated:
return ""
return signing.dumps({"author": user.pk, "id": str(uuid.uuid4())}, salt="field-notes")
def token_id(user, token):
try:
data = signing.loads(token, salt="field-notes", max_age=7 * 86400)
if data["author"] != user.pk:
raise ValueError
return uuid.UUID(data["id"])
except (signing.BadSignature, ValueError, KeyError, TypeError):
raise PermissionDenied("Invalid or expired note context. Reload the reporting page.")
def accessible_pending(user, session_ids=()):
if not user.is_authenticated:
return PendingEvent.objects.none()
if user.is_staff and user.has_perm("fireworks_detect.view_pendingevent"):
return PendingEvent.objects.all()
return PendingEvent.objects.filter(Q(note_contexts__author=user) | Q(sensor__owner=user) | Q(pk__in=session_ids)).distinct()
def target_snapshot(context):
if context.event_id:
return {"kind": "event", "id": context.event_id}
if context.pending_event_id:
return {"kind": "pending", "id": context.pending_event_id}
return {}
def associate(context, *, event=None, pending=None, actor=None, reason):
previous = target_snapshot(context)
context.event = event
context.pending_event = pending
context.full_clean()
context.save(update_fields=["event", "pending_event"])
FieldNoteAssociation.objects.create(context=context, actor=actor, previous=previous,
target=target_snapshot(context), reason=reason)
@transaction.atomic
def context_for_token(user, token):
# Serialize draft-note creation and report binding for the same author.
get_user_model().objects.select_for_update().get(pk=user.pk)
context, _ = FieldNoteContext.objects.get_or_create(id=token_id(user, token), defaults={"author": user})
if context.author_id != user.pk:
raise PermissionDenied
return context
@transaction.atomic
def bind_report(user, token, pending):
if not user.is_authenticated or not token:
return
context = context_for_token(user, token)
if context.event_id or context.pending_event_id:
raise PermissionDenied("This note context already belongs to a report. Reload before reporting again.")
associate(context, pending=pending, actor=user, reason="submission")
@transaction.atomic
def link_standalone(user, context_id, event):
# Approved events are publicly accessible in the existing application.
context = FieldNoteContext.objects.select_for_update().filter(pk=context_id, author=user).first()
if not context or context.event_id or context.pending_event_id:
raise Http404
associate(context, event=event, actor=user, reason="linked")
return context
@transaction.atomic
def regroup_event_notes(user, source, target):
"""Hook for future event-merging code; does not modify detection records."""
if not (user.is_staff and user.has_perm("fireworks_detect.change_event") and
user.has_perm("fireworks_detect.view_all_fieldnotes")):
raise PermissionDenied
if source.pk == target.pk:
return
for context in FieldNoteContext.objects.select_for_update().filter(event=source):
associate(context, event=target, actor=user, reason="regrouped")
def reportable_notes(user):
"""All exports, including future PDF reports, must start with this queryset."""
return FieldNote.objects.reportable_to(user).select_related("author", "context")