arthexis 0.1.21__py3-none-any.whl → 0.1.22__py3-none-any.whl

pages/admin.py

@@ -595,7 +595,23 @@ class ViewHistoryAdmin(EntityModelAdmin):
         )
 
     def traffic_data_view(self, request):
-        return JsonResponse(self._build_chart_data())
+        return JsonResponse(
+            self._build_chart_data(days=self._resolve_requested_days(request))
+        )
+
+    def _resolve_requested_days(self, request, default: int = 30) -> int:
+        raw_value = request.GET.get("days")
+        if raw_value in (None, ""):
+            return default
+
+        try:
+            days = int(raw_value)
+        except (TypeError, ValueError):
+            return default
+
+        minimum = 1
+        maximum = 90
+        return max(minimum, min(days, maximum))
 
     def _build_chart_data(self, days: int = 30, max_pages: int = 8) -> dict:
         end_date = timezone.localdate()
@@ -689,11 +705,13 @@ class UserStoryAdmin(EntityModelAdmin):
     actions = ["create_github_issues"]
     list_display = (
         "name",
+        "language_code",
         "rating",
         "path",
         "status",
         "submitted_at",
         "github_issue_display",
+        "screenshot_display",
         "take_screenshot",
         "owner",
         "assign_to",
@@ -703,6 +721,7 @@ class UserStoryAdmin(EntityModelAdmin):
         "name",
         "comments",
         "path",
+        "language_code",
         "referer",
         "github_issue_url",
         "ip_address",
@@ -715,6 +734,7 @@ class UserStoryAdmin(EntityModelAdmin):
         "path",
         "user",
         "owner",
+        "language_code",
         "referer",
         "user_agent",
         "ip_address",
@@ -722,6 +742,7 @@ class UserStoryAdmin(EntityModelAdmin):
         "submitted_at",
         "github_issue_number",
         "github_issue_url",
+        "screenshot_display",
     )
     ordering = ("-submitted_at",)
     fields = (
@@ -729,7 +750,9 @@ class UserStoryAdmin(EntityModelAdmin):
         "rating",
         "comments",
         "take_screenshot",
+        "screenshot_display",
         "path",
+        "language_code",
         "user",
         "owner",
         "status",
@@ -758,6 +781,21 @@ class UserStoryAdmin(EntityModelAdmin):
             )
         if obj.github_issue_number is not None:
             return f"#{obj.github_issue_number}"
+        return ""
+
+    @admin.display(description=_("Screenshot"), ordering="screenshot")
+    def screenshot_display(self, obj):
+        if not obj.screenshot_id:
+            return ""
+        try:
+            url = reverse("admin:nodes_contentsample_change", args=[obj.screenshot_id])
+        except NoReverseMatch:
+            return obj.screenshot.path
+        return format_html(
+            '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+            url,
+            _("View screenshot"),
+        )
         return _("Not created")
 
     @admin.action(description=_("Create GitHub issues"))
@@ -842,34 +880,93 @@ def favorite_toggle(request, ct_id):
     ct = get_object_or_404(ContentType, pk=ct_id)
     fav = Favorite.objects.filter(user=request.user, content_type=ct).first()
     next_url = request.GET.get("next")
-    if fav:
-        return redirect(next_url or "admin:favorite_list")
     if request.method == "POST":
+        if fav and request.POST.get("remove"):
+            fav.delete()
+            return redirect(next_url or "admin:index")
         label = request.POST.get("custom_label", "").strip()
         user_data = request.POST.get("user_data") == "on"
-        Favorite.objects.create(
-            user=request.user,
-            content_type=ct,
-            custom_label=label,
-            user_data=user_data,
-        )
+        priority_raw = request.POST.get("priority", "").strip()
+        if fav:
+            default_priority = fav.priority
+        else:
+            default_priority = 0
+        if priority_raw:
+            try:
+                priority = int(priority_raw)
+            except (TypeError, ValueError):
+                priority = default_priority
+        else:
+            priority = default_priority
+
+        if fav:
+            update_fields = []
+            if fav.custom_label != label:
+                fav.custom_label = label
+                update_fields.append("custom_label")
+            if fav.user_data != user_data:
+                fav.user_data = user_data
+                update_fields.append("user_data")
+            if fav.priority != priority:
+                fav.priority = priority
+                update_fields.append("priority")
+            if update_fields:
+                fav.save(update_fields=update_fields)
+        else:
+            Favorite.objects.create(
+                user=request.user,
+                content_type=ct,
+                custom_label=label,
+                user_data=user_data,
+                priority=priority,
+            )
         return redirect(next_url or "admin:index")
     return render(
         request,
         "admin/favorite_confirm.html",
-        {"content_type": ct, "next": next_url},
+        {
+            "content_type": ct,
+            "favorite": fav,
+            "next": next_url,
+            "initial_label": fav.custom_label if fav else "",
+            "initial_priority": fav.priority if fav else 0,
+            "is_checked": fav.user_data if fav else True,
+        },
     )
 
 
 def favorite_list(request):
-    favorites = Favorite.objects.filter(user=request.user).select_related(
-        "content_type"
+    favorites = (
+        Favorite.objects.filter(user=request.user)
+        .select_related("content_type")
+        .order_by("priority", "pk")
     )
     if request.method == "POST":
-        selected = request.POST.getlist("user_data")
+        selected = set(request.POST.getlist("user_data"))
         for fav in favorites:
-            fav.user_data = str(fav.pk) in selected
-            fav.save(update_fields=["user_data"])
+            update_fields = []
+            user_selected = str(fav.pk) in selected
+            if fav.user_data != user_selected:
+                fav.user_data = user_selected
+                update_fields.append("user_data")
+
+            priority_raw = request.POST.get(f"priority_{fav.pk}", "").strip()
+            if priority_raw:
+                try:
+                    priority = int(priority_raw)
+                except (TypeError, ValueError):
+                    priority = fav.priority
+                else:
+                    if fav.priority != priority:
+                        fav.priority = priority
+                        update_fields.append("priority")
+            else:
+                if fav.priority != 0:
+                    fav.priority = 0
+                    update_fields.append("priority")
+
+            if update_fields:
+                fav.save(update_fields=update_fields)
         return redirect("admin:favorite_list")
     return render(request, "admin/favorite_list.html", {"favorites": favorites})
 

pages/apps.py

@@ -1,13 +1,45 @@
+import logging
+
 from django.apps import AppConfig
+from django.db import DatabaseError
+from django.db.backends.signals import connection_created
+
+
+logger = logging.getLogger(__name__)
 
 
 class PagesConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "pages"
     verbose_name = "7. Experience"
+    _view_history_purged = False
 
     def ready(self):  # pragma: no cover - import for side effects
         from . import checks  # noqa: F401
         from . import site_config
 
         site_config.ready()
+        connection_created.connect(
+            self._handle_connection_created,
+            dispatch_uid="pages_view_history_connection_created",
+            weak=False,
+        )
+
+    def _handle_connection_created(self, sender, connection, **kwargs):
+        if self._view_history_purged:
+            return
+        self._view_history_purged = True
+        self._purge_view_history()
+
+    def _purge_view_history(self, days: int = 15) -> None:
+        """Remove stale :class:`pages.models.ViewHistory` entries."""
+
+        from .models import ViewHistory
+
+        try:
+            deleted = ViewHistory.purge_older_than(days=days)
+        except DatabaseError:
+            logger.debug("Skipping view history purge; database unavailable", exc_info=True)
+        else:
+            if deleted:
+                logger.info("Purged %s view history entries older than %s days", deleted, days)

pages/forms.py

@@ -171,15 +171,35 @@ class UserStoryForm(forms.ModelForm):
             "comments": forms.Textarea(attrs={"rows": 4, "maxlength": 400}),
         }
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, user=None, **kwargs):
+        self.user = user
         super().__init__(*args, **kwargs)
-        self.fields["name"].required = False
-        self.fields["name"].widget.attrs.update(
-            {
-                "maxlength": 40,
-                "placeholder": _("Name, email or pseudonym"),
-            }
-        )
+
+        if user is not None and user.is_authenticated:
+            name_field = self.fields["name"]
+            name_field.required = False
+            name_field.label = _("Username")
+            name_field.initial = (user.get_username() or "")[:40]
+            name_field.widget.attrs.update(
+                {
+                    "maxlength": 40,
+                    "readonly": "readonly",
+                }
+            )
+        else:
+            self.fields["name"] = forms.EmailField(
+                label=_("Email address"),
+                max_length=40,
+                required=True,
+                widget=forms.EmailInput(
+                    attrs={
+                        "maxlength": 40,
+                        "placeholder": _("name@example.com"),
+                        "autocomplete": "email",
+                        "inputmode": "email",
+                    }
+                ),
+            )
         self.fields["take_screenshot"].initial = True
         self.fields["rating"].widget = forms.RadioSelect(
             choices=[(i, str(i)) for i in range(1, 6)]
@@ -194,5 +214,8 @@ class UserStoryForm(forms.ModelForm):
         return comments
 
     def clean_name(self):
+        if self.user is not None and self.user.is_authenticated:
+            return (self.user.get_username() or "")[:40]
+
         name = (self.cleaned_data.get("name") or "").strip()
         return name[:40]

pages/models.py

@@ -1,5 +1,6 @@
 import base64
 import logging
+from datetime import timedelta
 from pathlib import Path
 
 from django.db import models
@@ -7,10 +8,11 @@ from django.db.models import Q
 from core.entity import Entity
 from core.models import Lead, SecurityGroup
 from django.contrib.sites.models import Site
-from nodes.models import NodeRole
+from nodes.models import ContentSample, NodeRole
 from django.apps import apps as django_apps
+from django.utils import timezone
 from django.utils.text import slugify
-from django.utils.translation import gettext, gettext_lazy as _
+from django.utils.translation import gettext, gettext_lazy as _, get_language_info
 from importlib import import_module
 from django.urls import URLPattern
 from django.conf import settings
@@ -490,6 +492,14 @@ class ViewHistory(Entity):
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return f"{self.method} {self.path} ({self.status_code})"
 
+    @classmethod
+    def purge_older_than(cls, *, days: int) -> int:
+        """Delete history entries recorded more than ``days`` days ago."""
+
+        cutoff = timezone.now() - timedelta(days=days)
+        deleted, _ = cls.objects.filter(visited_at__lt=cutoff).delete()
+        return deleted
+
 
 class Favorite(Entity):
     user = models.ForeignKey(
@@ -500,9 +510,11 @@ class Favorite(Entity):
     content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
     custom_label = models.CharField(max_length=100, blank=True)
     user_data = models.BooleanField(default=False)
+    priority = models.IntegerField(default=0)
 
     class Meta:
         unique_together = ("user", "content_type")
+        ordering = ["priority", "pk"]
 
 
 class UserStory(Lead):
@@ -545,6 +557,19 @@ class UserStory(Lead):
         blank=True,
         help_text=_("Link to the GitHub issue created for this feedback."),
     )
+    screenshot = models.ForeignKey(
+        ContentSample,
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+        related_name="user_stories",
+        help_text=_("Screenshot captured for this feedback."),
+    )
+    language_code = models.CharField(
+        max_length=15,
+        blank=True,
+        help_text=_("Language selected when the feedback was submitted."),
+    )
 
     class Meta:
         ordering = ["-submitted_at"]
@@ -590,6 +615,21 @@ class UserStory(Lead):
             f"**Screenshot requested:** {screenshot_requested}",
         ]
 
+        language_code = (self.language_code or "").strip()
+        if language_code:
+            normalized = language_code.replace("_", "-").lower()
+            try:
+                info = get_language_info(normalized)
+            except KeyError:
+                language_display = ""
+            else:
+                language_display = info.get("name_local") or info.get("name") or ""
+
+            if language_display:
+                lines.append(f"**Language:** {language_display} ({normalized})")
+            else:
+                lines.append(f"**Language:** {normalized}")
+
         if self.submitted_at:
             lines.append(f"**Submitted at:** {self.submitted_at.isoformat()}")