mobile menu added

This commit is contained in:
Joren de Graaf
2026-10-02 13:13:38 +02:00
parent 13258e76c3
commit c047bd9843
51 changed files with 780 additions and 18 deletions
Binary file not shown.
Binary file not shown.
Binary file not shown.
+57
View File
@@ -1,11 +1,18 @@
import json
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen
from django.contrib import admin, messages
from django.core.exceptions import PermissionDenied
from django.http import HttpResponseNotAllowed
from django.shortcuts import get_object_or_404, redirect
from django.urls import path, reverse
from django.utils import timezone
from django.utils.html import format_html
from django.utils.translation import gettext as _, gettext_lazy, ngettext
from .models import ClassificationRule, Event, PendingEvent, Sensor
from . import views as classifier_views
@admin.register(ClassificationRule)
@@ -35,6 +42,56 @@ class ClassificationAdmin(admin.ModelAdmin):
@admin.register(PendingEvent)
class PendingEventAdmin(ClassificationAdmin):
actions = ("approve_selected", "deny_selected")
change_form_template = "admin/fireworks_detect/pending_change_form.html"
def get_urls(self):
custom_urls = [
path(
"<path:object_id>/classify/",
self.admin_site.admin_view(self.classify_record),
name="fireworks_detect_pendingevent_classify",
),
]
return custom_urls + super().get_urls()
def classify_record(self, request, object_id):
if request.method != "POST":
return HttpResponseNotAllowed(["POST"])
pending = get_object_or_404(PendingEvent, pk=object_id)
if not self.has_change_permission(request, pending):
raise PermissionDenied
change_url = reverse("admin:fireworks_detect_pendingevent_change", args=[pending.pk])
if not pending.audio_file:
self.message_user(request, _("This Pending event has no attached audio to classify."), messages.ERROR)
return redirect(change_url)
try:
if pending.audio_file.size > classifier_views.MAX_AUDIO_SIZE:
self.message_user(request, _("The attached audio exceeds the 25 MiB limit."), messages.ERROR)
return redirect(change_url)
with pending.audio_file.open("rb") as audio:
body, content_type = classifier_views._encode_audio_multipart(audio)
classifier_request = Request(
classifier_views.CLASSIFIER_URL,
data=body,
headers={"Content-Type": content_type, "Accept": "application/json"},
method="POST",
)
with urlopen(classifier_request, timeout=60) as response:
payload = json.loads(response.read().decode("utf-8"))
if not isinstance(payload, dict):
raise ValueError("Classifier response must be a JSON object")
except HTTPError as error:
self.message_user(request, _("The classifier returned HTTP %(code)s.") % {"code": error.code}, messages.ERROR)
return redirect(change_url)
except (URLError, TimeoutError, OSError, UnicodeDecodeError, json.JSONDecodeError, ValueError):
self.message_user(request, _("The classifier could not be reached or returned invalid JSON."), messages.ERROR)
return redirect(change_url)
previous_response = pending.classifier_response if isinstance(pending.classifier_response, dict) else {}
pending.classifier_response = {**previous_response, **payload}
pending.save(update_fields=["classifier_response"])
self.message_user(request, _("Classification saved. This event remains Pending."), messages.SUCCESS)
return redirect(change_url)
def has_add_permission(self, request):
return False
@@ -1,9 +1,9 @@
{% load i18n %}
<section class="manual-report" aria-labelledby="manual-report-title">
<p class="eyebrow">{% trans "No recording needed" %}</p>
<p class="eyebrow">{% trans "Recording optional" %}</p>
<h2 class="manual-report__title" id="manual-report-title">{% trans "Report fireworks now" %}</h2>
<p class="manual-report__intro">{% trans "Choose how many times you heard fireworks, then send it straight to Pending. The report is timestamped now." %}</p>
<form id="manual-report-form" action="{% url "fireworks_detect:submit_manual_pending" %}" method="post" hx-post="{% url "fireworks_detect:submit_manual_pending" %}" hx-target="#manual-submission" hx-swap="outerHTML">
<form id="manual-report-form" action="{% url "fireworks_detect:submit_manual_pending" %}" method="post" enctype="multipart/form-data" hx-post="{% url "fireworks_detect:submit_manual_pending" %}" hx-target="#manual-submission" hx-swap="outerHTML">
{% csrf_token %}
<label class="manual-report__label" for="manual-occurrences">{% trans "Number of occurrences" %}</label>
<input id="manual-latitude" name="latitude" type="hidden">
@@ -18,6 +18,21 @@
<div id="manual-direction-status" class="manual-direction-panel__status" aria-live="polite"></div>
</div>
<button id="manual-submit" class="manual-report__submit" type="button">{% trans "I heard fireworks — send to Pending" %}</button>
<div class="burst-listener">
<button id="burst-start" class="burst-listener__button" type="button">{% trans "Listen for next bang" %}</button>
<div id="burst-panel" class="burst-listener__panel" hidden>
<strong id="burst-heading" aria-live="polite"></strong>
<canvas id="burst-waveform" width="600" height="90" aria-label="{% trans 'Live microphone waveform' %}"></canvas>
<p id="burst-detail"></p>
<audio id="burst-preview" controls hidden></audio>
<div class="burst-listener__actions">
<button id="burst-resume" type="button" hidden>{% trans "Resume listening" %}</button>
<button id="burst-discard" type="button" hidden>{% trans "Discard clip" %}</button>
<button id="burst-stop" type="button">{% trans "Stop listening" %}</button>
</div>
</div>
<p id="burst-error" role="alert" hidden></p>
</div>
</form>
<div id="manual-submission" class="manual-report__submission" aria-live="polite"></div>
</section>
@@ -1,7 +1,8 @@
{% load i18n %}
<header class="fireworks-header">
<button class="fireworks-menu-toggle" type="button" aria-label="{% trans "Open menu" %}" data-open-label="{% trans "Open menu" %}" data-close-label="{% trans "Close menu" %}" aria-controls="fireworks-header-controls" aria-expanded="false"><span></span><span></span><span></span></button>
<a class="fireworks-brand" href="{% url "fireworks_detect:fireworks" %}"><span class="brand-mark">✦</span> Sound Signal</a>
<div class="fireworks-header__controls">
<div class="fireworks-header__controls" id="fireworks-header-controls">
<nav class="fireworks-nav" aria-label="{% trans "Fireworks navigation" %}">
<a href="{% url "fireworks_detect:fireworks" %}"{% if active_page == "analyse" %} aria-current="page"{% endif %}>{% trans "Analyse" %}</a>
<a href="{% url "fireworks_detect:map" %}"{% if active_page == "map" %} aria-current="page"{% endif %}>{% trans "Map" %}</a>
+112
View File
@@ -1,7 +1,13 @@
from datetime import timedelta
from decimal import Decimal
from unittest.mock import MagicMock, patch
from urllib.error import URLError
from django.core.exceptions import ValidationError
from django.core.files.uploadedfile import SimpleUploadedFile
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.contrib.messages import get_messages, constants as message_levels
from django.db import IntegrityError, transaction
from django.test import TestCase, override_settings
from django.urls import reverse
@@ -79,6 +85,40 @@ class ManualPendingEventTests(TestCase):
self.assertContains(response, "Choose between 1 and 1,000 occurrences.", status_code=400)
self.assertFalse(PendingEvent.objects.exists())
def test_manual_report_accepts_optional_wav_on_the_same_pending_event(self):
from tempfile import TemporaryDirectory
with TemporaryDirectory() as media_root, override_settings(MEDIA_ROOT=media_root):
wav = SimpleUploadedFile("browser.wav", b"RIFF" + b"\x00" * 4 + b"WAVEfmt ", content_type="audio/wav")
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {"occurrences": "1", "audio": wav})
self.assertEqual(response.status_code, 200)
pending = PendingEvent.objects.get()
self.assertEqual(pending.source_type, PendingEvent.SourceType.MANUAL)
self.assertIn("sound-signal-manual-", pending.audio_file.name)
self.assertNotIn("browser.wav", pending.audio_file.name)
def test_manual_report_rejects_non_wav_attachment(self):
audio = SimpleUploadedFile("bad.wav", b"not a WAV file", content_type="audio/wav")
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {"occurrences": "1", "audio": audio})
self.assertEqual(response.status_code, 400)
self.assertFalse(PendingEvent.objects.exists())
def test_pending_admin_change_page_renders_for_manual_audio(self):
staff = get_user_model().objects.create_superuser("pending-reviewer", "reviewer@example.com", "test-password")
pending = PendingEvent.objects.create(
original_filename="Manual fireworks report",
classifier_response={},
source_type=PendingEvent.SourceType.MANUAL,
audio_file="fireworks_audio/example.wav",
)
self.client.force_login(staff)
response = self.client.get(reverse("admin:fireworks_detect_pendingevent_change", args=[pending.pk]))
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'class="audio-play"')
def test_event_details_and_source_type_are_kept_when_a_pending_event_is_approved(self):
pending = PendingEvent.objects.create(
original_filename="Manual fireworks report",
@@ -273,3 +313,75 @@ class ManualPendingEventTests(TestCase):
self.assertIsNone(saved.direction_degrees)
self.assertIsNone(saved.direction_accuracy_degrees)
self.assertEqual(saved.direction_source, "")
class PendingClassificationAdminTests(TestCase):
def setUp(self):
self.client.cookies["django_language"] = "en"
self.staff = get_user_model().objects.create_superuser("classifier-reviewer", "classifier@example.com", "test-password")
self.client.force_login(self.staff)
def test_classify_button_saves_json_without_approving(self):
from tempfile import TemporaryDirectory
with TemporaryDirectory() as media_root, override_settings(MEDIA_ROOT=media_root):
audio = SimpleUploadedFile("sample.wav", b"RIFF" + b"\x00" * 4 + b"WAVEdata", content_type="audio/wav")
pending = PendingEvent.objects.create(original_filename="Manual fireworks report", classifier_response={"manual_note": "keep"}, source_type=PendingEvent.SourceType.MANUAL, audio_file=audio)
url = reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk])
change = self.client.get(reverse("admin:fireworks_detect_pendingevent_change", args=[pending.pk]))
self.assertContains(change, url)
mocked_response = MagicMock()
mocked_response.read.return_value = b'{"predictions": [{"class": "Fireworks", "score": 0.91}]}'
mocked_response.__enter__.return_value = mocked_response
with patch("fireworks_detect.admin.urlopen", return_value=mocked_response) as classifier_call:
response = self.client.post(url)
self.assertEqual(response.status_code, 302)
request = classifier_call.call_args.args[0]
self.assertIn(b'name="file"', request.data)
self.assertIn(b"RIFF", request.data)
pending.refresh_from_db()
self.assertEqual(pending.classifier_response["predictions"][0]["class"], "Fireworks")
self.assertEqual(pending.classifier_response["manual_note"], "keep")
self.assertTrue(PendingEvent.objects.filter(pk=pending.pk).exists())
self.assertFalse(Event.objects.exists())
def test_classify_requires_post_and_audio(self):
pending = PendingEvent.objects.create(original_filename="Manual report", classifier_response={})
url = reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk])
self.assertEqual(self.client.get(url).status_code, 405)
self.assertEqual(self.client.post(url).status_code, 302)
pending.refresh_from_db()
self.assertEqual(pending.classifier_response, {})
def test_classifier_failure_preserves_existing_json_and_pending_record(self):
from tempfile import TemporaryDirectory
with TemporaryDirectory() as media_root, override_settings(MEDIA_ROOT=media_root):
pending = PendingEvent.objects.create(
original_filename="sample.wav",
classifier_response={"previous": "result"},
audio_file=SimpleUploadedFile("sample.wav", b"RIFFdata", content_type="audio/wav"),
)
url = reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk])
with patch("fireworks_detect.admin.urlopen", side_effect=URLError("offline")):
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(any(message.level == message_levels.ERROR for message in get_messages(response.wsgi_request)))
pending.refresh_from_db()
self.assertEqual(pending.classifier_response, {"previous": "result"})
self.assertTrue(PendingEvent.objects.filter(pk=pending.pk).exists())
def test_view_only_staff_cannot_classify(self):
pending = PendingEvent.objects.create(original_filename="sample.wav", classifier_response={}, audio_file="fireworks_audio/sample.wav")
viewer = get_user_model().objects.create_user("viewer", "viewer@example.com", "test-password", is_staff=True)
viewer.user_permissions.add(Permission.objects.get(codename="view_pendingevent"))
self.client.force_login(viewer)
change = self.client.get(reverse("admin:fireworks_detect_pendingevent_change", args=[pending.pk]))
self.assertEqual(change.status_code, 200)
self.assertNotContains(change, reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk]))
response = self.client.post(reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk]))
self.assertEqual(response.status_code, 403)
+12 -1
View File
@@ -216,7 +216,7 @@ def _encode_audio_multipart(uploaded_file):
"""Build the multipart request expected by the classifier without a third-party HTTP client."""
boundary = f"----DjangoAudioUpload{uuid.uuid4().hex}"
filename = Path(uploaded_file.name).name.replace('"', "")
content_type = uploaded_file.content_type or mimetypes.guess_type(filename)[0] or "application/octet-stream"
content_type = getattr(uploaded_file, "content_type", None) or mimetypes.guess_type(filename)[0] or "application/octet-stream"
header = (
f"--{boundary}\r\n"
f'Content-Disposition: form-data; name="file"; filename="{filename}"\r\n'
@@ -346,11 +346,22 @@ def submit_manual_pending_event(request):
status=400,
)
uploaded_file = request.FILES.get("audio")
if uploaded_file:
if uploaded_file.size > MAX_AUDIO_SIZE or uploaded_file.content_type not in ("audio/wav", "audio/wave", "audio/x-wav"):
return render(request, "fireworks_detect/manual_pending_submission.html", {"error": _("Please attach a WAV clip no larger than 25 MiB.")}, status=400)
header = uploaded_file.read(12)
uploaded_file.seek(0)
if len(header) != 12 or header[:4] != b"RIFF" or header[8:] != b"WAVE":
return render(request, "fireworks_detect/manual_pending_submission.html", {"error": _("The attached audio is not a WAV file.")}, status=400)
uploaded_file.name = f"sound-signal-manual-{timezone.now():%Y%m%d-%H%M%S}-{uuid.uuid4().hex[:8]}.wav"
latitude, longitude = _manual_coordinates(request)
h3_cell = cell_from_coordinates(latitude, longitude)
direction_degrees, direction_accuracy_degrees = _manual_direction(request)
pending = PendingEvent.objects.create(
audio_file=uploaded_file,
original_filename="Manual fireworks report",
classifier_response={},
source_type=PendingEvent.SourceType.MANUAL,