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

core/reference_utils.py

@@ -0,0 +1,108 @@
+"""Utility helpers for working with Reference objects."""
+
+from __future__ import annotations
+
+from typing import Iterable, TYPE_CHECKING
+
+from django.contrib.sites.models import Site
+
+if TYPE_CHECKING:  # pragma: no cover - imported only for type checking
+    from django.http import HttpRequest
+    from nodes.models import Node
+    from .models import Reference
+
+
+def filter_visible_references(
+    refs: Iterable["Reference"],
+    *,
+    request: "HttpRequest | None" = None,
+    site: Site | None = None,
+    node: "Node | None" = None,
+    respect_footer_visibility: bool = True,
+) -> list["Reference"]:
+    """Return references visible for the current context."""
+
+    if site is None and request is not None:
+        try:
+            host = request.get_host().split(":")[0]
+        except Exception:
+            host = ""
+        if host:
+            site = Site.objects.filter(domain__iexact=host).first()
+
+    site_id = site.pk if site else None
+
+    if node is None:
+        try:
+            from nodes.models import Node  # imported lazily to avoid circular import
+
+            node = Node.get_local()
+        except Exception:
+            node = None
+
+    node_role_id = getattr(node, "role_id", None)
+    node_active_feature_ids: set[int] = set()
+    if node is not None:
+        assignments_manager = getattr(node, "feature_assignments", None)
+        if assignments_manager is not None:
+            try:
+                assignments = list(
+                    assignments_manager.filter(is_deleted=False).select_related(
+                        "feature"
+                    )
+                )
+            except Exception:
+                assignments = []
+            for assignment in assignments:
+                feature = getattr(assignment, "feature", None)
+                if feature is None or getattr(feature, "is_deleted", False):
+                    continue
+                try:
+                    if feature.is_enabled:
+                        node_active_feature_ids.add(feature.pk)
+                except Exception:
+                    continue
+
+    visible_refs: list["Reference"] = []
+    for ref in refs:
+        required_roles = {role.pk for role in ref.roles.all()}
+        required_features = {feature.pk for feature in ref.features.all()}
+        required_sites = {current_site.pk for current_site in ref.sites.all()}
+
+        if required_roles or required_features or required_sites:
+            allowed = False
+            if required_roles and node_role_id and node_role_id in required_roles:
+                allowed = True
+            elif (
+                required_features
+                and node_active_feature_ids
+                and node_active_feature_ids.intersection(required_features)
+            ):
+                allowed = True
+            elif required_sites and site_id and site_id in required_sites:
+                allowed = True
+
+            if not allowed:
+                continue
+
+        if respect_footer_visibility:
+            if ref.footer_visibility == ref.FOOTER_PUBLIC:
+                visible_refs.append(ref)
+            elif (
+                ref.footer_visibility == ref.FOOTER_PRIVATE
+                and request
+                and request.user.is_authenticated
+            ):
+                visible_refs.append(ref)
+            elif (
+                ref.footer_visibility == ref.FOOTER_STAFF
+                and request
+                and request.user.is_authenticated
+                and request.user.is_staff
+            ):
+                visible_refs.append(ref)
+        else:
+            visible_refs.append(ref)
+
+    return visible_refs
+

core/sigil_builder.py

@@ -17,7 +17,7 @@ from .sigil_resolver import (
 def generate_model_sigils(**kwargs) -> None:
     """Ensure built-in configuration SigilRoot entries exist."""
     SigilRoot = apps.get_model("core", "SigilRoot")
-    for prefix in ["ENV", "SYS"]:
+    for prefix in ["ENV", "CONF", "SYS"]:
         # Ensure built-in configuration roots exist without violating the
         # unique ``prefix`` constraint, even if older databases already have
         # entries with a different ``context_type``.
@@ -40,7 +40,12 @@ def _sigil_builder_view(request):
         {
             "prefix": "ENV",
             "url": reverse("admin:environment"),
-            "label": _("Environment"),
+            "label": _("Environ"),
+        },
+        {
+            "prefix": "CONF",
+            "url": reverse("admin:config"),
+            "label": _("Config"),
         },
         {
             "prefix": "SYS",
@@ -88,16 +93,27 @@ def _sigil_builder_view(request):
 
     sigils_text = ""
     resolved_text = ""
+    show_sigils_input = True
+    show_result = False
     if request.method == "POST":
         sigils_text = request.POST.get("sigils_text", "")
+        source_text = sigils_text
         upload = request.FILES.get("sigils_file")
         if upload:
-            sigils_text = upload.read().decode("utf-8", errors="ignore")
+            source_text = upload.read().decode("utf-8", errors="ignore")
+            show_sigils_input = False
         else:
             single = request.POST.get("sigil", "")
             if single:
-                sigils_text = f"[{single}]" if not single.startswith("[") else single
-        resolved_text = resolve_sigils_in_text(sigils_text) if sigils_text else ""
+                source_text = (
+                    f"[{single}]" if not single.startswith("[") else single
+                )
+                sigils_text = source_text
+        if source_text:
+            resolved_text = resolve_sigils_in_text(source_text)
+            show_result = True
+        if upload:
+            sigils_text = ""
 
     context = admin.site.each_context(request)
     context.update(
@@ -108,6 +124,8 @@ def _sigil_builder_view(request):
             "auto_fields": auto_fields,
             "sigils_text": sigils_text,
             "resolved_text": resolved_text,
+            "show_sigils_input": show_sigils_input,
+            "show_result": show_result,
         }
     )
     return TemplateResponse(request, "admin/sigil_builder.html", context)

core/sigil_resolver.py

@@ -11,6 +11,7 @@ from django.core import serializers
 from django.db import models
 
 from .sigil_context import get_context
+from .system import get_system_sigil_values, resolve_system_namespace_value
 
 logger = logging.getLogger("core.entity")
 
@@ -150,6 +151,18 @@ def _resolve_token(token: str, current: Optional[models.Model] = None) -> str:
     SigilRoot = apps.get_model("core", "SigilRoot")
     try:
         root = SigilRoot.objects.get(prefix__iexact=lookup_root)
+    except SigilRoot.DoesNotExist:
+        logger.warning("Unknown sigil root [%s]", lookup_root)
+        return _failed_resolution(original_token)
+    except Exception:
+        logger.exception(
+            "Error resolving sigil [%s.%s]",
+            lookup_root,
+            key_upper or normalized_key or raw_key,
+        )
+        return _failed_resolution(original_token)
+
+    try:
         if root.context_type == SigilRoot.Context.CONFIG:
             if not normalized_key:
                 return ""
@@ -176,7 +189,7 @@ def _resolve_token(token: str, current: Optional[models.Model] = None) -> str:
                     key_upper or normalized_key or raw_key or "",
                 )
                 return _failed_resolution(original_token)
-            if root.prefix.upper() == "SYS":
+            if root.prefix.upper() == "CONF":
                 for candidate in [normalized_key, key_upper, key_lower]:
                     if not candidate:
                         continue
@@ -188,6 +201,26 @@ def _resolve_token(token: str, current: Optional[models.Model] = None) -> str:
                 if fallback is not None:
                     return fallback
                 return ""
+            if root.prefix.upper() == "SYS":
+                values = get_system_sigil_values()
+                candidates = {
+                    key_upper,
+                    normalized_key.upper() if normalized_key else None,
+                    (raw_key or "").upper(),
+                }
+                for candidate in candidates:
+                    if not candidate:
+                        continue
+                    if candidate in values:
+                        return values[candidate]
+                    resolved = resolve_system_namespace_value(candidate)
+                    if resolved is not None:
+                        return resolved
+                logger.warning(
+                    "Missing system information for sigil [SYS.%s]",
+                    key_upper or normalized_key or raw_key or "",
+                )
+                return _failed_resolution(original_token)
         elif root.context_type == SigilRoot.Context.ENTITY:
             model = root.content_type.model_class() if root.content_type else None
             instance = None
@@ -243,15 +276,13 @@ def _resolve_token(token: str, current: Optional[models.Model] = None) -> str:
                     return _failed_resolution(original_token)
                 return serializers.serialize("json", [instance])
         return _failed_resolution(original_token)
-    except SigilRoot.DoesNotExist:
-        logger.warning("Unknown sigil root [%s]", lookup_root)
     except Exception:
         logger.exception(
             "Error resolving sigil [%s.%s]",
             lookup_root,
             key_upper or normalized_key or raw_key,
         )
-    return _failed_resolution(original_token)
+        return _failed_resolution(original_token)
 
 
 def resolve_sigils(text: str, current: Optional[models.Model] = None) -> str: