debug of strawbery django filter

Author: jirivrany

cesnet_service_path_plugin/graphql/filters.py

@@ -104,27 +104,6 @@ class SegmentFilter(NetBoxModelFilterMixin):
     # Custom filter for checking if segment has type-specific data
     has_type_specific_data: Optional[bool] = None
 
-    # Type-specific field filters - Dark Fiber
-    fiber_type: FilterLookup[str] | None = None
-    fiber_attenuation_max: Optional[TypeSpecificNumericFilter] = None
-    total_loss: Optional[TypeSpecificNumericFilter] = None
-    total_length: Optional[TypeSpecificNumericFilter] = None
-    number_of_fibers: Optional[TypeSpecificIntegerFilter] = None
-    connector_type: FilterLookup[str] | None = None
-
-    # Type-specific field filters - Optical Spectrum
-    wavelength: Optional[TypeSpecificNumericFilter] = None
-    spectral_slot_width: Optional[TypeSpecificNumericFilter] = None
-    itu_grid_position: Optional[TypeSpecificIntegerFilter] = None
-    modulation_format: FilterLookup[str] | None = None
-
-    # Type-specific field filters - Ethernet Service
-    port_speed: Optional[TypeSpecificIntegerFilter] = None
-    vlan_id: Optional[TypeSpecificIntegerFilter] = None
-    mtu_size: Optional[TypeSpecificIntegerFilter] = None
-    encapsulation_type: FilterLookup[str] | None = None
-    interface_type: FilterLookup[str] | None = None
-
     def filter_has_path_data(self, queryset, info):
         if self.has_path_data is None:
             return queryset
@@ -141,167 +120,6 @@ def filter_has_type_specific_data(self, queryset, info):
         else:
             return queryset.filter(type_specific_data={})
 
-    def filter_fiber_type(self, queryset, info):
-        if self.fiber_type is None:
-            return queryset
-        return queryset.filter(type_specific_data__fiber_type=self.fiber_type)
-
-    def filter_connector_type(self, queryset, info):
-        if self.connector_type is None:
-            return queryset
-        return queryset.filter(type_specific_data__connector_type=self.connector_type)
-
-    def filter_modulation_format(self, queryset, info):
-        if self.modulation_format is None:
-            return queryset
-        return queryset.filter(type_specific_data__modulation_format=self.modulation_format)
-
-    def filter_encapsulation_type(self, queryset, info):
-        if self.encapsulation_type is None:
-            return queryset
-        return queryset.filter(type_specific_data__encapsulation_type=self.encapsulation_type)
-
-    def filter_interface_type(self, queryset, info):
-        if self.interface_type is None:
-            return queryset
-        return queryset.filter(type_specific_data__interface_type=self.interface_type)
-
-    def _filter_numeric_field(self, queryset, field_name: str, filter_input: TypeSpecificNumericFilter):
-        """Helper method to filter numeric type-specific fields"""
-        if filter_input is None:
-            return queryset
-
-        conditions = Q(type_specific_data__has_key=field_name)
-
-        if filter_input.exact is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::decimal = %s"], params=[field_name, filter_input.exact]
-                ).values("pk")
-            )
-
-        if filter_input.gt is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::decimal > %s"], params=[field_name, filter_input.gt]
-                ).values("pk")
-            )
-
-        if filter_input.gte is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::decimal >= %s"], params=[field_name, filter_input.gte]
-                ).values("pk")
-            )
-
-        if filter_input.lt is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::decimal < %s"], params=[field_name, filter_input.lt]
-                ).values("pk")
-            )
-
-        if filter_input.lte is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::decimal <= %s"], params=[field_name, filter_input.lte]
-                ).values("pk")
-            )
-
-        if filter_input.range_min is not None and filter_input.range_max is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::decimal BETWEEN %s AND %s"],
-                    params=[field_name, filter_input.range_min, filter_input.range_max],
-                ).values("pk")
-            )
-
-        return queryset.filter(conditions)
-
-    def _filter_integer_field(self, queryset, field_name: str, filter_input: TypeSpecificIntegerFilter):
-        """Helper method to filter integer type-specific fields"""
-        if filter_input is None:
-            return queryset
-
-        conditions = Q(type_specific_data__has_key=field_name)
-
-        if filter_input.exact is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::integer = %s"], params=[field_name, filter_input.exact]
-                ).values("pk")
-            )
-
-        if filter_input.gt is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::integer > %s"], params=[field_name, filter_input.gt]
-                ).values("pk")
-            )
-
-        if filter_input.gte is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::integer >= %s"], params=[field_name, filter_input.gte]
-                ).values("pk")
-            )
-
-        if filter_input.lt is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::integer < %s"], params=[field_name, filter_input.lt]
-                ).values("pk")
-            )
-
-        if filter_input.lte is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::integer <= %s"], params=[field_name, filter_input.lte]
-                ).values("pk")
-            )
-
-        if filter_input.range_min is not None and filter_input.range_max is not None:
-            conditions &= Q(
-                pk__in=queryset.extra(
-                    where=["(type_specific_data->>%s)::integer BETWEEN %s AND %s"],
-                    params=[field_name, filter_input.range_min, filter_input.range_max],
-                ).values("pk")
-            )
-
-        return queryset.filter(conditions)
-
-    # Apply filters for numeric fields
-    def filter_fiber_attenuation_max(self, queryset, info):
-        return self._filter_numeric_field(queryset, "fiber_attenuation_max", self.fiber_attenuation_max)
-
-    def filter_total_loss(self, queryset, info):
-        return self._filter_numeric_field(queryset, "total_loss", self.total_loss)
-
-    def filter_total_length(self, queryset, info):
-        return self._filter_numeric_field(queryset, "total_length", self.total_length)
-
-    def filter_wavelength(self, queryset, info):
-        return self._filter_numeric_field(queryset, "wavelength", self.wavelength)
-
-    def filter_spectral_slot_width(self, queryset, info):
-        return self._filter_numeric_field(queryset, "spectral_slot_width", self.spectral_slot_width)
-
-    # Apply filters for integer fields
-    def filter_number_of_fibers(self, queryset, info):
-        return self._filter_integer_field(queryset, "number_of_fibers", self.number_of_fibers)
-
-    def filter_itu_grid_position(self, queryset, info):
-        return self._filter_integer_field(queryset, "itu_grid_position", self.itu_grid_position)
-
-    def filter_port_speed(self, queryset, info):
-        return self._filter_integer_field(queryset, "port_speed", self.port_speed)
-
-    def filter_vlan_id(self, queryset, info):
-        return self._filter_integer_field(queryset, "vlan_id", self.vlan_id)
-
-    def filter_mtu_size(self, queryset, info):
-        return self._filter_integer_field(queryset, "mtu_size", self.mtu_size)
-
 
 @strawberry_django.filter(ServicePath, lookups=True)
 class ServicePathFilter(NetBoxModelFilterMixin):

cesnet_service_path_plugin/graphql/types.py

@@ -1,12 +1,13 @@
 from typing import Annotated, List, Optional
-
+import logging
 from circuits.graphql.types import CircuitType, ProviderType
 from dcim.graphql.types import LocationType, SiteType
 from netbox.graphql.types import NetBoxObjectType
 from strawberry import auto, lazy, field
 from strawberry_django import type as strawberry_django_type
 import strawberry
 
+
 from cesnet_service_path_plugin.models import (
     Segment,
     SegmentCircuitMapping,
@@ -23,6 +24,9 @@
 )
 
 
+logger = logging.getLogger(__name__)
+
+
 # Custom scalar types for path geometry data
 @strawberry.type
 class PathBounds:
@@ -65,13 +69,20 @@ class SegmentType(NetBoxObjectType):
     # Circuit relationships
     circuits: List[Annotated["CircuitType", lazy("circuits.graphql.types")]]
 
+    @field
+    def has_type_specific_data(self) -> bool:
+        """Whether this segment has type-specific data"""
+        if hasattr(self, "has_type_specific_data"):
+            return self.has_type_specific_data()
+        logger.warning("Segment has no type-specific data")
+        logger.debug(f"Type-specific data: {self.type_specific_data}")
+        return bool(self.type_specific_data)
+
     @field
     def has_path_data(self) -> bool:
         """Whether this segment has path geometry data"""
-        # Make sure this method exists on your model
         if hasattr(self, "has_path_data") and callable(getattr(self, "has_path_data")):
             return self.has_path_data()
-        # Fallback: check if path_geometry field has data
         return bool(self.path_geometry)
 
     @field