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

pages/context_processors.py

@@ -9,11 +9,22 @@ from core.reference_utils import filter_visible_references
 from .models import Module
 
 _favicon_path = Path(settings.BASE_DIR) / "pages" / "fixtures" / "data" / "favicon.txt"
+_control_favicon_path = (
+    Path(settings.BASE_DIR) / "pages" / "fixtures" / "data" / "favicon_control.txt"
+)
+
 try:
     _DEFAULT_FAVICON = f"data:image/png;base64,{_favicon_path.read_text().strip()}"
 except OSError:
     _DEFAULT_FAVICON = ""
 
+try:
+    _CONTROL_FAVICON = (
+        f"data:image/png;base64,{_control_favicon_path.read_text().strip()}"
+    )
+except OSError:
+    _CONTROL_FAVICON = _DEFAULT_FAVICON
+
 
 def nav_links(request):
     """Provide navigation links for the current site."""
@@ -39,12 +50,12 @@ def nav_links(request):
             except Resolver404:
                 continue
             view_func = match.func
-            requires_login = getattr(view_func, "login_required", False) or hasattr(
-                view_func, "login_url"
-            )
+            requires_login = bool(getattr(view_func, "login_required", False))
+            if not requires_login and hasattr(view_func, "login_url"):
+                requires_login = True
             staff_only = getattr(view_func, "staff_required", False)
             if requires_login and not request.user.is_authenticated:
-                continue
+                setattr(landing, "requires_login", True)
             if staff_only and not request.user.is_staff:
                 continue
             landings.append(landing)
@@ -52,8 +63,8 @@ def nav_links(request):
             app_name = getattr(module.application, "name", "").lower()
             if app_name == "awg":
                 module.menu = "Calculate"
-            elif app_name == "man":
-                module.menu = "Manuals"
+            elif module.path.rstrip("/").lower() == "/man":
+                module.menu = "Manual"
             module.enabled_landings = landings
             valid_modules.append(module)
             if request.path.startswith(module.path):
@@ -84,7 +95,10 @@ def nav_links(request):
             except Exception:
                 pass
         if not favicon_url:
-            favicon_url = _DEFAULT_FAVICON
+            if node and getattr(node.role, "name", "") == "Control":
+                favicon_url = _CONTROL_FAVICON
+            else:
+                favicon_url = _DEFAULT_FAVICON
 
     header_refs_qs = (
         Reference.objects.filter(show_in_header=True)

pages/defaults.py

@@ -0,0 +1,13 @@
+"""Default configuration for the pages application."""
+from __future__ import annotations
+
+from typing import Dict
+
+DEFAULT_APPLICATION_DESCRIPTIONS: Dict[str, str] = {
+    "awg": "Power, Energy and Cost calculations.",
+    "core": "Support for Business Processes and monetization.",
+    "ocpp": "Compatibility with Standards and Good Practices.",
+    "nodes": "System and Node-level operations,",
+    "pages": "User QA, Continuity Design and Chaos Testing.",
+    "teams": "Identity, Entitlements and Access Controls.",
+}

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):
@@ -111,6 +114,7 @@ class Module(Entity):
                 return
         patterns = getattr(urlconf, "urlpatterns", [])
         created = False
+        normalized_module = self.path.strip("/")
 
         def _walk(patterns, prefix=""):
             nonlocal created
@@ -118,17 +122,34 @@ class Module(Entity):
                 if isinstance(pattern, URLPattern):
                     callback = pattern.callback
                     if getattr(callback, "landing", False):
-                        Landing.objects.get_or_create(
-                            module=self,
-                            path=f"{self.path}{prefix}{str(pattern.pattern)}",
-                            defaults={
-                                "label": getattr(
-                                    callback,
-                                    "landing_label",
-                                    callback.__name__.replace("_", " ").title(),
-                                )
-                            },
-                        )
+                        pattern_path = str(pattern.pattern)
+                        relative = f"{prefix}{pattern_path}"
+                        if normalized_module and relative.startswith(normalized_module):
+                            full_path = f"/{relative}"
+                            Landing.objects.update_or_create(
+                                module=self,
+                                path=full_path,
+                                defaults={
+                                    "label": getattr(
+                                        callback,
+                                        "landing_label",
+                                        callback.__name__.replace("_", " ").title(),
+                                    )
+                                },
+                            )
+                        else:
+                            full_path = f"{self.path}{relative}"
+                            Landing.objects.get_or_create(
+                                module=self,
+                                path=full_path,
+                                defaults={
+                                    "label": getattr(
+                                        callback,
+                                        "landing_label",
+                                        callback.__name__.replace("_", " ").title(),
+                                    )
+                                },
+                            )
                         created = True
                 else:
                     _walk(
@@ -192,6 +213,7 @@ class Landing(Entity):
         return f"{self.label} ({self.path})"
 
     def save(self, *args, **kwargs):
+        existing = None
         if not self.pk:
             existing = (
                 type(self).objects.filter(module=self.module, path=self.path).first()
@@ -200,10 +222,30 @@ class Landing(Entity):
             self.pk = existing.pk
         super().save(*args, **kwargs)
 
-    def natural_key(self):  # pragma: no cover - simple representation
-        return (self.module.node_role.name, self.module.path, self.path)
 
-    natural_key.dependencies = ["nodes.NodeRole", "pages.Module"]
+class UserManual(Entity):
+    slug = models.SlugField(unique=True)
+    title = models.CharField(max_length=200)
+    description = models.CharField(max_length=200)
+    languages = models.CharField(
+        max_length=100,
+        blank=True,
+        default="",
+        help_text="Comma-separated 2-letter language codes",
+    )
+    content_html = models.TextField()
+    content_pdf = models.TextField(help_text="Base64 encoded PDF")
+
+    class Meta:
+        db_table = "man_usermanual"
+        verbose_name = "User Manual"
+        verbose_name_plural = "User Manuals"
+
+    def __str__(self):  # pragma: no cover - simple representation
+        return self.title
+
+    def natural_key(self):  # pragma: no cover - simple representation
+        return (self.slug,)
 
 
 class ViewHistory(Entity):
@@ -240,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