netbox-cadplan 0.2.0__py3-none-any.whl

netbox_cadplan/__init__.py

@@ -0,0 +1,28 @@
+try:
+    from netbox.plugins import PluginConfig
+except Exception:
+    # Minimal fallback for local development / tests when NetBox is not
+    # available. This avoids import-time errors during pytest collection.
+    class PluginConfig:  # type: ignore
+        pass
+
+
+class NetBoxCadPlanConfig(PluginConfig):
+    name = "netbox_cadplan"
+    verbose_name = "NetBox CadPlan"
+    description = "Visual floor-plan management linked to Sites and Locations"
+    version = "0.2.0"
+    author = "Simon Lacroix"
+    author_email = "simonlacroix@live.ca"
+    base_url = "cadplan"
+    min_version = "4.6.0"
+    max_version = "4.6.99"
+    required_settings = []
+    default_settings = {}
+
+    def ready(self):
+        super().ready()
+        from . import signals  # noqa: F401
+
+
+config = NetBoxCadPlanConfig

netbox_cadplan/api/serializers.py

@@ -0,0 +1,125 @@
+from core.models import ObjectType
+from dcim.api.serializers import (
+    DeviceTypeSerializer,
+    LocationSerializer,
+    SiteSerializer,
+)
+from netbox.api.fields import ContentTypeField
+from netbox.api.gfk_fields import GFKSerializerField
+from netbox.api.serializers import NetBoxModelSerializer
+from rest_framework import serializers
+
+from ..models import DeviceTypeShape, PlacedObject, Plan, PlanZone
+
+
+class PlanSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cadplan-api:plan-detail"
+    )
+    site = SiteSerializer(nested=True)
+    location = LocationSerializer(nested=True, required=False, allow_null=True)
+
+    class Meta:
+        model = Plan
+        fields = [
+            "id",
+            "url",
+            "display",
+            "name",
+            "site",
+            "location",
+            "dxf_file",
+            "selected_layer",
+            "width_px",
+            "height_px",
+            "mm_per_px",
+            "tags",
+            "custom_fields",
+            "created",
+            "last_updated",
+        ]
+        brief_fields = ("id", "url", "display", "name")
+
+
+class PlanZoneSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cadplan-api:planzone-detail"
+    )
+    plan = PlanSerializer(nested=True)
+    location = LocationSerializer(nested=True, required=False, allow_null=True)
+
+    class Meta:
+        model = PlanZone
+        fields = [
+            "id",
+            "url",
+            "display",
+            "plan",
+            "number",
+            "location",
+            "polygon_data",
+            "svg_file",
+            "label",
+            "tags",
+            "custom_fields",
+            "created",
+            "last_updated",
+        ]
+        brief_fields = ("id", "url", "display", "number", "label")
+
+
+class DeviceTypeShapeSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cadplan-api:devicetypeshape-detail"
+    )
+    device_type = DeviceTypeSerializer(nested=True)
+
+    class Meta:
+        model = DeviceTypeShape
+        fields = [
+            "id",
+            "url",
+            "display",
+            "device_type",
+            "shape",
+            "width",
+            "depth",
+            "diameter",
+            "unit",
+            "tags",
+            "custom_fields",
+            "created",
+            "last_updated",
+        ]
+        brief_fields = ("id", "url", "display", "device_type", "shape")
+
+
+class PlacedObjectSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_cadplan-api:placedobject-detail"
+    )
+    zone = PlanZoneSerializer(nested=True)
+    object_type = ContentTypeField(queryset=ObjectType.objects.all())
+    object = GFKSerializerField(source="content_object", read_only=True)
+
+    class Meta:
+        model = PlacedObject
+        fields = [
+            "id",
+            "url",
+            "display",
+            "zone",
+            "object_type",
+            "object_id",
+            "object",
+            "x",
+            "y",
+            "rotation",
+            "snap_to_wall",
+            "name_position",
+            "tags",
+            "custom_fields",
+            "created",
+            "last_updated",
+        ]
+        brief_fields = ("id", "url", "display", "object_type", "object_id")

netbox_cadplan/api/urls.py

@@ -0,0 +1,12 @@
+from netbox.api.routers import NetBoxRouter
+
+from . import views
+
+app_name = "netbox_cadplan"
+router = NetBoxRouter()
+router.register("plans", views.PlanViewSet)
+router.register("plan-zones", views.PlanZoneViewSet)
+router.register("device-type-shapes", views.DeviceTypeShapeViewSet)
+router.register("placed-objects", views.PlacedObjectViewSet)
+
+urlpatterns = router.urls

netbox_cadplan/api/views.py

@@ -0,0 +1,30 @@
+from netbox.api.viewsets import NetBoxModelViewSet
+
+from .. import filtersets, models
+from .serializers import (
+    DeviceTypeShapeSerializer,
+    PlacedObjectSerializer,
+    PlanSerializer,
+    PlanZoneSerializer,
+)
+
+
+class PlanViewSet(NetBoxModelViewSet):
+    queryset = models.Plan.objects.all()
+    serializer_class = PlanSerializer
+    filterset_class = filtersets.PlanFilterSet
+
+
+class PlanZoneViewSet(NetBoxModelViewSet):
+    queryset = models.PlanZone.objects.all()
+    serializer_class = PlanZoneSerializer
+
+
+class DeviceTypeShapeViewSet(NetBoxModelViewSet):
+    queryset = models.DeviceTypeShape.objects.all()
+    serializer_class = DeviceTypeShapeSerializer
+
+
+class PlacedObjectViewSet(NetBoxModelViewSet):
+    queryset = models.PlacedObject.objects.all()
+    serializer_class = PlacedObjectSerializer

netbox_cadplan/choices.py

@@ -0,0 +1,41 @@
+from django.utils.translation import gettext_lazy as _
+from utilities.choices import ChoiceSet
+
+
+class ShapeChoices(ChoiceSet):
+
+    RECTANGLE = "rectangle"
+    CIRCLE = "circle"
+
+    CHOICES = (
+        (RECTANGLE, _("Rectangle")),
+        (CIRCLE, _("Circle")),
+    )
+
+
+class LengthUnitChoices(ChoiceSet):
+
+    UNIT_CENTIMETER = "cm"
+    UNIT_INCH = "in"
+
+    CHOICES = (
+        (UNIT_CENTIMETER, _("Centimeters")),
+        (UNIT_INCH, _("Inches")),
+    )
+
+
+class NamePositionChoices(ChoiceSet):
+
+    TOP = "top"
+    BOTTOM = "bottom"
+    LEFT = "left"
+    RIGHT = "right"
+    CENTER = "center"
+
+    CHOICES = (
+        (TOP, _("Top")),
+        (BOTTOM, _("Bottom")),
+        (LEFT, _("Left")),
+        (RIGHT, _("Right")),
+        (CENTER, _("Center")),
+    )

netbox_cadplan/filtersets.py

@@ -0,0 +1,20 @@
+import django_filters
+from django.db.models import Q
+from netbox.filtersets import NetBoxModelFilterSet
+
+from .models import Plan
+
+
+class PlanFilterSet(NetBoxModelFilterSet):
+    q = django_filters.CharFilter(method="search", label="Search")
+
+    class Meta:
+        model = Plan
+        fields = ("id", "name", "site", "location", "selected_layer")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(name__icontains=value) | Q(selected_layer__icontains=value)
+        )

netbox_cadplan/forms.py

@@ -0,0 +1,92 @@
+from dcim.models import Location, Site
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+from netbox.forms import NetBoxModelForm
+from utilities.forms.fields import DynamicModelChoiceField
+from utilities.forms.rendering import FieldSet, InlineFields
+
+from .models import DeviceTypeShape, Plan
+
+MAX_DXF_UPLOAD_SIZE = 50 * 1024 * 1024  # 50 Mo
+
+
+def _validate_dxf_size(dxf_file):
+    if dxf_file and dxf_file.size > MAX_DXF_UPLOAD_SIZE:
+        raise ValidationError(
+            _("The DXF/DWG file exceeds the maximum allowed size (50 MB).")
+        )
+    return dxf_file
+
+
+class PlanForm(NetBoxModelForm):
+    site = DynamicModelChoiceField(
+        queryset=Site.objects.all(),
+        required=True,
+    )
+    location = DynamicModelChoiceField(
+        queryset=Location.objects.all(),
+        required=False,
+        query_params={"site_id": "$site"},
+        help_text=_(
+            "Optional NetBox Location (leave empty for a plan covering the whole site)"
+        ),
+    )
+
+    fieldsets = (FieldSet("name", "site", "location", "dxf_file", name=_("Plan")),)
+
+    class Meta:
+        model = Plan
+        fields = ("name", "site", "location", "dxf_file")
+
+    def clean_dxf_file(self):
+        return _validate_dxf_size(self.cleaned_data.get("dxf_file"))
+
+    def clean(self):
+        super().clean()
+        cleaned_data = self.cleaned_data
+        site = cleaned_data.get("site")
+        location = cleaned_data.get("location")
+        if site and location and location.site_id != site.id:
+            self.add_error(
+                "location",
+                _("The selected location does not belong to the chosen site."),
+            )
+        return cleaned_data
+
+
+class ReimportDxfForm(NetBoxModelForm):
+    """
+    Replaces only the DXF file of an already-confirmed plan (not name/site/location,
+    unlike PlanForm) — clears selected_layer on save to make the layer selection
+    panel reappear (see PlanReimportDxfView).
+    """
+
+    fieldsets = (FieldSet("dxf_file", name=_("Reimport a DXF")),)
+
+    class Meta:
+        model = Plan
+        fields = ("dxf_file",)
+
+    def clean_dxf_file(self):
+        return _validate_dxf_size(self.cleaned_data.get("dxf_file"))
+
+    def save(self, commit=True):
+        instance = super().save(commit=False)
+        instance.selected_layer = ""
+        if commit:
+            instance.save()
+        return instance
+
+
+class DeviceTypeShapeForm(NetBoxModelForm):
+    fieldsets = (
+        FieldSet(
+            "shape",
+            InlineFields("width", "depth", "diameter", "unit", label=_("Dimensions")),
+            name=_("Shape"),
+        ),
+    )
+
+    class Meta:
+        model = DeviceTypeShape
+        fields = ("shape", "width", "depth", "diameter", "unit")