arthexis 0.1.11__py3-none-any.whl → 0.1.12__py3-none-any.whl

pages/forms.py

@@ -9,6 +9,8 @@ from django.core.exceptions import ValidationError
 from django.utils.translation import gettext_lazy as _
 from django.views.decorators.debug import sensitive_variables
 
+from .models import UserStory
+
 
 class AuthenticatorLoginForm(AuthenticationForm):
     """Authentication form that supports password or authenticator codes."""
@@ -129,3 +131,39 @@ class AuthenticatorEnrollmentForm(forms.Form):
 
     def get_verified_device(self):
         return self.device
+
+
+class UserStoryForm(forms.ModelForm):
+    class Meta:
+        model = UserStory
+        fields = ("name", "rating", "comments", "take_screenshot", "path")
+        widgets = {
+            "path": forms.HiddenInput(),
+            "comments": forms.Textarea(attrs={"rows": 4, "maxlength": 400}),
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["name"].required = False
+        self.fields["name"].widget.attrs.update(
+            {
+                "maxlength": 40,
+                "placeholder": _("Name, email or pseudonym"),
+            }
+        )
+        self.fields["take_screenshot"].initial = True
+        self.fields["rating"].widget = forms.RadioSelect(
+            choices=[(i, str(i)) for i in range(1, 6)]
+        )
+
+    def clean_comments(self):
+        comments = (self.cleaned_data.get("comments") or "").strip()
+        if len(comments) > 400:
+            raise forms.ValidationError(
+                _("Feedback must be 400 characters or fewer."), code="max_length"
+            )
+        return comments
+
+    def clean_name(self):
+        name = (self.cleaned_data.get("name") or "").strip()
+        return name[:40]

pages/models.py

@@ -4,11 +4,14 @@ from django.contrib.sites.models import Site
 from nodes.models import NodeRole
 from django.apps import apps as django_apps
 from django.utils.text import slugify
-from django.utils.translation import gettext_lazy as _
+from django.utils.translation import gettext, gettext_lazy as _
 from importlib import import_module
 from django.urls import URLPattern
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
+from django.core.validators import MaxLengthValidator, MaxValueValidator, MinValueValidator
+
+from core import github_issues
 
 
 class ApplicationManager(models.Manager):
@@ -279,6 +282,138 @@ class Favorite(Entity):
         unique_together = ("user", "content_type")
 
 
+class UserStory(Entity):
+    path = models.CharField(max_length=500)
+    name = models.CharField(max_length=40, blank=True)
+    rating = models.PositiveSmallIntegerField(
+        validators=[MinValueValidator(1), MaxValueValidator(5)],
+        help_text=_("Rate your experience from 1 (lowest) to 5 (highest)."),
+    )
+    comments = models.TextField(
+        validators=[MaxLengthValidator(400)],
+        help_text=_("Share more about your experience."),
+    )
+    take_screenshot = models.BooleanField(
+        default=True,
+        help_text=_("Request a screenshot capture for this feedback."),
+    )
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+        related_name="user_stories",
+    )
+    owner = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+        related_name="owned_user_stories",
+        help_text=_("Internal owner for this feedback."),
+    )
+    submitted_at = models.DateTimeField(auto_now_add=True)
+    github_issue_number = models.PositiveIntegerField(
+        blank=True,
+        null=True,
+        help_text=_("Number of the GitHub issue created for this feedback."),
+    )
+    github_issue_url = models.URLField(
+        blank=True,
+        help_text=_("Link to the GitHub issue created for this feedback."),
+    )
+
+    class Meta:
+        ordering = ["-submitted_at"]
+        verbose_name = _("User Story")
+        verbose_name_plural = _("User Stories")
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        display = self.name or _("Anonymous")
+        return f"{display} ({self.rating}/5)"
+
+    def get_github_issue_labels(self) -> list[str]:
+        """Return default labels used when creating GitHub issues."""
+
+        return ["feedback"]
+
+    def get_github_issue_fingerprint(self) -> str | None:
+        """Return a fingerprint used to avoid duplicate issue submissions."""
+
+        if self.pk:
+            return f"user-story:{self.pk}"
+        return None
+
+    def build_github_issue_title(self) -> str:
+        """Return the title used for GitHub issues."""
+
+        path = self.path or "/"
+        return gettext("Feedback for %(path)s (%(rating)s/5)") % {
+            "path": path,
+            "rating": self.rating,
+        }
+
+    def build_github_issue_body(self) -> str:
+        """Return the issue body summarising the feedback details."""
+
+        name = self.name or gettext("Anonymous")
+        path = self.path or "/"
+        screenshot_requested = gettext("Yes") if self.take_screenshot else gettext("No")
+
+        lines = [
+            f"**Path:** {path}",
+            f"**Rating:** {self.rating}/5",
+            f"**Name:** {name}",
+            f"**Screenshot requested:** {screenshot_requested}",
+        ]
+
+        if self.submitted_at:
+            lines.append(f"**Submitted at:** {self.submitted_at.isoformat()}")
+
+        comment = (self.comments or "").strip()
+        if comment:
+            lines.extend(["", comment])
+
+        return "\n".join(lines).strip()
+
+    def create_github_issue(self) -> str | None:
+        """Create a GitHub issue for this feedback and store the identifiers."""
+
+        if self.github_issue_url:
+            return self.github_issue_url
+
+        response = github_issues.create_issue(
+            self.build_github_issue_title(),
+            self.build_github_issue_body(),
+            labels=self.get_github_issue_labels(),
+            fingerprint=self.get_github_issue_fingerprint(),
+        )
+
+        if response is None:
+            return None
+
+        try:
+            payload = response.json()
+        except ValueError:  # pragma: no cover - defensive guard
+            payload = {}
+
+        issue_url = payload.get("html_url")
+        issue_number = payload.get("number")
+
+        update_fields = []
+        if issue_url and issue_url != self.github_issue_url:
+            self.github_issue_url = issue_url
+            update_fields.append("github_issue_url")
+        if issue_number is not None and issue_number != self.github_issue_number:
+            self.github_issue_number = issue_number
+            update_fields.append("github_issue_number")
+
+        if update_fields:
+            self.save(update_fields=update_fields)
+
+        return issue_url
+
+
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 

pages/tests.py

@@ -13,10 +13,18 @@ from urllib.parse import quote
 from django.contrib.auth import get_user_model
 from django.contrib.sites.models import Site
 from django.contrib import admin
+from django.contrib.messages.storage.fallback import FallbackStorage
 from django.core.exceptions import DisallowedHost
 import socket
-from pages.models import Application, Module, SiteBadge, Favorite, ViewHistory
-from pages.admin import ApplicationAdmin
+from pages.models import (
+    Application,
+    Module,
+    SiteBadge,
+    Favorite,
+    ViewHistory,
+    UserStory,
+)
+from pages.admin import ApplicationAdmin, UserStoryAdmin, ViewHistoryAdmin
 from pages.screenshot_specs import (
     ScreenshotSpec,
     ScreenshotSpecRunner,
@@ -33,6 +41,7 @@ from core.models import (
     Reference,
     ReleaseManager,
     Todo,
+    TOTPDeviceSettings,
 )
 from django.core.files.uploadedfile import SimpleUploadedFile
 import base64
@@ -41,12 +50,18 @@ import shutil
 from io import StringIO
 from django.conf import settings
 from pathlib import Path
-from unittest.mock import patch, Mock
+from unittest.mock import MagicMock, Mock, patch
 from types import SimpleNamespace
 from django.core.management import call_command
 import re
 from django.contrib.contenttypes.models import ContentType
-from datetime import date, timedelta
+from datetime import (
+    date,
+    datetime,
+    time as datetime_time,
+    timedelta,
+    timezone as datetime_timezone,
+)
 from django.core import mail
 from django.utils import timezone
 from django.utils.text import slugify
@@ -84,6 +99,14 @@ class LoginViewTests(TestCase):
         resp = self.client.get(reverse("pages:login"))
         self.assertContains(resp, "Use Authenticator app")
 
+    def test_cp_simulator_redirect_shows_restricted_message(self):
+        simulator_path = reverse("cp-simulator")
+        resp = self.client.get(f"{reverse('pages:login')}?next={simulator_path}")
+        self.assertContains(
+            resp,
+            "This page is reserved for members only. Please log in to continue.",
+        )
+
     def test_staff_login_redirects_admin(self):
         resp = self.client.post(
             reverse("pages:login"),
@@ -303,6 +326,15 @@ class AuthenticatorSetupTests(TestCase):
         self.assertIn(label, config_url)
         self.assertIn(f"issuer={quote(settings.OTP_TOTP_ISSUER)}", config_url)
 
+    def test_device_config_url_uses_custom_issuer_when_available(self):
+        self.client.post(reverse("pages:authenticator-setup"), {"action": "generate"})
+        device = TOTPDevice.objects.get(user=self.staff)
+        TOTPDeviceSettings.objects.create(device=device, issuer="Custom Co")
+        config_url = device.config_url
+        quoted_issuer = quote("Custom Co")
+        self.assertIn(quoted_issuer, config_url)
+        self.assertIn(f"issuer={quoted_issuer}", config_url)
+
     def test_pending_device_context_includes_qr(self):
         self.client.post(reverse("pages:authenticator-setup"), {"action": "generate"})
         resp = self.client.get(reverse("pages:authenticator-setup"))
@@ -731,6 +763,7 @@ class ViewHistoryAdminTests(TestCase):
         self.assertContains(resp, static("core/vendor/chart.umd.min.js"))
 
     def test_graph_data_endpoint(self):
+        ViewHistory.all_objects.all().delete()
         self._create_history("/", count=2)
         self._create_history("/about/", days_offset=1)
         url = reverse("admin:pages_viewhistory_traffic_data")
@@ -746,6 +779,44 @@ class ViewHistoryAdminTests(TestCase):
         self.assertEqual(totals.get("/"), 2)
         self.assertEqual(totals.get("/about/"), 1)
 
+    def test_graph_data_includes_late_evening_visits(self):
+        target_date = date(2025, 9, 27)
+        entry = ViewHistory.objects.create(
+            path="/late/",
+            method="GET",
+            status_code=200,
+            status_text="OK",
+            error_message="",
+            view_name="pages:index",
+        )
+        local_evening = datetime.combine(target_date, datetime_time(21, 30))
+        aware_evening = timezone.make_aware(
+            local_evening, timezone.get_current_timezone()
+        )
+        entry.visited_at = aware_evening.astimezone(datetime_timezone.utc)
+        entry.save(update_fields=["visited_at"])
+
+        url = reverse("admin:pages_viewhistory_traffic_data")
+        with patch("pages.admin.timezone.localdate", return_value=target_date):
+            resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        data = resp.json()
+        totals = {
+            dataset["label"]: sum(dataset["data"]) for dataset in data["datasets"]
+        }
+        self.assertEqual(totals.get("/late/"), 1)
+
+    def test_graph_data_filters_using_datetime_range(self):
+        admin_view = ViewHistoryAdmin(ViewHistory, admin.site)
+        with patch.object(ViewHistory.objects, "filter") as mock_filter:
+            mock_queryset = mock_filter.return_value
+            mock_queryset.exists.return_value = False
+            admin_view._build_chart_data()
+
+        kwargs = mock_filter.call_args.kwargs
+        self.assertIn("visited_at__gte", kwargs)
+        self.assertIn("visited_at__lt", kwargs)
+
     def test_admin_index_displays_widget(self):
         resp = self.client.get(reverse("admin:index"))
         self.assertContains(resp, "viewhistory-mini-module")
@@ -1339,6 +1410,29 @@ class FaviconTests(TestCase):
             )
             self.assertContains(resp, b64)
 
+    def test_control_nodes_use_purple_favicon(self):
+        with override_settings(MEDIA_ROOT=self.tmpdir):
+            role, _ = NodeRole.objects.get_or_create(name="Control")
+            Node.objects.update_or_create(
+                mac_address=Node.get_current_mac(),
+                defaults={
+                    "hostname": "localhost",
+                    "address": "127.0.0.1",
+                    "role": role,
+                },
+            )
+            Site.objects.update_or_create(
+                id=1, defaults={"domain": "testserver", "name": ""}
+            )
+            resp = self.client.get(reverse("pages:index"))
+            b64 = (
+                Path(settings.BASE_DIR)
+                .joinpath("pages", "fixtures", "data", "favicon_control.txt")
+                .read_text()
+                .strip()
+            )
+            self.assertContains(resp, b64)
+
 
 class FavoriteTests(TestCase):
     def setUp(self):
@@ -1727,6 +1821,170 @@ class DatasetteTests(TestCase):
             lock_file.unlink(missing_ok=True)
 
 
+class UserStorySubmissionTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.url = reverse("pages:user-story-submit")
+        User = get_user_model()
+        self.user = User.objects.create_user(username="feedbacker", password="pwd")
+
+    def test_authenticated_submission_defaults_to_username(self):
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 5,
+                "comments": "Loved the experience!",
+                "path": "/wizard/step-1/",
+                "take_screenshot": "1",
+            },
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"success": True})
+        story = UserStory.objects.get()
+        self.assertEqual(story.name, "feedbacker")
+        self.assertEqual(story.rating, 5)
+        self.assertEqual(story.path, "/wizard/step-1/")
+        self.assertEqual(story.user, self.user)
+        self.assertEqual(story.owner, self.user)
+        self.assertTrue(story.is_user_data)
+        self.assertTrue(story.take_screenshot)
+
+    def test_anonymous_submission_uses_provided_name(self):
+        response = self.client.post(
+            self.url,
+            {
+                "name": "Guest Reviewer",
+                "rating": 3,
+                "comments": "It was fine.",
+                "path": "/status/",
+                "take_screenshot": "on",
+            },
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(UserStory.objects.count(), 1)
+        story = UserStory.objects.get()
+        self.assertEqual(story.name, "Guest Reviewer")
+        self.assertIsNone(story.user)
+        self.assertIsNone(story.owner)
+        self.assertEqual(story.comments, "It was fine.")
+        self.assertTrue(story.take_screenshot)
+
+    def test_invalid_rating_returns_errors(self):
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 7,
+                "comments": "Way off the scale",
+                "path": "/feedback/",
+                "take_screenshot": "1",
+            },
+        )
+        self.assertEqual(response.status_code, 400)
+        data = response.json()
+        self.assertFalse(UserStory.objects.exists())
+        self.assertIn("rating", data.get("errors", {}))
+
+    def test_anonymous_submission_without_name_uses_fallback(self):
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 2,
+                "comments": "Could be better.",
+                "path": "/feedback/",
+                "take_screenshot": "1",
+            },
+        )
+        self.assertEqual(response.status_code, 200)
+        story = UserStory.objects.get()
+        self.assertEqual(story.name, "Anonymous")
+        self.assertIsNone(story.user)
+        self.assertIsNone(story.owner)
+        self.assertTrue(story.take_screenshot)
+
+    def test_submission_without_screenshot_request(self):
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 4,
+                "comments": "Skip the screenshot, please.",
+                "path": "/feedback/",
+            },
+        )
+        self.assertEqual(response.status_code, 200)
+        story = UserStory.objects.get()
+        self.assertFalse(story.take_screenshot)
+        self.assertIsNone(story.owner)
+
+
+class UserStoryAdminActionTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.factory = RequestFactory()
+        User = get_user_model()
+        self.admin_user = User.objects.create_superuser(
+            username="admin",
+            email="admin@example.com",
+            password="pwd",
+        )
+        self.story = UserStory.objects.create(
+            path="/",
+            name="Feedback",
+            rating=4,
+            comments="Helpful notes",
+            take_screenshot=True,
+        )
+        self.admin = UserStoryAdmin(UserStory, admin.site)
+
+    def _build_request(self):
+        request = self.factory.post("/admin/pages/userstory/")
+        request.user = self.admin_user
+        request.session = self.client.session
+        setattr(request, "_messages", FallbackStorage(request))
+        return request
+
+    @patch("pages.models.github_issues.create_issue")
+    def test_create_github_issues_action_updates_issue_fields(self, mock_create_issue):
+        response = MagicMock()
+        response.json.return_value = {
+            "html_url": "https://github.com/example/repo/issues/123",
+            "number": 123,
+        }
+        mock_create_issue.return_value = response
+
+        request = self._build_request()
+        queryset = UserStory.objects.filter(pk=self.story.pk)
+        self.admin.create_github_issues(request, queryset)
+
+        self.story.refresh_from_db()
+        self.assertEqual(self.story.github_issue_number, 123)
+        self.assertEqual(
+            self.story.github_issue_url,
+            "https://github.com/example/repo/issues/123",
+        )
+
+        mock_create_issue.assert_called_once()
+        args, kwargs = mock_create_issue.call_args
+        self.assertIn("Feedback for", args[0])
+        self.assertIn("**Rating:**", args[1])
+        self.assertEqual(kwargs.get("labels"), ["feedback"])
+        self.assertEqual(
+            kwargs.get("fingerprint"), f"user-story:{self.story.pk}"
+        )
+
+    @patch("pages.models.github_issues.create_issue")
+    def test_create_github_issues_action_skips_existing_issue(self, mock_create_issue):
+        self.story.github_issue_url = "https://github.com/example/repo/issues/5"
+        self.story.github_issue_number = 5
+        self.story.save(update_fields=["github_issue_url", "github_issue_number"])
+
+        request = self._build_request()
+        queryset = UserStory.objects.filter(pk=self.story.pk)
+        self.admin.create_github_issues(request, queryset)
+
+        mock_create_issue.assert_not_called()
+
+
 class ClientReportLiveUpdateTests(TestCase):
     def setUp(self):
         self.client = Client()

pages/urls.py

@@ -21,4 +21,5 @@ urlpatterns = [
     path("man/", views.manual_list, name="manual-list"),
     path("man/<slug:slug>/", views.manual_detail, name="manual-detail"),
     path("man/<slug:slug>/pdf/", views.manual_pdf, name="manual-pdf"),
+    path("feedback/user-story/", views.submit_user_story, name="user-story-submit"),
 ]

pages/views.py

@@ -8,6 +8,7 @@ import io
 import shutil
 import re
 from html import escape
+from urllib.parse import urlparse
 
 from django.conf import settings
 from django.contrib import admin
@@ -19,7 +20,7 @@ from django.contrib.auth.views import LoginView
 from django import forms
 from django.apps import apps as django_apps
 from utils.sites import get_site
-from django.http import Http404, HttpResponse
+from django.http import Http404, HttpResponse, JsonResponse
 from django.shortcuts import get_object_or_404, redirect, render
 from nodes.models import Node
 from django.template.response import TemplateResponse
@@ -32,6 +33,7 @@ from core import mailer, public_wifi
 from core.backends import TOTP_DEVICE_NAME
 from django.utils.translation import gettext as _
 from django.views.decorators.csrf import csrf_exempt, ensure_csrf_cookie
+from django.views.decorators.http import require_POST
 from django.core.cache import cache
 from django.views.decorators.cache import never_cache
 from django.utils.cache import patch_vary_headers
@@ -78,8 +80,12 @@ from core.liveupdate import live_update
 from django_otp import login as otp_login
 from django_otp.plugins.otp_totp.models import TOTPDevice
 import qrcode
-from .forms import AuthenticatorEnrollmentForm, AuthenticatorLoginForm
-from .models import Module, UserManual
+from .forms import (
+    AuthenticatorEnrollmentForm,
+    AuthenticatorLoginForm,
+    UserStoryForm,
+)
+from .models import Module, UserManual, UserStory
 
 
 logger = logging.getLogger(__name__)
@@ -494,12 +500,26 @@ class CustomLoginView(LoginView):
     def get_context_data(self, **kwargs):
         context = super(LoginView, self).get_context_data(**kwargs)
         current_site = get_site(self.request)
+        redirect_target = self.request.GET.get(self.redirect_field_name)
+        restricted_notice = None
+        if redirect_target:
+            parsed_target = urlparse(redirect_target)
+            target_path = parsed_target.path or redirect_target
+            try:
+                simulator_path = reverse("cp-simulator")
+            except NoReverseMatch:  # pragma: no cover - simulator may be uninstalled
+                simulator_path = None
+            if simulator_path and target_path.startswith(simulator_path):
+                restricted_notice = _(
+                    "This page is reserved for members only. Please log in to continue."
+                )
         context.update(
             {
                 "site": current_site,
                 "site_name": getattr(current_site, "name", ""),
                 "next": self.get_success_url(),
                 "can_request_invite": mailer.can_send_email(),
+                "restricted_notice": restricted_notice,
             }
         )
         return context
@@ -1015,6 +1035,35 @@ def client_report(request):
     return render(request, "pages/client_report.html", context)
 
 
+@require_POST
+def submit_user_story(request):
+    data = request.POST.copy()
+    if request.user.is_authenticated and not data.get("name"):
+        data["name"] = request.user.get_username()[:40]
+    if not data.get("path"):
+        data["path"] = request.get_full_path()
+
+    form = UserStoryForm(data)
+    if request.user.is_authenticated:
+        form.instance.user = request.user
+
+    if form.is_valid():
+        story = form.save(commit=False)
+        if request.user.is_authenticated:
+            story.user = request.user
+            story.owner = request.user
+            if not story.name:
+                story.name = request.user.get_username()[:40]
+        if not story.name:
+            story.name = str(_("Anonymous"))[:40]
+        story.path = (story.path or request.get_full_path())[:500]
+        story.is_user_data = True
+        story.save()
+        return JsonResponse({"success": True})
+
+    return JsonResponse({"success": False, "errors": form.errors}, status=400)
+
+
 def csrf_failure(request, reason=""):
     """Custom CSRF failure view with a friendly message."""
     logger.warning("CSRF failure on %s: %s", request.path, reason)