ipfabric_netbox 4.3.2b9__py3-none-any.whl → 4.3.2b11__py3-none-any.whl

ipfabric_netbox/forms.py

@@ -1,5 +1,3 @@
-import copy
-
 from core.choices import JobIntervalChoices
 from django import forms
 from django.contrib.contenttypes.models import ContentType
@@ -29,13 +27,17 @@ from utilities.forms.widgets import DateTimePicker
 from utilities.forms.widgets import HTMXSelect
 from utilities.forms.widgets import NumberWithOptions
 
+from .choices import IPFabricEndpointChoices
+from .choices import IPFabricFilterTypeChoices
 from .choices import IPFabricSnapshotStatusModelChoices
 from .choices import IPFabricSourceStatusChoices
 from .choices import IPFabricSourceTypeChoices
 from .choices import IPFabricSyncStatusChoices
-from .choices import IPFabricTransformMapSourceModelChoices
 from .choices import required_transform_map_contenttypes
 from .choices import transform_field_source_columns
+from .models import IPFabricEndpoint
+from .models import IPFabricFilter
+from .models import IPFabricFilterExpression
 from .models import IPFabricIngestion
 from .models import IPFabricRelationshipField
 from .models import IPFabricSnapshot
@@ -45,7 +47,8 @@ from .models import IPFabricSync
 from .models import IPFabricTransformField
 from .models import IPFabricTransformMap
 from .models import IPFabricTransformMapGroup
-
+from .utilities.filters import get_filter_expression_test_candidates
+from .utilities.transform_map import has_cycle_dfs
 
 exclude_fields = [
     "id",
@@ -56,47 +59,11 @@ exclude_fields = [
     "status",
 ]
 
-dcim_parameters = {
-    "site": forms.BooleanField(required=False, label=_("Sites"), initial=True),
-    "manufacturer": forms.BooleanField(
-        required=False, label=_("Manufacturers"), initial=True
-    ),
-    "devicetype": forms.BooleanField(
-        required=False, label=_("Device Types"), initial=True
-    ),
-    "devicerole": forms.BooleanField(
-        required=False, label=_("Device Roles"), initial=True
-    ),
-    "platform": forms.BooleanField(required=False, label=_("Platforms"), initial=True),
-    "device": forms.BooleanField(required=False, label=_("Devices"), initial=True),
-    "virtualchassis": forms.BooleanField(
-        required=False, label=_("Virtual Chassis"), initial=True
-    ),
-    "interface": forms.BooleanField(
-        required=False, label=_("Interfaces"), initial=True
-    ),
-    "macaddress": forms.BooleanField(
-        required=False, label=_("MAC Addresses"), initial=True
-    ),
-    "inventoryitem": forms.BooleanField(
-        required=False, label=_("Part Numbers"), initial=True
-    ),
-}
-ipam_parameters = {
-    "vlan": forms.BooleanField(required=False, label=_("VLANs"), initial=True),
-    "vrf": forms.BooleanField(required=False, label=_("VRFs"), initial=True),
-    "prefix": forms.BooleanField(required=False, label=_("Prefixes"), initial=True),
-    "ipaddress": forms.BooleanField(
-        required=False, label=_("IP Addresses"), initial=True
-    ),
-}
-sync_parameters = {"dcim": dcim_parameters, "ipam": ipam_parameters}
 
-
-def source_column_choices(model: str) -> list[tuple[str, str]]:
-    columns = transform_field_source_columns.get(model, None)
+def source_column_choices(endpoint: str) -> list[tuple[str, str]]:
+    columns = transform_field_source_columns.get(endpoint, None)
     if columns:
-        choices = [(f, f) for f in transform_field_source_columns.get(model)]
+        choices = [(f, f) for f in transform_field_source_columns.get(endpoint)]
     else:
         # This should never happen, but better be safe than sorry
         choices = []  # pragma: no cover
@@ -113,10 +80,37 @@ def str_to_list(_str: str | list) -> list[str]:
 def list_to_choices(choices: list[str]) -> tuple[tuple[str, str], ...]:
     new_choices = ()
     for choice in choices:
-        new_choices = new_choices + ((choice, choice),)
+        new_choices += ((choice, choice),)
     return new_choices
 
 
+class IPFabricEndpointForm(NetBoxModelForm):
+    endpoint = CSVChoiceField(
+        label=_("Endpoint"),
+        choices=IPFabricEndpointChoices,
+        help_text=_("API endpoints available in IP Fabric to pull data from"),
+    )
+
+    class Meta:
+        model = IPFabricEndpoint
+        fields = ("name", "description", "endpoint")
+        widgets = {
+            "endpoint": HTMXSelect(),
+        }
+
+
+class IPFabricEndpointBulkEditForm(NetBoxModelBulkEditForm):
+    model = IPFabricEndpoint
+    fields = ("endpoint",)
+    nullable_fields = ("endpoint",)
+
+
+class IPFabricEndpointBulkImportForm(NetBoxModelImportForm):
+    class Meta:
+        model = IPFabricEndpoint
+        fields = ("name", "description", "endpoint")
+
+
 class IPFabricRelationshipFieldForm(NetBoxModelForm):
     coalesce = forms.BooleanField(required=False, initial=False)
     target_field = forms.CharField(
@@ -241,7 +235,6 @@ class IPFabricTransformFieldForm(NetBoxModelForm):
                 fields = (
                     self.instance.transform_map.target_model.model_class()._meta.fields
                 )
-                source_fields = self.instance.transform_map.source_model
                 self.fields["target_field"].widget.choices = add_blank_choice(
                     [
                         (f.name, f.verbose_name)
@@ -251,7 +244,9 @@ class IPFabricTransformFieldForm(NetBoxModelForm):
                 )
                 self.fields["target_field"].widget.initial = self.instance.target_field
                 self.fields["source_field"].widget.choices = add_blank_choice(
-                    source_column_choices(source_fields)
+                    source_column_choices(
+                        self.instance.transform_map.source_endpoint.endpoint
+                    )
                 )
             else:
                 if kwargs.get("initial", {}).get("transform_map", None):
@@ -269,7 +264,7 @@ class IPFabricTransformFieldForm(NetBoxModelForm):
                         choices
                     )
                     self.fields["source_field"].widget.choices = add_blank_choice(
-                        source_column_choices(transform_map.source_model)
+                        source_column_choices(transform_map.source_endpoint.endpoint)
                     )
 
 
@@ -294,13 +289,68 @@ class IPFabricTransformMapGroupBulkImportForm(NetBoxModelImportForm):
 
 
 class IPFabricTransformMapForm(NetBoxModelForm):
+    parents = DynamicModelMultipleChoiceField(
+        queryset=IPFabricTransformMap.objects.all(),
+        required=False,
+        label=_("Parents"),
+        help_text=_(
+            "Parent transform maps that must be processed before this one. "
+            "This transform map will only be processed after ALL selected parents complete. "
+            "Example: IP Address requires both Interface and VRF as parents."
+        ),
+    )
+
     class Meta:
         model = IPFabricTransformMap
-        fields = ("name", "group", "source_model", "target_model")
+        fields = ("name", "group", "source_endpoint", "target_model", "parents")
         widgets = {
             "target_model": HTMXSelect(hx_url="/plugins/ipfabric/transform-map/add"),
         }
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        if self.instance and self.instance.pk:
+            self.fields["parents"].widget.add_query_param("id__n", self.instance.pk)
+            self.fields["parents"].queryset = self.fields["parents"].queryset.exclude(
+                pk=self.instance.pk
+            )
+
+    def clean(self):
+        super().clean()
+
+        # Validate circular dependencies with the new parent selection
+        if self.instance and self.instance.pk:
+            new_parents = self.cleaned_data.get("parents", [])
+            if new_parents:
+                self._validate_no_circular_dependency_with_parents(new_parents)
+
+    def _validate_no_circular_dependency_with_parents(self, new_parents):
+        """
+        Check if adding these parents would create a circular dependency.
+        Uses DFS to detect cycles considering the new parent set.
+        """
+
+        def get_parents(node_id: int, parent_override: list | None):
+            """Get parents for a node, with optional override for the instance being modified."""
+            if node_id == self.instance.pk and parent_override is not None:
+                # Use the new parents for the current node
+                return parent_override
+            else:
+                # Use existing parents for other nodes
+                node = IPFabricTransformMap.objects.get(pk=node_id)
+                return node.parents.all()
+
+        if has_cycle_dfs(self.instance.pk, get_parents, parent_override=new_parents):
+            raise forms.ValidationError(
+                {
+                    "parents": _(
+                        "The selected parents create a circular dependency. "
+                        "A transform map cannot be an ancestor of itself."
+                    )
+                }
+            )
+
 
 class IPFabricTransformMapBulkEditForm(NetBoxModelBulkEditForm):
     group = forms.ModelChoiceField(
@@ -308,16 +358,23 @@ class IPFabricTransformMapBulkEditForm(NetBoxModelBulkEditForm):
         required=False,
         label=_("Target Group"),
     )
+    parents = forms.ModelMultipleChoiceField(
+        queryset=IPFabricTransformMap.objects.all(),
+        required=False,
+        label=_("Parents"),
+    )
+
     model = IPFabricTransformMap
-    fields = ("group",)
-    nullable_fields = ("group",)
+    fields = ("group", "parents")
+    nullable_fields = ("group", "parents")
 
 
 class IPFabricTransformMapBulkImportForm(NetBoxModelImportForm):
-    source_model = CSVChoiceField(
-        label=_("Source model"),
-        choices=IPFabricTransformMapSourceModelChoices,
-        help_text=_("Models available in IP Fabric to source data from"),
+    source_endpoint = CSVModelChoiceField(
+        label=_("Endpoints"),
+        queryset=IPFabricEndpoint.objects.all(),
+        required=True,
+        to_field_name="name",
     )
     target_model = CSVContentTypeField(
         queryset=ContentType.objects.filter(IPFabricSupportedSyncModels),
@@ -337,7 +394,7 @@ class IPFabricTransformMapBulkImportForm(NetBoxModelImportForm):
 
     class Meta:
         model = IPFabricTransformMap
-        fields = ("name", "source_model", "target_model", "group")
+        fields = ("name", "source_endpoint", "target_model", "group", "parents")
 
 
 class IPFabricTransformMapCloneForm(forms.Form):
@@ -398,7 +455,7 @@ class IPFabricIngestionFilterForm(SavedFiltersMixin, FilterForm):
     )
     model = IPFabricIngestion
     sync_id = DynamicModelMultipleChoiceField(
-        queryset=IPFabricSync.objects.all(), required=False, label=_("Sync")
+        queryset=IPFabricSync.objects.all(), required=False, label=_("Syncs")
     )
 
 
@@ -573,6 +630,12 @@ class IPFabricSyncForm(NetBoxModelForm):
         ),
     )
 
+    filters = DynamicModelMultipleChoiceField(
+        queryset=IPFabricFilter.objects.all(),
+        label=_("Filters"),
+        required=False,
+    )
+
     update_custom_fields = forms.BooleanField(
         required=False,
         label=_("Custom Fields Updating"),
@@ -607,6 +670,7 @@ class IPFabricSyncForm(NetBoxModelForm):
             "auto_merge",
             "update_custom_fields",
             "sites",
+            "filters",
             "tags",
             "scheduled",
             "interval",
@@ -620,11 +684,8 @@ class IPFabricSyncForm(NetBoxModelForm):
         for name, value in initial.items():
             if (
                 (
-                    name.startswith("ipf_")
-                    or (
-                        name in self.base_fields
-                        and isinstance(self.base_fields[name], forms.BooleanField)
-                    )
+                    name in self.base_fields
+                    and isinstance(self.base_fields[name], forms.BooleanField)
                 )
                 and isinstance(value, list)
                 and len(value) > 1
@@ -688,34 +749,66 @@ class IPFabricSyncForm(NetBoxModelForm):
             else:
                 self.fields["sites"].initial = self.initial["sites"]
 
+            if "filters" not in self.initial:
+                self.initial["filters"] = self.instance.filters.all()
+        else:
+            # For new instances, populate default filters (filters with names starting with "Default ")
+            if "filters" not in self.initial or not self.initial.get("filters"):
+                self.initial["filters"] = IPFabricFilter.objects.filter(
+                    name__istartswith="Default "
+                )
+
         now = local_now().strftime("%Y-%m-%d %H:%M:%S")
         self.fields["scheduled"].help_text += f" (current time: <strong>{now}</strong>)"
 
         # Add backend-specific form fields
         self.backend_fields = {}
+        for transform_map in IPFabricSync.get_transform_maps():
+            field = transform_map.target_model
+            if field.app_label not in self.backend_fields:
+                self.backend_fields[field.app_label] = []
+            self.backend_fields[field.app_label].append(
+                f"{field.app_label}.{field.model}"
+            )
 
-        # Prepare buttons for each target Model
-        for k, v in sync_parameters.items():
-            self.backend_fields[k] = []
-            for name, form_field in v.items():
-                field_name = f"ipf_{name}"
-                self.backend_fields[k].append(field_name)
-                self.fields[field_name] = copy.deepcopy(form_field)
+        # Prepare buttons for each target Model, order according to model hierarchy
+        hierarchy = [
+            f"{tm.target_model.app_label}.{tm.target_model.model}"
+            for tm in IPFabricSync.get_model_hierarchy(
+                group_ids=self.initial.get("groups", [])
+            )
+        ]
+        for k, v in self.backend_fields.items():
+            self.backend_fields[k] = [
+                f for f in hierarchy if f in self.backend_fields[k]
+            ]
+            # Now that it's sorted, we can add those fields to have them in correct order
+            for field in self.backend_fields[k]:
+                self.fields[field] = forms.BooleanField(
+                    required=False,
+                    label=field.split(".", maxsplit=1).pop(),
+                    initial=True,
+                )
                 if self.instance and self.instance.parameters:
-                    value = self.instance.parameters.get(name)
-                    self.fields[field_name].initial = value
+                    value = self.instance.parameters.get(field)
+                    self.fields[field].initial = value
 
         # Set fieldsets dynamically based and backend_fields
         fieldsets = [
             FieldSet("name", "source", "groups", name=_("IP Fabric Source")),
         ]
-        # Only show snapshot and sites if source is selected
+        # Only show snapshot, sites and filters if source is selected
         if source:
             if isinstance(source, str) or isinstance(source, int):
                 source = IPFabricSource.objects.get(pk=source)
             if source.type == "local":
                 fieldsets.append(
-                    FieldSet("snapshot_data", "sites", name=_("Snapshot Information")),
+                    FieldSet(
+                        "snapshot_data",
+                        "sites",
+                        "filters",
+                        name=_("Snapshot Information"),
+                    ),
                 )
             else:
                 fieldsets.append(
@@ -749,6 +842,10 @@ class IPFabricSyncForm(NetBoxModelForm):
                 {"snapshot_data": _("Snapshot does not belong to the selected source.")}
             )
 
+        scheduled_time = self.cleaned_data.get("scheduled")
+        if scheduled_time and scheduled_time < local_now():
+            raise forms.ValidationError(_("Scheduled time must be in the future."))
+
         sites = self.data.get("sites")
         self.fields["sites"].choices = list_to_choices(str_to_list(sites))
         if sites and "snapshot_data" in self.cleaned_data:
@@ -768,10 +865,6 @@ class IPFabricSyncForm(NetBoxModelForm):
                     {"sites": _(f"Sites {invalid_sites} not part of the snapshot.")}
                 )
 
-        scheduled_time = self.cleaned_data.get("scheduled")
-        if scheduled_time and scheduled_time < local_now():
-            raise forms.ValidationError(_("Scheduled time must be in the future."))
-
         # When interval is used without schedule at, schedule for the current time
         if self.cleaned_data.get("interval") and not scheduled_time:
             self.cleaned_data["scheduled"] = local_now()
@@ -796,18 +889,26 @@ class IPFabricSyncForm(NetBoxModelForm):
 
     def save(self, *args, **kwargs):
         parameters = {}
+        backend_fields_values = {
+            item for lst in self.backend_fields.values() for item in lst
+        }
         for name in self.fields:
-            if name.startswith("ipf_"):
-                parameters[name[4:]] = self.cleaned_data[name]
+            if name in backend_fields_values:
+                parameters[name] = self.cleaned_data[name]
             if name == "sites":
                 parameters["sites"] = self.cleaned_data["sites"]
             if name == "groups":
                 parameters["groups"] = [
                     group.pk for group in self.cleaned_data["groups"]
                 ]
-        self.instance.parameters = parameters
+        self.instance.parameters = dict(sorted(parameters.items()))
         self.instance.status = IPFabricSyncStatusChoices.NEW
-        return super().save(*args, **kwargs)
+
+        instance = super().save(*args, **kwargs)
+        # M2M relationships need to be set after the instance is saved
+        # But only if they are set from the side where they are not defined on model
+        instance.filters.set(self.cleaned_data["filters"])
+        return instance
 
 
 class IPFabricSyncBulkEditForm(NetBoxModelBulkEditForm):
@@ -869,6 +970,155 @@ class IPFabricSyncBulkEditForm(NetBoxModelBulkEditForm):
     )
 
 
+class IPFabricFilterForm(NetBoxModelForm):
+    endpoints = DynamicModelMultipleChoiceField(
+        label=_("Endpoints"),
+        queryset=IPFabricEndpoint.objects.all(),
+        required=False,
+        widget=APISelectMultiple(
+            api_url="/api/plugins/ipfabric/endpoint/",
+        ),
+    )
+    filter_type = CSVChoiceField(
+        label=_("Filter Type"),
+        choices=IPFabricFilterTypeChoices,
+        help_text=_(
+            "Top-level merging of filter, where this will be used along other filters."
+        ),
+    )
+    expressions = DynamicModelMultipleChoiceField(
+        queryset=IPFabricFilterExpression.objects.all(),
+        label=_("Filter Expressions"),
+        required=False,
+        widget=APISelectMultiple(
+            api_url="/api/plugins/ipfabric/filter-expression/",
+        ),
+    )
+
+    class Meta:
+        model = IPFabricFilter
+        fields = (
+            "name",
+            "description",
+            "endpoints",
+            "filter_type",
+            "syncs",
+            "expressions",
+        )
+        widgets = {
+            "endpoints": forms.SelectMultiple(),
+            "filter_type": forms.Select(),
+            "syncs": forms.SelectMultiple(),
+        }
+
+    def __init__(self, data=None, instance=None, *args, **kwargs):
+        super().__init__(data=data, instance=instance, *args, **kwargs)
+
+        if self.instance and self.instance.pk is not None:
+            self.fields[
+                "expressions"
+            ].initial = self.instance.expressions.all().values_list("id", flat=True)
+
+    def save(self, *args, **kwargs):
+        instance = super().save(*args, **kwargs)
+        instance.expressions.set(self.cleaned_data["expressions"])
+        return instance
+
+
+class IPFabricFilterBulkEditForm(NetBoxModelBulkEditForm):
+    endpoints = DynamicModelMultipleChoiceField(
+        queryset=IPFabricEndpoint.objects.all(),
+        required=False,
+        label=_("Endpoints"),
+    )
+    filter_type = forms.ChoiceField(
+        choices=add_blank_choice(IPFabricFilterTypeChoices),
+        required=False,
+        label=_("Filter Type"),
+    )
+    syncs = DynamicModelMultipleChoiceField(
+        queryset=IPFabricSync.objects.all(),
+        required=False,
+        label=_("Syncs"),
+    )
+
+    model = IPFabricFilter
+    fields = ("endpoints", "filter_type", "syncs")
+    nullable_fields = ("syncs", "endpoints")
+
+
+class IPFabricFilterBulkImportForm(NetBoxModelImportForm):
+    class Meta:
+        model = IPFabricFilter
+        fields = ("name", "description", "endpoints", "filter_type", "syncs")
+
+
+class IPFabricFilterExpressionForm(NetBoxModelForm):
+    filters = forms.ModelMultipleChoiceField(
+        queryset=IPFabricFilter.objects.all(),
+        required=False,
+        widget=forms.SelectMultiple(),
+    )
+
+    # Test expression fields - for testing the filter against IP Fabric API
+    test_source = DynamicModelChoiceField(
+        queryset=IPFabricSource.objects.filter(type=IPFabricSourceTypeChoices.LOCAL),
+        required=False,
+        label=_("Test Source"),
+        help_text=_(
+            "IP Fabric source to test against. Auto-detected from associated filters if available."
+        ),
+    )
+    test_endpoint = DynamicModelChoiceField(
+        queryset=IPFabricEndpoint.objects.all(),
+        required=False,
+        label=_("Test Endpoint"),
+        help_text=_(
+            "Endpoint to query. Auto-detected from associated filters if available."
+        ),
+    )
+
+    fieldsets = (
+        FieldSet("name", "description", name=_("Filter Expression")),
+        FieldSet("filters", "expression", name=_("Configuration")),
+        FieldSet("test_source", "test_endpoint", name=_("Test Expression")),
+    )
+
+    class Meta:
+        model = IPFabricFilterExpression
+        fields = ("name", "description", "filters", "expression")
+        widgets = {
+            "filters": forms.SelectMultiple(),
+            "expression": forms.Textarea(attrs={"class": "font-monospace"}),
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # Auto-detect test parameters from associated filters if editing existing expression
+        if self.instance and self.instance.pk:
+            # Get unique sources and endpoints from associated filters
+            sources, endpoints = get_filter_expression_test_candidates(self.instance)
+
+            # Set smart defaults if only one option exists
+            if sources and len(sources) == 1:
+                self.fields["test_source"].initial = list(sources)[0]
+            if endpoints and len(endpoints) == 1:
+                self.fields["test_endpoint"].initial = list(endpoints)[0]
+
+
+class IPFabricFilterExpressionBulkEditForm(NetBoxModelBulkEditForm):
+    model = IPFabricFilterExpression
+    fields = ("description", "filters")
+    nullable_fields = ("description", "filters")
+
+
+class IPFabricFilterExpressionBulkImportForm(NetBoxModelImportForm):
+    class Meta:
+        model = IPFabricFilterExpression
+        fields = ("name", "description", "expression")
+
+
 tableChoices = [
     ("eol_details", "Inventory - EOL_DETAILS"),
     ("fans", "Inventory - FANS"),

ipfabric_netbox/graphql/__init__.py

@@ -1,4 +1,7 @@
 from .schema import IPFabricDataQuery
+from .schema import IPFabricEndpointQuery
+from .schema import IPFabricFilterExpressionQuery
+from .schema import IPFabricFilterQuery
 from .schema import IPFabricIngestionIssueQuery
 from .schema import IPFabricIngestionQuery
 from .schema import IPFabricRelationshipFieldQuery
@@ -20,4 +23,7 @@ schema = [
     IPFabricIngestionQuery,
     IPFabricIngestionIssueQuery,
     IPFabricDataQuery,
+    IPFabricEndpointQuery,
+    IPFabricFilterExpressionQuery,
+    IPFabricFilterQuery,
 ]

ipfabric_netbox/graphql/enums.py

@@ -2,22 +2,22 @@ import strawberry
 from core.choices import JobStatusChoices
 from netbox_branching.choices import BranchStatusChoices
 
+from ipfabric_netbox.choices import IPFabricFilterTypeChoices
 from ipfabric_netbox.choices import IPFabricRawDataTypeChoices
 from ipfabric_netbox.choices import IPFabricSnapshotStatusModelChoices
 from ipfabric_netbox.choices import IPFabricSourceStatusChoices
 from ipfabric_netbox.choices import IPFabricSourceTypeChoices
 from ipfabric_netbox.choices import IPFabricSyncStatusChoices
-from ipfabric_netbox.choices import IPFabricTransformMapSourceModelChoices
 
 __all__ = (
     "IPFabricSourceStatusEnum",
     "IPFabricSyncStatusEnum",
-    "IPFabricTransformMapSourceModelEnum",
     "IPFabricSourceTypeEnum",
     "IPFabricSnapshotStatusModelEnum",
     "IPFabricRawDataTypeEnum",
     "BranchStatusEnum",
     "JobStatusEnum",
+    "IPFabricFilterTypeEnum",
 )
 
 IPFabricSourceStatusEnum = strawberry.enum(
@@ -26,9 +26,6 @@ IPFabricSourceStatusEnum = strawberry.enum(
 IPFabricSyncStatusEnum = strawberry.enum(
     IPFabricSyncStatusChoices.as_enum(prefix="type")
 )
-IPFabricTransformMapSourceModelEnum = strawberry.enum(
-    IPFabricTransformMapSourceModelChoices.as_enum(prefix="type")
-)
 IPFabricSourceTypeEnum = strawberry.enum(
     IPFabricSourceTypeChoices.as_enum(prefix="type")
 )
@@ -40,3 +37,6 @@ IPFabricRawDataTypeEnum = strawberry.enum(
 )
 BranchStatusEnum = strawberry.enum(BranchStatusChoices.as_enum(prefix="type"))
 JobStatusEnum = strawberry.enum(JobStatusChoices.as_enum(prefix="type"))
+IPFabricFilterTypeEnum = strawberry.enum(
+    IPFabricFilterTypeChoices.as_enum(prefix="type")
+)