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

pages/views.py

@@ -439,7 +439,7 @@ def admin_model_graph(request, app_label: str):
     return response
 
 
-def _render_readme(request, role, doc: str | None = None):
+def _locate_readme_document(role, doc: str | None, lang: str) -> SimpleNamespace:
     app = (
         Module.objects.filter(node_role=role, is_default=True)
         .select_related("application")
@@ -448,9 +448,8 @@ def _render_readme(request, role, doc: str | None = None):
     app_slug = app.path.strip("/") if app else ""
     root_base = Path(settings.BASE_DIR).resolve()
     readme_base = (root_base / app_slug).resolve() if app_slug else root_base
-    lang = getattr(request, "LANGUAGE_CODE", "")
-    lang = lang.replace("_", "-").lower()
-    candidates = []
+    candidates: list[Path] = []
+
     if doc:
         normalized = doc.strip().replace("\\", "/")
         while normalized.startswith("./"):
@@ -501,23 +500,72 @@ def _render_readme(request, role, doc: str | None = None):
                 if short != lang:
                     candidates.append(root_base / f"README.{short}.md")
             candidates.append(root_base / "README.md")
+
     readme_file = next((p for p in candidates if p.exists()), None)
     if readme_file is None:
         raise Http404("Document not found")
-    text = readme_file.read_text(encoding="utf-8")
-    html, toc_html = _render_markdown_with_toc(text)
+
     title = "README" if readme_file.name.startswith("README") else readme_file.stem
+    return SimpleNamespace(
+        file=readme_file,
+        title=title,
+        root_base=root_base,
+    )
+
+
+def _relative_readme_path(readme_file: Path, root_base: Path) -> str | None:
+    try:
+        return readme_file.relative_to(root_base).as_posix()
+    except ValueError:
+        return None
+
+
+def _render_readme(request, role, doc: str | None = None):
+    lang = getattr(request, "LANGUAGE_CODE", "")
+    lang = lang.replace("_", "-").lower()
+    document = _locate_readme_document(role, doc, lang)
+    text = document.file.read_text(encoding="utf-8")
+    html, toc_html = _render_markdown_with_toc(text)
+    relative_path = _relative_readme_path(document.file, document.root_base)
+    user = getattr(request, "user", None)
+    can_edit = bool(
+        relative_path
+        and user
+        and user.is_authenticated
+        and user.is_superuser
+    )
+    edit_url = None
+    if can_edit:
+        try:
+            edit_url = reverse("pages:readme-edit", kwargs={"doc": relative_path})
+        except NoReverseMatch:
+            edit_url = None
     context = {
         "content": html,
-        "title": title,
+        "title": document.title,
         "toc": toc_html,
         "page_url": request.build_absolute_uri(),
+        "edit_url": edit_url,
     }
     response = render(request, "pages/readme.html", context)
     patch_vary_headers(response, ["Accept-Language", "Cookie"])
     return response
 
 
+class MarkdownDocumentForm(forms.Form):
+    content = forms.CharField(
+        widget=forms.Textarea(
+            attrs={
+                "class": "form-control",
+                "rows": 24,
+                "spellcheck": "false",
+            }
+        ),
+        required=False,
+        strip=False,
+    )
+
+
 @landing("Home")
 @never_cache
 def index(request):
@@ -573,6 +621,57 @@ def readme(request, doc=None):
     return _render_readme(request, role, doc)
 
 
+def readme_edit(request, doc):
+    user = getattr(request, "user", None)
+    if not (user and user.is_authenticated and user.is_superuser):
+        raise PermissionDenied
+
+    node = Node.get_local()
+    role = node.role if node else None
+    lang = getattr(request, "LANGUAGE_CODE", "")
+    lang = lang.replace("_", "-").lower()
+    document = _locate_readme_document(role, doc, lang)
+    relative_path = _relative_readme_path(document.file, document.root_base)
+    if relative_path:
+        read_url = reverse("pages:readme-document", kwargs={"doc": relative_path})
+    else:
+        read_url = reverse("pages:readme")
+
+    if request.method == "POST":
+        form = MarkdownDocumentForm(request.POST)
+        if form.is_valid():
+            content = form.cleaned_data["content"]
+            try:
+                document.file.write_text(content, encoding="utf-8")
+            except OSError:
+                logger.exception("Failed to update markdown document %s", document.file)
+                messages.error(
+                    request,
+                    _("Unable to save changes. Please try again."),
+                )
+            else:
+                messages.success(request, _("Document saved successfully."))
+                if relative_path:
+                    return redirect("pages:readme-edit", doc=relative_path)
+                return redirect("pages:readme")
+    else:
+        try:
+            initial_text = document.file.read_text(encoding="utf-8")
+        except OSError:
+            logger.exception("Failed to read markdown document %s", document.file)
+            messages.error(request, _("Unable to load the document for editing."))
+            return redirect("pages:readme")
+        form = MarkdownDocumentForm(initial={"content": initial_text})
+
+    context = {
+        "form": form,
+        "title": document.title,
+        "relative_path": relative_path,
+        "read_url": read_url,
+    }
+    return render(request, "pages/readme_edit.html", context)
+
+
 def sitemap(request):
     site = get_site(request)
     node = Node.get_local()
@@ -611,11 +710,6 @@ def release_checklist(request):
     return response
 
 
-@csrf_exempt
-def datasette_auth(request):
-    if request.user.is_authenticated:
-        return HttpResponse("OK")
-    return HttpResponse(status=401)
 
 
 class CustomLoginView(LoginView):
@@ -1005,13 +1099,14 @@ class ClientReportForm(forms.Form):
         label=_("Month"),
         required=False,
         widget=forms.DateInput(attrs={"type": "month"}),
+        input_formats=["%Y-%m"],
         help_text=_("Generates the report for the calendar month that you select."),
     )
     owner = forms.ModelChoiceField(
         queryset=get_user_model().objects.all(),
         required=False,
         help_text=_(
-            "Sets who owns the report schedule and is listed as the requestor."
+            "Sets who owns the report schedule and is listed as the requester."
         ),
     )
     destinations = forms.CharField(

core/workgroup_urls.py

@@ -1,17 +0,0 @@
-"""URL routes for assistant profile endpoints."""
-
-from django.urls import path
-
-from . import workgroup_views as views
-
-app_name = "workgroup"
-
-urlpatterns = [
-    path(
-        "assistant-profiles/<int:user_id>/",
-        views.issue_key,
-        name="assistantprofile-issue",
-    ),
-    path("assistant/test/", views.assistant_test, name="assistant-test"),
-    path("chat/", views.chat, name="chat"),
-]

core/workgroup_views.py

@@ -1,94 +0,0 @@
-"""REST endpoints for AssistantProfile issuance and authentication."""
-
-from __future__ import annotations
-
-from functools import wraps
-
-from django.apps import apps
-from django.contrib.auth import get_user_model
-from django.forms.models import model_to_dict
-from django.http import HttpResponse, JsonResponse
-from django.views.decorators.csrf import csrf_exempt
-from django.views.decorators.http import require_GET, require_POST
-
-from .models import AssistantProfile, hash_key
-
-
-@csrf_exempt
-@require_POST
-def issue_key(request, user_id: int) -> JsonResponse:
-    """Issue a new ``user_key`` for ``user_id``.
-
-    The response reveals the plain key once. Store only the hash server-side.
-    """
-
-    user = get_user_model().objects.get(pk=user_id)
-    profile, key = AssistantProfile.issue_key(user)
-    return JsonResponse({"user_id": user_id, "user_key": key})
-
-
-def authenticate(view_func):
-    """View decorator that validates the ``Authorization`` header."""
-
-    @wraps(view_func)
-    def wrapper(request, *args, **kwargs):
-        header = request.META.get("HTTP_AUTHORIZATION", "")
-        if not header.startswith("Bearer "):
-            return HttpResponse(status=401)
-
-        key_hash = hash_key(header.split(" ", 1)[1])
-        try:
-            profile = AssistantProfile.objects.get(
-                user_key_hash=key_hash, is_active=True
-            )
-        except AssistantProfile.DoesNotExist:
-            return HttpResponse(status=401)
-
-        profile.touch()
-        request.assistant_profile = profile
-        request.chat_profile = profile
-        return view_func(request, *args, **kwargs)
-
-    return wrapper
-
-
-@require_GET
-@authenticate
-def assistant_test(request):
-    """Return a simple greeting to confirm authentication."""
-
-    profile = getattr(request, "assistant_profile", None)
-    user_id = profile.user_id if profile else None
-    return JsonResponse({"message": f"Hello from user {user_id}"})
-
-
-@require_GET
-@authenticate
-def chat(request):
-    """Return serialized data from any model.
-
-    Clients must provide ``model`` as ``app_label.ModelName`` and may include a
-    ``pk`` to fetch a specific record. When ``pk`` is omitted, the view returns
-    up to 100 records.
-    """
-
-    model_label = request.GET.get("model")
-    if not model_label:
-        return JsonResponse({"error": "model parameter required"}, status=400)
-    try:
-        model = apps.get_model(model_label)
-    except LookupError:
-        return JsonResponse({"error": "unknown model"}, status=400)
-
-    qs = model.objects.all()
-    pk = request.GET.get("pk")
-    if pk is not None:
-        try:
-            obj = qs.get(pk=pk)
-        except model.DoesNotExist:
-            return JsonResponse({"error": "object not found"}, status=404)
-        data = model_to_dict(obj)
-    else:
-        data = [model_to_dict(o) for o in qs[:100]]
-
-    return JsonResponse({"data": data})