netbox-data-import 2.2.0__tar.gz → 2.3.0__tar.gz

{netbox_data_import-2.2.0 → netbox_data_import-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netbox-data-import
-Version: 2.2.0
+Version: 2.3.0
 Summary: NetBox plugin for importing data from external DCIM systems
 Author: Marcin Zieba
 License-Expression: Apache-2.0

{netbox_data_import-2.2.0 → netbox_data_import-2.3.0}/netbox_data_import/__init__.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from netbox.plugins import PluginConfig
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"
 
 
 class NetBoxDataImportConfig(PluginConfig):

{netbox_data_import-2.2.0 → netbox_data_import-2.3.0}/netbox_data_import/api/serializers.py

@@ -10,8 +10,11 @@ from rest_framework import serializers
 
 from ..adapters import DEFAULT_ADAPTER_KEY, get_adapter, selectable_adapter_choices
 from ..catalog import CATALOG
+from ..forms import InferenceBackendForm
 from ..models import (
     ImportProfile,
+    CableClassMapping,
+    CableImportSource,
     ColumnMapping,
     ClassRoleMapping,
     DeviceTypeMapping,
@@ -63,6 +66,17 @@ class PolicySectionSerializer(PolicySectionApplicabilityMixin, ValidatedModelSer
     def validate_policy_row(self, attrs):
         """Check the fields this model resolves through the catalog. Subclasses override."""
 
+    def model_cleaned_values(self):
+        """Return request values after applying the model's canonical normalization."""
+        values = dict(self.validated_data)
+        if self.instance is None:
+            instance = self.Meta.model(**values)
+            instance.full_clean(validate_unique=False)
+        else:
+            # ValidatedModelSerializer.validate() applies request values and full_clean() to this instance.
+            instance = self.instance
+        return {name: getattr(instance, name) for name in values}
+
 
 def _validate_target_keys(instance, attrs, names, *, allow_candidates=True, required=False):
     """Reject a target key the profile's Source Adapter cannot supply."""
@@ -145,6 +159,24 @@ class ColumnMappingSerializer(PolicySectionSerializer):
         _validate_target_keys(self.instance, attrs, ("target_field",), required=True)
 
 
+class CableClassMappingSerializer(PolicySectionSerializer):
+    """Serializer for CableClassMapping policy decisions."""
+
+    class Meta:
+        model = CableClassMapping
+        fields = [
+            "id",
+            "url",
+            "display",
+            "profile",
+            "cable_class",
+            "cable_type_resolved",
+            "cable_type",
+            "cable_profile_resolved",
+            "cable_profile",
+        ]
+
+
 class _RackTypeSlugField(serializers.SlugRelatedField):
     """SlugRelatedField for RackType that defers the queryset import."""
 
@@ -282,6 +314,30 @@ class ImportExecutionSerializer(serializers.ModelSerializer):
         read_only_fields = fields
 
 
+class CableImportSourceSerializer(serializers.ModelSerializer):
+    """Read-only serializer for one Cable provenance record."""
+
+    class Meta:
+        model = CableImportSource
+        fields = [
+            "id",
+            "cable",
+            "profile",
+            "trace_identity",
+            "segment_index",
+            "from_text",
+            "to_text",
+            "direction",
+            "workbook_fingerprint",
+            "sheet",
+            "block_ordinal",
+            "row_start",
+            "row_end",
+            "export_timestamp",
+        ]
+        read_only_fields = fields
+
+
 class ResolutionProposalSerializer(serializers.ModelSerializer):
     """Read-only serializer for the Resolution Proposal audit record."""
 
@@ -328,28 +384,20 @@ class ResolutionProposalHistorySerializer(serializers.ModelSerializer):
 
 
 class InferenceBackendSerializer(NetBoxModelSerializer):
-    """Serialize one Inference Backend row, without its credential reference.
+    """Serialize one Inference Backend row with a write-only credential reference.
 
     NetBox resolves this class by model name to freeze a delete event payload.
     """
 
+    credential_reference = serializers.JSONField(write_only=True)
+
     class Meta:
         model = InferenceBackend
         fields = [
             "id",
             "url",
             "display",
-            "backend_key",
-            "display_name",
-            "adapter_type",
-            "api_root",
-            "model",
-            "authentication",
-            "response_mode",
-            "connect_timeout",
-            "read_timeout",
-            "enabled",
-            "tags",
+            *InferenceBackendForm.Meta.fields,
             "custom_fields",
             "created",
             "last_updated",

{netbox_data_import-2.2.0 → netbox_data_import-2.3.0}/netbox_data_import/api/urls.py

@@ -7,6 +7,8 @@ from netbox.api.routers import NetBoxRouter
 
 from .views import (
     ImportProfileViewSet,
+    CableClassMappingViewSet,
+    CableImportSourceViewSet,
     ColumnMappingViewSet,
     ClassRoleMappingViewSet,
     DeviceTypeMappingViewSet,
@@ -21,6 +23,8 @@ from .views import (
 
 router = NetBoxRouter()
 router.register("profiles", ImportProfileViewSet)
+router.register("cable-class-mappings", CableClassMappingViewSet)
+router.register("cable-provenance", CableImportSourceViewSet)
 router.register("column-mappings", ColumnMappingViewSet)
 router.register("class-role-mappings", ClassRoleMappingViewSet)
 router.register("device-type-mappings", DeviceTypeMappingViewSet)

{netbox_data_import-2.2.0 → netbox_data_import-2.3.0}/netbox_data_import/api/views.py

@@ -3,16 +3,17 @@
 """DRF viewsets for the data-import plugin API."""
 
 from django.http import Http404
-from netbox.api.viewsets import NetBoxModelViewSet, NetBoxReadOnlyModelViewSet
+from netbox.api.viewsets import NetBoxModelViewSet
 from rest_framework import mixins, permissions, viewsets
-from rest_framework.exceptions import ValidationError
+from rest_framework.exceptions import PermissionDenied, ValidationError
 from rest_framework.permissions import DjangoModelPermissions
 
 from ..field_keys import SELECT_TERMINATION_TASK, parse_termination_field_key
 from ..models import (
     locked_profile_policy,
-    locked_resolution_policy,
     ImportProfile,
+    CableClassMapping,
+    CableImportSource,
     ColumnMapping,
     ClassRoleMapping,
     DeviceTypeMapping,
@@ -23,8 +24,15 @@ from ..models import (
     InferenceBackend,
     ResolutionProposal,
 )
+from ..object_permissions import (
+    ObjectPermissionDenied,
+    delete_permission_scoped_objects,
+    save_permission_scoped_object,
+)
 from .serializers import (
     ImportProfileSerializer,
+    CableClassMappingSerializer,
+    CableImportSourceSerializer,
     ColumnMappingSerializer,
     ClassRoleMappingSerializer,
     DeviceTypeMappingSerializer,
@@ -84,6 +92,72 @@ class _PluginModelViewSet(_ProfileScopedQuerySetMixin, viewsets.ModelViewSet):
 
     permission_classes = [permissions.IsAuthenticated, DjangoModelPermissionsWithView]
 
+    def perform_create(self, serializer):
+        """Create one policy row inside its profile and object-permission scope."""
+        model = serializer.Meta.model
+        profile_id = serializer.validated_data["profile"].pk
+        try:
+            with locked_profile_policy(profile_id):
+                serializer.run_validation(serializer.initial_data)
+                values = serializer.model_cleaned_values()
+                profile = values.pop("profile")
+                result = save_permission_scoped_object(
+                    self.request.user,
+                    model,
+                    {"pk": None, "profile": profile},
+                    values,
+                    on_existing="reject",
+                )
+        except ImportProfile.DoesNotExist:
+            raise Http404 from None
+        except ObjectPermissionDenied as exc:
+            raise PermissionDenied from exc
+        serializer.instance = result.instance
+
+    def perform_update(self, serializer):
+        """Update one policy row under every affected profile and object scope."""
+        model = serializer.Meta.model
+        row_pk = serializer.instance.pk
+        stored_profile_id = model.objects.filter(pk=row_pk).values_list("profile_id", flat=True).first()
+        if stored_profile_id is None:
+            raise Http404
+        requested_profile = serializer.validated_data.get("profile")
+        requested_profile_id = requested_profile.pk if requested_profile is not None else stored_profile_id
+        try:
+            with locked_profile_policy(stored_profile_id, requested_profile_id):
+                serializer.instance = model.objects.get(pk=row_pk, profile_id=stored_profile_id)
+                serializer.run_validation(serializer.initial_data)
+                result = save_permission_scoped_object(
+                    self.request.user,
+                    model,
+                    {"pk": row_pk, "profile_id": stored_profile_id},
+                    serializer.model_cleaned_values(),
+                )
+        except (model.DoesNotExist, ImportProfile.DoesNotExist):
+            raise Http404 from None
+        except ObjectPermissionDenied as exc:
+            raise PermissionDenied from exc
+        serializer.instance = result.instance
+
+    def perform_destroy(self, instance):
+        """Delete one policy row under its current profile and object scope."""
+        model = type(instance)
+        profile_id = model.objects.filter(pk=instance.pk).values_list("profile_id", flat=True).first()
+        if profile_id is None:
+            raise Http404
+        try:
+            with locked_profile_policy(profile_id):
+                deleted = delete_permission_scoped_objects(
+                    self.request.user,
+                    model.objects.filter(pk=instance.pk, profile_id=profile_id),
+                )
+                if deleted != 1:
+                    raise Http404
+        except ImportProfile.DoesNotExist:
+            raise Http404 from None
+        except ObjectPermissionDenied as exc:
+            raise PermissionDenied from exc
+
 
 class ColumnMappingViewSet(_PluginModelViewSet):
     """CRUD viewset for ColumnMapping."""
@@ -92,6 +166,13 @@ class ColumnMappingViewSet(_PluginModelViewSet):
     serializer_class = ColumnMappingSerializer
 
 
+class CableClassMappingViewSet(_PluginModelViewSet):
+    """CRUD viewset for CableClassMapping."""
+
+    queryset = CableClassMapping.objects.select_related("profile")
+    serializer_class = CableClassMappingSerializer
+
+
 class ClassRoleMappingViewSet(_PluginModelViewSet):
     """CRUD viewset for ClassRoleMapping."""
 
@@ -120,53 +201,12 @@ class ColumnTransformRuleViewSet(_PluginModelViewSet):
     serializer_class = ColumnTransformRuleSerializer
 
 
-def _revalidate_against_the_stored_row(serializer):
-    """Read the resolution again and check the request against the row as it now stands.
-
-    save() writes every field, so a request that changed another field first would otherwise be
-    undone. The whole validation runs again rather than validate() alone, because the field checks
-    read the stored row too, and the profile lock makes this reading of it authoritative. The
-    result is discarded: the values are the request's own, which the first pass already holds.
-    """
-    serializer.instance = SourceResolution.objects.get(pk=serializer.instance.pk)
-    serializer.run_validation(serializer.initial_data)
-
-
 class SourceResolutionViewSet(_PluginModelViewSet):
     """CRUD viewset for SourceResolution (rerere)."""
 
     queryset = SourceResolution.objects.select_related("profile")
     serializer_class = SourceResolutionSerializer
 
-    # Each write serializes against an executing import, which holds the same profile row.
-    def perform_create(self, serializer):
-        """Create the resolution under the profile lock."""
-        try:
-            with locked_profile_policy(serializer.validated_data["profile"].pk):
-                serializer.save()
-        except ImportProfile.DoesNotExist:
-            # The profile is read to validate the request, and can be deleted before the lock.
-            raise Http404 from None
-
-    def perform_update(self, serializer):
-        """Update the resolution under its profile lock."""
-        # ValidatedModelSerializer.validate() writes the request values onto the instance, so only
-        # its primary key still names the stored row.
-        try:
-            with locked_resolution_policy(serializer.instance.pk):
-                _revalidate_against_the_stored_row(serializer)
-                serializer.save()
-        except (SourceResolution.DoesNotExist, ImportProfile.DoesNotExist):
-            raise Http404 from None
-
-    def perform_destroy(self, instance):
-        """Delete the resolution under its profile lock."""
-        try:
-            with locked_resolution_policy(instance.pk):
-                instance.delete()
-        except (SourceResolution.DoesNotExist, ImportProfile.DoesNotExist):
-            raise Http404 from None
-
 
 class ImportExecutionViewSet(_ProfileScopedQuerySetMixin, viewsets.ReadOnlyModelViewSet):
     """Read-only viewset for the Import Execution audit history."""
@@ -176,6 +216,27 @@ class ImportExecutionViewSet(_ProfileScopedQuerySetMixin, viewsets.ReadOnlyModel
     permission_classes = [permissions.IsAuthenticated, DjangoModelPermissionsWithView]
 
 
+class CableImportSourceViewSet(_ProfileScopedQuerySetMixin, viewsets.ReadOnlyModelViewSet):
+    """Read-only viewset for per-Cable import provenance."""
+
+    queryset = CableImportSource.objects.select_related("cable", "profile")
+    serializer_class = CableImportSourceSerializer
+    permission_classes = [permissions.IsAuthenticated, DjangoModelPermissionsWithView]
+
+    def get_queryset(self):
+        """Apply the profile scope and an optional Cable ID filter."""
+        profile_scope = ImportProfile.objects.restrict(self.request.user, "view")
+        qs = super().get_queryset().filter(profile__in=profile_scope)
+        cable_id = self.request.query_params.get("cable_id")
+        if cable_id is not None:
+            try:
+                cable_id = int(cable_id)
+            except (TypeError, ValueError) as exc:
+                raise ValidationError({"cable_id": "Enter a whole number."}) from exc
+            qs = qs.filter(cable_id=cable_id)
+        return qs
+
+
 class ResolutionProposalViewSet(_ProfileScopedQuerySetMixin, viewsets.ReadOnlyModelViewSet):
     """Read-only viewset for Resolution Proposal history."""
 
@@ -225,12 +286,8 @@ class ResolutionProposalHistoryViewSet(mixins.ListModelMixin, viewsets.GenericVi
         )
 
 
-class InferenceBackendViewSet(NetBoxReadOnlyModelViewSet):
-    """Read-only viewset for Inference Backend rows.
-
-    Read-only on purpose: a backend row carries the destination NetBox itself calls, and the UI form
-    is the one place that validates the `api_root` trust boundary against the allowlist.
-    """
+class InferenceBackendViewSet(NetBoxModelViewSet):
+    """CRUD viewset whose configuration fields derive from the Inference Backend form."""
 
     queryset = InferenceBackend.objects.prefetch_related("tags")
     serializer_class = InferenceBackendSerializer

netbox_data_import-2.3.0/netbox_data_import/graphql/schema.py

@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
+
+"""GraphQL queries registered with NetBox."""
+
+import strawberry
+import strawberry_django
+
+from .types import CableClassMappingType, ImportProfileType
+
+
+@strawberry.type(name="Query")
+class ImportProfilesQuery:
+    """Expose import profile detail and list queries."""
+
+    import_profile: ImportProfileType = strawberry_django.field()
+    import_profile_list: list[ImportProfileType] = strawberry_django.field()
+
+
+@strawberry.type(name="Query")
+class CableClassMappingsQuery:
+    """Expose CableClass mapping detail and list queries."""
+
+    cable_class_mapping: CableClassMappingType = strawberry_django.field()
+    cable_class_mapping_list: list[CableClassMappingType] = strawberry_django.field()
+
+
+schema = [ImportProfilesQuery, CableClassMappingsQuery]
+
+__all__ = ("CableClassMappingsQuery", "ImportProfilesQuery", "schema")

netbox_data_import-2.3.0/netbox_data_import/graphql/types.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
+
+"""GraphQL object types for import profile configuration."""
+
+import strawberry_django
+from netbox.graphql.types import BaseObjectType, NetBoxObjectType
+
+from netbox_data_import.models import CableClassMapping, ImportProfile
+
+from .filters import ImportProfileFilter
+
+_type_kwargs = {"fields": "__all__", "pagination": True}
+if ImportProfileFilter is not None:  # pragma: no cover
+    _type_kwargs["filters"] = ImportProfileFilter
+
+
+@strawberry_django.type(ImportProfile, **_type_kwargs)
+class ImportProfileType(NetBoxObjectType):
+    """One saved source-file import configuration."""
+
+
+@strawberry_django.type(
+    CableClassMapping,
+    fields=[
+        "id",
+        "profile",
+        "cable_class",
+        "cable_type_resolved",
+        "cable_type",
+        "cable_profile_resolved",
+        "cable_profile",
+    ],
+    pagination=True,
+)
+class CableClassMappingType(BaseObjectType):
+    """One trace CableClass policy decision."""
+
+    profile: ImportProfileType
+
+
+__all__ = ("CableClassMappingType", "ImportProfileType")

{netbox_data_import-2.2.0 → netbox_data_import-2.3.0}/netbox_data_import/models.py

@@ -1784,6 +1784,8 @@ class CableImportSource(DigestIndexedMixin):
     DIGEST_SOURCE_FIELD = "trace_identity"
     DIGEST_FIELD = "trace_key"
 
+    objects = RestrictedQuerySet.as_manager()
+
     cable = models.ForeignKey(
         to="dcim.Cable",
         on_delete=models.CASCADE,