Merge branch 'gispath' into 'master'

Version 5.0 – GIS Path enablede (Breaking Changes)

See merge request 701/netbox/cesnet_service_path_plugin!25

Author: Kani999

cesnet_service_path_plugin/__init__.py

@@ -1,8 +1,15 @@
 """Top-level package for Cesnet ServicePath Plugin."""
 
+from importlib import metadata
 from netbox.plugins import PluginConfig
 
-from .version import __description__, __name__, __version__
+# Get package metadata from pyproject.toml
+_metadata = metadata.metadata("cesnet_service_path_plugin")
+__version__ = _metadata["Version"]
+__description__ = _metadata["Summary"]
+__name__ = _metadata["Name"]
+__author__ = _metadata["Author"]
+__email__ = _metadata["Author-email"]
 
 
 class CesnetServicePathPluginConfig(PluginConfig):
@@ -11,6 +18,7 @@ class CesnetServicePathPluginConfig(PluginConfig):
     description = __description__
     version = __version__
     base_url = "cesnet-service-path-plugin"
+    author = __email__
 
 
 config = CesnetServicePathPluginConfig

cesnet_service_path_plugin/api/serializers/segment.py

@@ -1,3 +1,4 @@
+import json
 from circuits.api.serializers import CircuitSerializer, ProviderSerializer
 from dcim.api.serializers import (
     LocationSerializer,
@@ -7,19 +8,23 @@
 from rest_framework import serializers
 
 from cesnet_service_path_plugin.models.segment import Segment
+from cesnet_service_path_plugin.utils import export_segment_paths_as_geojson
 
 
 class SegmentSerializer(NetBoxModelSerializer):
-    url = serializers.HyperlinkedIdentityField(
-        view_name="plugins-api:cesnet_service_path_plugin-api:segment-detail"
-    )
+    """Default serializer Segment - excludes heavy geometry fields"""
+
+    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:cesnet_service_path_plugin-api:segment-detail")
     provider = ProviderSerializer(required=True, nested=True)
     site_a = SiteSerializer(required=True, nested=True)
     location_a = LocationSerializer(required=True, nested=True)
     site_b = SiteSerializer(required=True, nested=True)
     location_b = LocationSerializer(required=True, nested=True)
     circuits = CircuitSerializer(required=False, many=True, nested=True)
 
+    # Only include lightweight path info
+    has_path_data = serializers.SerializerMethodField(read_only=True)
+
     class Meta:
         model = Segment
         fields = (
@@ -40,6 +45,11 @@ class Meta:
             "site_b",
             "location_b",
             "circuits",
+            # Only basic path info, no heavy geometry
+            "path_length_km",
+            "path_source_format",
+            "path_notes",
+            "has_path_data",
             "tags",
         )
         brief_fields = (
@@ -48,9 +58,165 @@ class Meta:
             "display",
             "name",
             "status",
+            "has_path_data",
             "tags",
         )
 
+    def get_has_path_data(self, obj):
+        return obj.has_path_data()
+
+
+class SegmentListSerializer(NetBoxModelSerializer):
+    """Lightweight serializer for list views - excludes heavy geometry fields"""
+
+    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:cesnet_service_path_plugin-api:segment-detail")
+    provider = ProviderSerializer(required=True, nested=True)
+    site_a = SiteSerializer(required=True, nested=True)
+    location_a = LocationSerializer(required=True, nested=True)
+    site_b = SiteSerializer(required=True, nested=True)
+    location_b = LocationSerializer(required=True, nested=True)
+    circuits = CircuitSerializer(required=False, many=True, nested=True)
+
+    # Only include lightweight path info
+    has_path_data = serializers.SerializerMethodField(read_only=True)
+
+    class Meta:
+        model = Segment
+        fields = (
+            "id",
+            "url",
+            "display",
+            "name",
+            "status",
+            "network_label",
+            "install_date",
+            "termination_date",
+            "provider",
+            "provider_segment_id",
+            "provider_segment_name",
+            "provider_segment_contract",
+            "site_a",
+            "location_a",
+            "site_b",
+            "location_b",
+            "circuits",
+            # Only basic path info, no heavy geometry
+            "path_length_km",
+            "path_source_format",
+            "path_notes",
+            "has_path_data",
+            "tags",
+        )
+        brief_fields = (
+            "id",
+            "url",
+            "display",
+            "name",
+            "status",
+            "has_path_data",
+            "tags",
+        )
+
+    def get_has_path_data(self, obj):
+        return obj.has_path_data()
+
+
+class SegmentDetailSerializer(NetBoxModelSerializer):
+    """Full serializer with all geometry data for detail views"""
+
+    # This is your existing SegmentSerializer - just rename it
+    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:cesnet_service_path_plugin-api:segment-detail")
+    provider = ProviderSerializer(required=True, nested=True)
+    site_a = SiteSerializer(required=True, nested=True)
+    location_a = LocationSerializer(required=True, nested=True)
+    site_b = SiteSerializer(required=True, nested=True)
+    location_b = LocationSerializer(required=True, nested=True)
+    circuits = CircuitSerializer(required=False, many=True, nested=True)
+
+    # All the heavy geometry fields
+    path_geometry_geojson = serializers.SerializerMethodField(read_only=True)
+    path_coordinates = serializers.SerializerMethodField(read_only=True)
+    path_bounds = serializers.SerializerMethodField(read_only=True)
+    has_path_data = serializers.SerializerMethodField(read_only=True)
+
+    class Meta:
+        model = Segment
+        fields = (
+            "id",
+            "url",
+            "display",
+            "name",
+            "status",
+            "network_label",
+            "install_date",
+            "termination_date",
+            "provider",
+            "provider_segment_id",
+            "provider_segment_name",
+            "provider_segment_contract",
+            "site_a",
+            "location_a",
+            "site_b",
+            "location_b",
+            "circuits",
+            # All path geometry fields
+            "path_geometry_geojson",
+            "path_coordinates",
+            "path_bounds",
+            "path_length_km",
+            "path_source_format",
+            "path_notes",
+            "has_path_data",
+            "tags",
+        )
+        brief_fields = (
+            "id",
+            "url",
+            "display",
+            "name",
+            "status",
+            "has_path_data",
+            "tags",
+        )
+
+    def get_path_geometry_geojson(self, obj):
+        """
+        Return path geometry as GeoJSON Feature
+        """
+        if not obj.has_path_data():
+            return None
+
+        try:
+
+            geojson_str = export_segment_paths_as_geojson([obj])
+            geojson_data = json.loads(geojson_str)
+
+            # Return just the first (and only) feature, not the entire FeatureCollection
+            if geojson_data.get("features"):
+                return geojson_data["features"][0]
+            return None
+        except Exception:
+            # Fallback to basic GeoJSON if utility function fails
+            return obj.get_path_geojson()
+
+    def get_path_coordinates(self, obj):
+        """
+        Return path coordinates as list of LineString coordinate arrays
+        """
+        return obj.get_path_coordinates()
+
+    def get_path_bounds(self, obj):
+        """
+        Return bounding box of the path geometry [xmin, ymin, xmax, ymax]
+        """
+        return obj.get_path_bounds()
+
+    def get_has_path_data(self, obj):
+        """
+        Return boolean indicating if segment has path data
+        """
+        return obj.has_path_data()
+
     def validate(self, data):
         # Enforce model validation
         super().validate(data)

cesnet_service_path_plugin/api/serializers/segment_circuit_mapping.py

@@ -1,16 +1,17 @@
 from rest_framework import serializers
 from netbox.api.serializers import NetBoxModelSerializer
-from cesnet_service_path_plugin.api.serializers.segment import SegmentSerializer
+from cesnet_service_path_plugin.api.serializers.segment import SegmentListSerializer
 from cesnet_service_path_plugin.api.serializers.service_path import ServicePathSerializer
 from cesnet_service_path_plugin.models import SegmentCircuitMapping
 from circuits.api.serializers import CircuitSerializer
 
+
 class SegmentCircuitMappingSerializer(NetBoxModelSerializer):
     url = serializers.HyperlinkedIdentityField(
         view_name="plugins-api:cesnet_service_path_plugin-api:segmentcircuitmapping-detail"
     )
     circuit = CircuitSerializer(nested=True)
-    segment = SegmentSerializer(nested=True)
+    segment = SegmentListSerializer(nested=True)
 
     class Meta:
         model = SegmentCircuitMapping

cesnet_service_path_plugin/api/serializers/service_path.py

@@ -2,15 +2,15 @@
 from netbox.api.serializers import NetBoxModelSerializer
 from rest_framework import serializers
 
-from cesnet_service_path_plugin.api.serializers.segment import SegmentSerializer
+from cesnet_service_path_plugin.api.serializers.segment import SegmentListSerializer
 from cesnet_service_path_plugin.models import ServicePath
 
 
 class ServicePathSerializer(NetBoxModelSerializer):
     url = serializers.HyperlinkedIdentityField(
         view_name="plugins-api:cesnet_service_path_plugin-api:servicepath-detail"
     )
-    segments = SegmentSerializer(many=True, read_only=True, nested=True)
+    segments = SegmentListSerializer(many=True, read_only=True, nested=True)
     circuits = CircuitSerializer(required=False, many=True, nested=True)
 
     class Meta:

cesnet_service_path_plugin/api/serializers/service_path_segment_mapping.py

@@ -1,6 +1,6 @@
 from rest_framework import serializers
 from netbox.api.serializers import NetBoxModelSerializer
-from cesnet_service_path_plugin.api.serializers.segment import SegmentSerializer
+from cesnet_service_path_plugin.api.serializers.segment import SegmentListSerializer
 from cesnet_service_path_plugin.api.serializers.service_path import (
     ServicePathSerializer,
 )
@@ -16,7 +16,7 @@ class ServicePathSegmentMappingSerializer(NetBoxModelSerializer):
     #    required=True
     # )
     service_path = ServicePathSerializer(nested=True)
-    segment = SegmentSerializer(nested=True)
+    segment = SegmentListSerializer(nested=True)
 
     class Meta:
         model = ServicePathSegmentMapping

cesnet_service_path_plugin/api/views/segment.py

@@ -3,11 +3,21 @@
 
 from cesnet_service_path_plugin.models import Segment
 from cesnet_service_path_plugin.filtersets import SegmentFilterSet
-from cesnet_service_path_plugin.api.serializers import SegmentSerializer
+from cesnet_service_path_plugin.api.serializers import SegmentSerializer, SegmentDetailSerializer
 
 
 class SegmentViewSet(NetBoxModelViewSet):
     metadata_class = ContentTypeMetadata
     queryset = Segment.objects.all()
-    serializer_class = SegmentSerializer
     filterset_class = SegmentFilterSet
+
+    def get_serializer_class(self):
+        """
+        Return appropriate serializer based on action
+        """
+        if self.action == "retrieve":
+            pathdata = self.request.query_params.get("pathdata", "false").lower() == "true"
+            if pathdata:
+                return SegmentDetailSerializer
+
+        return SegmentSerializer

cesnet_service_path_plugin/filtersets/segment.py

@@ -76,6 +76,16 @@ class SegmentFilterSet(NetBoxModelFilterSet):
         label="Circuit (ID)",
     )
 
+    # New filter for path data
+    has_path_data = django_filters.MultipleChoiceFilter(
+        choices=[
+            (True, "Yes"),
+            (False, "No"),
+        ],
+        method="_has_path_data",
+        label="Has Path Data",
+    )
+
     class Meta:
         model = Segment
         fields = [
@@ -92,6 +102,7 @@ class Meta:
             "location_a",
             "site_b",
             "location_b",
+            "has_path_data",  # Added to Meta fields
         ]
 
     def _at_any_site(self, queryset, name, value):
@@ -110,6 +121,42 @@ def _at_any_location(self, queryset, name, value):
         location_b = Q(location_b__in=value)
         return queryset.filter(location_a | location_b)
 
+    def _has_path_data(self, queryset, name, value):
+        """
+        Filter segments based on whether they have path data or not
+
+        Args:
+            value: List of selected values from choices
+                   [True] - show only segments with path data
+                   [False] - show only segments without path data
+                   [True, False] - show all segments (both with and without)
+                   [] - show all segments (nothing selected)
+        """
+        if not value:
+            # Nothing selected, show all segments
+            return queryset
+
+        # Convert string values to boolean (django-filter sometimes passes strings)
+        bool_values = []
+        for v in value:
+            if v is True or v == "True" or v == True:
+                bool_values.append(True)
+            elif v is False or v == "False" or v == False:
+                bool_values.append(False)
+
+        if True in bool_values and False in bool_values:
+            # Both selected, show all segments
+            return queryset
+        elif True in bool_values:
+            # Only "Yes" selected, show segments with path data
+            return queryset.filter(path_geometry__isnull=False)
+        elif False in bool_values:
+            # Only "No" selected, show segments without path data
+            return queryset.filter(path_geometry__isnull=True)
+        else:
+            # Fallback: show all segments
+            return queryset
+
     def search(self, queryset, name, value):
         site_a = Q(site_a__name__icontains=value)
         site_b = Q(site_b__name__icontains=value)
@@ -121,12 +168,5 @@ def search(self, queryset, name, value):
         status = Q(status__iexact=value)
 
         return queryset.filter(
-            site_a
-            | site_b
-            | location_a
-            | location_b
-            | segment_name
-            | network_label
-            | provider_segment_id
-            | status
+            site_a | site_b | location_a | location_b | segment_name | network_label | provider_segment_id | status
         )