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

core/user_data.py

@@ -16,6 +16,7 @@ from django.dispatch import receiver
 from django.http import HttpResponse, HttpResponseRedirect
 from django.template.response import TemplateResponse
 from django.urls import path, reverse
+from django.utils.functional import LazyObject
 from django.utils.translation import gettext as _
 
 from .entity import Entity
@@ -39,7 +40,14 @@ def _username_for(user) -> str:
 
 
 def _user_allows_user_data(user) -> bool:
-    return bool(user) and not getattr(user, "is_profile_restricted", False)
+    if not user:
+        return False
+    username = _username_for(user)
+    UserModel = get_user_model()
+    system_username = getattr(UserModel, "SYSTEM_USERNAME", "")
+    if system_username and username == system_username:
+        return True
+    return not getattr(user, "is_profile_restricted", False)
 
 
 def _data_dir(user) -> Path:
@@ -93,18 +101,68 @@ def _seed_fixture_path(instance) -> Path | None:
     return None
 
 
+def _coerce_user(candidate, user_model):
+    if candidate is None:
+        return None
+    if isinstance(candidate, user_model):
+        return candidate
+    if isinstance(candidate, LazyObject):
+        try:
+            candidate._setup()
+        except Exception:
+            return None
+        return _coerce_user(candidate._wrapped, user_model)
+    return None
+
+
+def _select_fixture_user(candidate, user_model):
+    user = _coerce_user(candidate, user_model)
+    visited: set[int] = set()
+    while user is not None:
+        identifier = user.pk or id(user)
+        if identifier in visited:
+            break
+        visited.add(identifier)
+        username = _username_for(user)
+        admin_username = getattr(user_model, "ADMIN_USERNAME", "")
+        if admin_username and username == admin_username:
+            try:
+                delegate = getattr(user, "operate_as", None)
+            except user_model.DoesNotExist:
+                delegate = None
+            else:
+                delegate = _coerce_user(delegate, user_model)
+            if delegate is not None and delegate is not user:
+                user = delegate
+                continue
+        if _user_allows_user_data(user):
+            return user
+        try:
+            delegate = getattr(user, "operate_as", None)
+        except user_model.DoesNotExist:
+            delegate = None
+        user = _coerce_user(delegate, user_model)
+    return None
+
+
 def _resolve_fixture_user(instance, fallback=None):
     UserModel = get_user_model()
     owner = getattr(instance, "user", None)
-    if isinstance(owner, UserModel):
-        return owner
+    selected = _select_fixture_user(owner, UserModel)
+    if selected is not None:
+        return selected
     if hasattr(instance, "owner"):
         try:
             owner_value = instance.owner
         except Exception:
             owner_value = None
-        if isinstance(owner_value, UserModel):
-            return owner_value
+        else:
+            selected = _select_fixture_user(owner_value, UserModel)
+            if selected is not None:
+                return selected
+    selected = _select_fixture_user(fallback, UserModel)
+    if selected is not None:
+        return selected
     return fallback
 
 
@@ -180,6 +238,36 @@ def _mark_fixture_user_data(path: Path) -> None:
         model.all_objects.filter(pk=pk).update(is_user_data=True)
 
 
+def _fixture_targets_installed_apps(data) -> bool:
+    """Return ``True`` when *data* only targets installed apps and models."""
+
+    if not isinstance(data, list):
+        return True
+
+    labels = {
+        obj.get("model")
+        for obj in data
+        if isinstance(obj, dict) and obj.get("model")
+    }
+
+    for label in labels:
+        if not isinstance(label, str):
+            continue
+        if "." not in label:
+            continue
+        app_label, model_name = label.split(".", 1)
+        if not app_label or not model_name:
+            continue
+        if not apps.is_installed(app_label):
+            return False
+        try:
+            apps.get_model(label)
+        except LookupError:
+            return False
+
+    return True
+
+
 def _load_fixture(path: Path, *, mark_user_data: bool = True) -> bool:
     """Load a fixture from *path* and optionally flag loaded entities."""
 
@@ -203,9 +291,12 @@ def _load_fixture(path: Path, *, mark_user_data: bool = True) -> bool:
         except Exception:
             data = None
         else:
-            if isinstance(data, list) and not data:
-                path.unlink(missing_ok=True)
-                return False
+            if isinstance(data, list):
+                if not data:
+                    path.unlink(missing_ok=True)
+                    return False
+                if not _fixture_targets_installed_apps(data):
+                    return False
 
     try:
         call_command("loaddata", str(path), ignorenonexistent=True)
@@ -230,6 +321,30 @@ def _is_user_fixture(path: Path) -> bool:
     return len(parts) >= 2 and parts[1].lower() == "user"
 
 
+def _get_request_ip(request) -> str:
+    """Return the best-effort client IP for ``request``."""
+
+    if request is None:
+        return ""
+
+    meta = getattr(request, "META", None)
+    if not getattr(meta, "get", None):
+        return ""
+
+    forwarded = meta.get("HTTP_X_FORWARDED_FOR")
+    if forwarded:
+        for value in str(forwarded).split(","):
+            candidate = value.strip()
+            if candidate:
+                return candidate
+
+    remote = meta.get("REMOTE_ADDR")
+    if remote:
+        return str(remote).strip()
+
+    return ""
+
+
 _shared_fixtures_loaded = False
 
 
@@ -260,6 +375,18 @@ def load_user_fixtures(user, *, include_shared: bool = False) -> None:
 def _on_login(sender, request, user, **kwargs):
     load_user_fixtures(user, include_shared=not _shared_fixtures_loaded)
 
+    if not (
+        getattr(user, "is_staff", False) or getattr(user, "is_superuser", False)
+    ):
+        return
+
+    username = _username_for(user) or "unknown"
+    ip_address = _get_request_ip(request) or "unknown"
+
+    from nodes.models import NetMessage
+
+    NetMessage.broadcast(subject=f"login {username}", body=f"@ {ip_address}")
+
 
 @receiver(post_save, sender=settings.AUTH_USER_MODEL)
 def _on_user_created(sender, instance, created, **kwargs):
@@ -274,9 +401,7 @@ class UserDatumAdminMixin(admin.ModelAdmin):
     def render_change_form(
         self, request, context, add=False, change=False, form_url="", obj=None
     ):
-        context["show_user_datum"] = issubclass(
-            self.model, Entity
-        ) and _user_allows_user_data(request.user)
+        context["show_user_datum"] = issubclass(self.model, Entity)
         context["show_seed_datum"] = issubclass(self.model, Entity)
         context["show_save_as_copy"] = issubclass(self.model, Entity) or hasattr(
             self.model, "clone"
@@ -317,6 +442,9 @@ class EntityModelAdmin(UserDatumAdminMixin, admin.ModelAdmin):
                 )
         if copied:
             return
+        if getattr(self, "_skip_entity_user_datum", False):
+            return
+
         target_user = _resolve_fixture_user(obj, request.user)
         allow_user_data = _user_allows_user_data(target_user)
         if request.POST.get("_user_datum") == "on":
@@ -389,11 +517,23 @@ def patch_admin_user_datum() -> None:
     admin.site._user_datum_patched = True
 
 
-def _seed_data_view(request):
-    sections = []
+def _iter_entity_admin_models():
+    """Yield registered :class:`Entity` admin models without proxy duplicates."""
+
+    seen: set[type] = set()
     for model, model_admin in admin.site._registry.items():
         if not issubclass(model, Entity):
             continue
+        concrete_model = model._meta.concrete_model
+        if concrete_model in seen:
+            continue
+        seen.add(concrete_model)
+        yield model, model_admin
+
+
+def _seed_data_view(request):
+    sections = []
+    for model, model_admin in _iter_entity_admin_models():
         objs = model.objects.filter(is_seed_data=True)
         if not objs.exists():
             continue
@@ -413,9 +553,7 @@ def _seed_data_view(request):
 
 def _user_data_view(request):
     sections = []
-    for model, model_admin in admin.site._registry.items():
-        if not issubclass(model, Entity):
-            continue
+    for model, model_admin in _iter_entity_admin_models():
         objs = model.objects.filter(is_user_data=True)
         if not objs.exists():
             continue