arthexis 0.1.3__py3-none-any.whl

pages/admin.py

@@ -0,0 +1,231 @@
+from django.contrib import admin, messages
+from django.contrib.sites.admin import SiteAdmin as DjangoSiteAdmin
+from django.contrib.sites.models import Site
+from django import forms
+from django.db import models
+from app.widgets import CopyColorWidget
+from django.shortcuts import redirect, render, get_object_or_404
+from django.urls import path, reverse
+from django.utils.html import format_html
+import ipaddress
+from django.apps import apps as django_apps
+from django.conf import settings
+
+from nodes.models import Node
+from nodes.utils import capture_screenshot, save_screenshot
+
+from .models import SiteBadge, Application, SiteProxy, Module, Landing, Favorite
+from django.contrib.contenttypes.models import ContentType
+
+
+def get_local_app_choices():
+    choices = []
+    for app_label in getattr(settings, "LOCAL_APPS", []):
+        try:
+            config = django_apps.get_app_config(app_label)
+        except LookupError:
+            continue
+        choices.append((config.label, config.verbose_name))
+    return choices
+
+
+class SiteBadgeInline(admin.StackedInline):
+    model = SiteBadge
+    can_delete = False
+    extra = 0
+    formfield_overrides = {models.CharField: {"widget": CopyColorWidget}}
+    fields = ("badge_color", "favicon", "landing_override")
+
+
+class SiteForm(forms.ModelForm):
+    name = forms.CharField(required=False)
+
+    class Meta:
+        model = Site
+        fields = "__all__"
+
+
+class SiteAdmin(DjangoSiteAdmin):
+    form = SiteForm
+    inlines = [SiteBadgeInline]
+    change_list_template = "admin/sites/site/change_list.html"
+    fields = ("domain", "name")
+    list_display = ("domain", "name")
+    actions = ["capture_screenshot"]
+
+    @admin.action(description="Capture screenshot")
+    def capture_screenshot(self, request, queryset):
+        node = Node.get_local()
+        for site in queryset:
+            url = f"http://{site.domain}/"
+            try:
+                path = capture_screenshot(url)
+                screenshot = save_screenshot(path, node=node, method="ADMIN")
+            except Exception as exc:  # pragma: no cover - browser issues
+                self.message_user(request, f"{site.domain}: {exc}", messages.ERROR)
+                continue
+            if screenshot:
+                link = reverse(
+                    "admin:nodes_contentsample_change", args=[screenshot.pk]
+                )
+                self.message_user(
+                    request,
+                    format_html(
+                        'Screenshot for {} saved. <a href="{}">View</a>',
+                        site.domain,
+                        link,
+                    ),
+                    messages.SUCCESS,
+                )
+            else:
+                self.message_user(
+                    request,
+                    f"{site.domain}: duplicate screenshot; not saved",
+                    messages.INFO,
+                )
+
+    def get_urls(self):
+        urls = super().get_urls()
+        custom = [
+            path(
+                "register-current/",
+                self.admin_site.admin_view(self.register_current),
+                name="pages_siteproxy_register_current",
+            )
+        ]
+        return custom + urls
+
+    def register_current(self, request):
+        domain = request.get_host().split(":")[0]
+        try:
+            ipaddress.ip_address(domain)
+        except ValueError:
+            name = domain
+        else:
+            name = ""
+        site, created = Site.objects.get_or_create(
+            domain=domain, defaults={"name": name}
+        )
+        if created:
+            self.message_user(request, "Current domain registered", messages.SUCCESS)
+        else:
+            self.message_user(
+                request, "Current domain already registered", messages.INFO
+            )
+        return redirect("..")
+
+
+admin.site.unregister(Site)
+admin.site.register(SiteProxy, SiteAdmin)
+
+
+class ApplicationForm(forms.ModelForm):
+    name = forms.ChoiceField(choices=[])
+
+    class Meta:
+        model = Application
+        fields = "__all__"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["name"].choices = get_local_app_choices()
+
+
+class ApplicationModuleInline(admin.TabularInline):
+    model = Module
+    fk_name = "application"
+    extra = 0
+
+
+@admin.register(Application)
+class ApplicationAdmin(admin.ModelAdmin):
+    form = ApplicationForm
+    list_display = ("name", "app_verbose_name", "installed")
+    readonly_fields = ("installed",)
+    inlines = [ApplicationModuleInline]
+
+    @admin.display(description="Verbose name")
+    def app_verbose_name(self, obj):
+        return obj.verbose_name
+
+    @admin.display(boolean=True)
+    def installed(self, obj):
+        return obj.installed
+
+
+class LandingInline(admin.TabularInline):
+    model = Landing
+    extra = 0
+    fields = ("path", "label", "enabled", "description")
+
+
+@admin.register(Module)
+class ModuleAdmin(admin.ModelAdmin):
+    list_display = ("application", "node_role", "path", "menu", "is_default")
+    list_filter = ("node_role", "application")
+    fields = ("node_role", "application", "path", "menu", "is_default", "favicon")
+    inlines = [LandingInline]
+
+
+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()
+    if fav:
+        return redirect("admin:favorite_list")
+    if request.method == "POST":
+        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,
+        )
+        return redirect("admin:index")
+    return render(request, "admin/favorite_confirm.html", {"content_type": ct})
+
+
+def favorite_list(request):
+    favorites = Favorite.objects.filter(user=request.user).select_related("content_type")
+    if request.method == "POST":
+        selected = request.POST.getlist("user_data")
+        for fav in favorites:
+            fav.user_data = str(fav.pk) in selected
+            fav.save(update_fields=["user_data"])
+        return redirect("admin:favorite_list")
+    return render(request, "admin/favorite_list.html", {"favorites": favorites})
+
+
+def favorite_delete(request, pk):
+    fav = get_object_or_404(Favorite, pk=pk, user=request.user)
+    fav.delete()
+    return redirect("admin:favorite_list")
+
+
+def favorite_clear(request):
+    Favorite.objects.filter(user=request.user).delete()
+    return redirect("admin:favorite_list")
+
+
+def get_admin_urls(urls):
+    def get_urls():
+        my_urls = [
+            path("favorites/<int:ct_id>/", admin.site.admin_view(favorite_toggle), name="favorite_toggle"),
+            path("favorites/", admin.site.admin_view(favorite_list), name="favorite_list"),
+            path(
+                "favorites/delete/<int:pk>/",
+                admin.site.admin_view(favorite_delete),
+                name="favorite_delete",
+            ),
+            path(
+                "favorites/clear/",
+                admin.site.admin_view(favorite_clear),
+                name="favorite_clear",
+            ),
+        ]
+        return my_urls + urls
+
+    return get_urls
+
+
+admin.site.get_urls = get_admin_urls(admin.site.get_urls())

pages/apps.py

@@ -0,0 +1,10 @@
+from django.apps import AppConfig
+
+
+class PagesConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "pages"
+    verbose_name = "Web Experience"
+
+    def ready(self):  # pragma: no cover - import for side effects
+        from . import checks  # noqa: F401

pages/checks.py

@@ -0,0 +1,41 @@
+import inspect
+
+from django.core.checks import Warning, register
+from django.urls.resolvers import URLPattern, URLResolver
+
+from config import urls as project_urls
+
+
+def _collect_checks(resolver: URLResolver, errors: list, prefix: str = ""):
+    for pattern in resolver.url_patterns:
+        if isinstance(pattern, URLResolver):
+            _collect_checks(pattern, errors, prefix + pattern.pattern._route)
+        elif isinstance(pattern, URLPattern):
+            view = pattern.callback
+            if getattr(view, "landing", False):
+                sig = inspect.signature(view)
+                params = list(sig.parameters.values())
+                if params and params[0].name == "request":
+                    params = params[1:]
+                has_required = any(
+                    p.default is inspect._empty
+                    and p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+                    for p in params
+                )
+                if has_required:
+                    errors.append(
+                        Warning(
+                            f'Landing view "{view.__module__}.{view.__name__}" requires URL parameters and cannot be a landing page.',
+                            id="pages.W001",
+                        )
+                    )
+
+
+@register()
+def landing_views_have_no_args(app_configs, **kwargs):
+    errors: list = []
+    for p in project_urls.urlpatterns:
+        if isinstance(p, URLResolver):
+            _collect_checks(p, errors, p.pattern._route)
+    return errors
+

pages/context_processors.py

@@ -0,0 +1,72 @@
+from utils.sites import get_site
+from django.urls import Resolver404, resolve
+from django.conf import settings
+from pathlib import Path
+from nodes.models import Node
+from .models import Module
+
+_favicon_path = (
+    Path(settings.BASE_DIR) / "pages" / "fixtures" / "data" / "favicon.txt"
+)
+try:
+    _DEFAULT_FAVICON = f"data:image/png;base64,{_favicon_path.read_text().strip()}"
+except OSError:
+    _DEFAULT_FAVICON = ""
+
+
+def nav_links(request):
+    """Provide navigation links for the current site."""
+    site = get_site(request)
+    node = Node.get_local()
+    role = node.role if node else None
+    if role:
+        modules = (
+            Module.objects.filter(node_role=role)
+            .select_related("application")
+            .prefetch_related("landings")
+        )
+    else:
+        modules = []
+
+    valid_modules = []
+    current_module = None
+    for module in modules:
+        landings = []
+        for landing in module.landings.filter(enabled=True):
+            try:
+                match = resolve(landing.path)
+            except Resolver404:
+                continue
+            view_func = match.func
+            requires_login = getattr(view_func, "login_required", False) or hasattr(
+                view_func, "login_url"
+            )
+            staff_only = getattr(view_func, "staff_required", False)
+            if requires_login and not request.user.is_authenticated:
+                continue
+            if staff_only and not request.user.is_staff:
+                continue
+            landings.append(landing)
+        if landings:
+            module.enabled_landings = landings
+            valid_modules.append(module)
+            if request.path.startswith(module.path):
+                if current_module is None or len(module.path) > len(current_module.path):
+                    current_module = module
+
+    valid_modules.sort(key=lambda m: m.menu_label.lower())
+
+    if current_module and current_module.favicon:
+        favicon_url = current_module.favicon.url
+    else:
+        favicon_url = None
+        if site:
+            try:
+                if site.badge.favicon:
+                    favicon_url = site.badge.favicon.url
+            except Exception:
+                pass
+        if not favicon_url:
+            favicon_url = _DEFAULT_FAVICON
+
+    return {"nav_modules": valid_modules, "favicon_url": favicon_url}

pages/models.py

@@ -0,0 +1,224 @@
+from django.db import models
+from core.entity import Entity
+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 importlib import import_module
+from django.urls import URLPattern
+from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
+
+
+class ApplicationManager(models.Manager):
+    def get_by_natural_key(self, name: str):
+        return self.get(name=name)
+
+
+class Application(Entity):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+
+    objects = ApplicationManager()
+
+    def natural_key(self):  # pragma: no cover - simple representation
+        return (self.name,)
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return self.name
+
+    @property
+    def installed(self) -> bool:
+        return django_apps.is_installed(self.name)
+
+    @property
+    def verbose_name(self) -> str:
+        try:
+            return django_apps.get_app_config(self.name).verbose_name
+        except LookupError:
+            return self.name
+
+
+class ModuleManager(models.Manager):
+    def get_by_natural_key(self, role: str, path: str):
+        return self.get(node_role__name=role, path=path)
+
+
+class Module(Entity):
+    node_role = models.ForeignKey(
+        NodeRole, on_delete=models.CASCADE, related_name="modules",
+    )
+    application = models.ForeignKey(
+        Application, on_delete=models.CASCADE, related_name="modules",
+    )
+    path = models.CharField(
+        max_length=100,
+        help_text="Base path for the app, starting with /",
+        blank=True,
+    )
+    menu = models.CharField(
+        max_length=100,
+        blank=True,
+        help_text="Text used for the navbar pill; defaults to the application name.",
+    )
+    is_default = models.BooleanField(default=False)
+    favicon = models.ImageField(upload_to="modules/favicons/", blank=True)
+
+    objects = ModuleManager()
+
+    class Meta:
+        verbose_name = _("Module")
+        verbose_name_plural = _("Modules")
+        unique_together = ("node_role", "path")
+
+    def natural_key(self):  # pragma: no cover - simple representation
+        role_name = None
+        if getattr(self, "node_role_id", None):
+            role_name = self.node_role.name
+        return (role_name, self.path)
+
+    natural_key.dependencies = ["nodes.NodeRole"]
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return f"{self.application.name} ({self.path})"
+
+    @property
+    def menu_label(self) -> str:
+        return self.menu or self.application.name
+
+    def save(self, *args, **kwargs):
+        if not self.path:
+            self.path = f"/{slugify(self.application.name)}/"
+        super().save(*args, **kwargs)
+
+    def create_landings(self):
+        try:
+            urlconf = import_module(f"{self.application.name}.urls")
+        except Exception:
+            try:
+                urlconf = import_module(f"{self.application.name.lower()}.urls")
+            except Exception:
+                Landing.objects.get_or_create(
+                    module=self,
+                    path=self.path,
+                    defaults={"label": self.application.name},
+                )
+                return
+        patterns = getattr(urlconf, "urlpatterns", [])
+        created = False
+
+        def _walk(patterns, prefix=""):
+            nonlocal created
+            for pattern in patterns:
+                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(),
+                                )
+                            },
+                        )
+                        created = True
+                else:
+                    _walk(pattern.url_patterns, prefix=f"{prefix}{str(pattern.pattern)}")
+
+        _walk(patterns)
+
+        if not created:
+            Landing.objects.get_or_create(
+                module=self, path=self.path, defaults={"label": self.application.name}
+            )
+
+
+class SiteBadge(Entity):
+    site = models.OneToOneField(Site, on_delete=models.CASCADE, related_name="badge")
+    badge_color = models.CharField(max_length=7, default="#28a745")
+    favicon = models.ImageField(upload_to="sites/favicons/", blank=True)
+    landing_override = models.ForeignKey('Landing', null=True, blank=True, on_delete=models.SET_NULL)
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return f"Badge for {self.site.domain}"
+
+    class Meta:
+        verbose_name = "Site Badge"
+        verbose_name_plural = "Site Badges"
+
+
+class SiteProxy(Site):
+    class Meta:
+        proxy = True
+        app_label = "pages"
+        verbose_name = "Site"
+        verbose_name_plural = "Sites"
+
+
+class LandingManager(models.Manager):
+    def get_by_natural_key(self, role: str, module_path: str, path: str):
+        return self.get(
+            module__node_role__name=role, module__path=module_path, path=path
+        )
+
+
+class Landing(Entity):
+    module = models.ForeignKey(
+        Module, on_delete=models.CASCADE, related_name="landings"
+    )
+    path = models.CharField(max_length=200)
+    label = models.CharField(max_length=100)
+    enabled = models.BooleanField(default=True)
+    description = models.TextField(blank=True)
+
+    objects = LandingManager()
+
+    class Meta:
+        unique_together = ("module", "path")
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return f"{self.label} ({self.path})"
+
+    def save(self, *args, **kwargs):
+        if not self.pk:
+            existing = type(self).objects.filter(
+                module=self.module, path=self.path
+            ).first()
+            if existing:
+                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 Favorite(Entity):
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="favorites",
+    )
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    custom_label = models.CharField(max_length=100, blank=True)
+    user_data = models.BooleanField(default=False)
+
+    class Meta:
+        unique_together = ("user", "content_type")
+
+
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+
+@receiver(post_save, sender=Module)
+def _create_landings(
+    sender, instance, created, raw, **kwargs
+):  # pragma: no cover - simple handler
+    if created and not raw:
+        instance.create_landings()