ipfabric_netbox 4.3.2b8__py3-none-any.whl → 4.3.2b10__py3-none-any.whl

ipfabric_netbox/graphql/filters.py

@@ -21,12 +21,12 @@ from users.graphql.filters import UserFilter
 
 from ipfabric_netbox import models
 from ipfabric_netbox.graphql.enums import BranchStatusEnum
+from ipfabric_netbox.graphql.enums import IPFabricFilterTypeEnum
 from ipfabric_netbox.graphql.enums import IPFabricRawDataTypeEnum
 from ipfabric_netbox.graphql.enums import IPFabricSnapshotStatusModelEnum
 from ipfabric_netbox.graphql.enums import IPFabricSourceStatusEnum
 from ipfabric_netbox.graphql.enums import IPFabricSourceTypeEnum
 from ipfabric_netbox.graphql.enums import IPFabricSyncStatusEnum
-from ipfabric_netbox.graphql.enums import IPFabricTransformMapSourceModelEnum
 from ipfabric_netbox.graphql.enums import JobStatusEnum
 
 __all__ = (
@@ -42,9 +42,19 @@ __all__ = (
     "IPFabricDataFilter",
     "BranchFilter",
     "JobFilter",
+    "IPFabricFilterFilter",
+    "IPFabricFilterExpressionFilter",
 )
 
 
+@strawberry_django.filter(models.IPFabricEndpoint, lookups=True)
+class IPFabricEndpointFilter(NetBoxModelFilterMixin):
+    id: ID | None = strawberry_django.filter_field()
+    name: FilterLookup[str] | None = strawberry_django.filter_field()
+    description: FilterLookup[str] | None = strawberry_django.filter_field()
+    endpoint: FilterLookup[str] | None = strawberry_django.filter_field()
+
+
 @strawberry_django.filter(models.IPFabricTransformMapGroup, lookups=True)
 class IPFabricTransformMapGroupFilter(NetBoxModelFilterMixin):
     id: ID | None = strawberry_django.filter_field()
@@ -56,10 +66,10 @@ class IPFabricTransformMapGroupFilter(NetBoxModelFilterMixin):
 class IPFabricTransformMapFilter(NetBoxModelFilterMixin):
     id: ID | None = strawberry_django.filter_field()
     name: FilterLookup[str] | None = strawberry_django.filter_field()
-    source_model: (
+    source_endpoint: (
         Annotated[
-            "IPFabricTransformMapSourceModelEnum",
-            strawberry.lazy("ipfabric_netbox.graphql.enums"),
+            "IPFabricEndpointFilter",
+            strawberry.lazy("ipfabric_netbox.graphql.filters"),
         ]
         | None
     ) = strawberry_django.filter_field()
@@ -259,6 +269,48 @@ class IPFabricDataFilter(BaseFilterMixin):
     ) = strawberry_django.filter_field()
 
 
+@strawberry_django.filter(models.IPFabricFilter, lookups=True)
+class IPFabricFilterFilter(NetBoxModelFilterMixin):
+    id: ID | None = strawberry_django.filter_field()
+    name: FilterLookup[str] | None = strawberry_django.filter_field()
+    description: FilterLookup[str] | None = strawberry_django.filter_field()
+    endpoints: (
+        Annotated[
+            "IPFabricEndpointFilter",
+            strawberry.lazy("ipfabric_netbox.graphql.filters"),
+        ]
+        | None
+    ) = strawberry_django.filter_field()
+    filter_type: (
+        Annotated[
+            "IPFabricFilterTypeEnum", strawberry.lazy("ipfabric_netbox.graphql.enums")
+        ]
+        | None
+    ) = strawberry_django.filter_field()
+    syncs: (
+        Annotated[
+            "IPFabricSyncFilter", strawberry.lazy("ipfabric_netbox.graphql.filters")
+        ]
+        | None
+    ) = strawberry_django.filter_field()
+
+
+@strawberry_django.filter(models.IPFabricFilterExpression, lookups=True)
+class IPFabricFilterExpressionFilter(NetBoxModelFilterMixin):
+    id: ID | None = strawberry_django.filter_field()
+    name: FilterLookup[str] | None = strawberry_django.filter_field()
+    description: FilterLookup[str] | None = strawberry_django.filter_field()
+    expression: (
+        Annotated["JSONFilter", strawberry.lazy("netbox.graphql.filter_lookups")] | None
+    ) = strawberry_django.filter_field()
+    filters: (
+        Annotated[
+            "IPFabricFilterFilter", strawberry.lazy("ipfabric_netbox.graphql.filters")
+        ]
+        | None
+    ) = strawberry_django.filter_field()
+
+
 # These filters are not defined in the libs, so need to define them here
 @strawberry_django.filter(Branch, lookups=True)
 class BranchFilter(PrimaryModelFilterMixin):

ipfabric_netbox/graphql/schema.py

@@ -2,6 +2,9 @@ import strawberry
 import strawberry_django
 
 from .types import IPFabricDataType
+from .types import IPFabricEndpointType
+from .types import IPFabricFilterExpressionType
+from .types import IPFabricFilterType
 from .types import IPFabricIngestionIssueType
 from .types import IPFabricIngestionType
 from .types import IPFabricRelationshipFieldType
@@ -24,6 +27,9 @@ __all__ = (
     "IPFabricIngestionQuery",
     "IPFabricIngestionIssueQuery",
     "IPFabricDataQuery",
+    "IPFabricEndpointQuery",
+    "IPFabricFilterQuery",
+    "IPFabricFilterExpressionQuery",
 )
 
 
@@ -99,3 +105,25 @@ class IPFabricIngestionIssueQuery:
 class IPFabricDataQuery:
     ipfabric_data: IPFabricDataType = strawberry_django.field()
     ipfabric_data_list: list[IPFabricDataType] = strawberry_django.field()
+
+
+@strawberry.type(name="Query")
+class IPFabricEndpointQuery:
+    ipfabric_endpoint: IPFabricEndpointType = strawberry_django.field()
+    ipfabric_endpoint_list: list[IPFabricEndpointType] = strawberry_django.field()
+
+
+@strawberry.type(name="Query")
+class IPFabricFilterQuery:
+    ip_fabric_filter: IPFabricFilterType = strawberry_django.field()
+    ip_fabric_filter_list: list[IPFabricFilterType] = strawberry_django.field()
+
+
+@strawberry.type(name="Query")
+class IPFabricFilterExpressionQuery:
+    ip_fabric_filter_expression: IPFabricFilterExpressionType = (
+        strawberry_django.field()
+    )
+    ip_fabric_filter_expression_list: list[
+        IPFabricFilterExpressionType
+    ] = strawberry_django.field()

ipfabric_netbox/graphql/types.py

@@ -15,6 +15,8 @@ from users.graphql.types import UserType
 
 from .filters import BranchFilter
 from .filters import IPFabricDataFilter
+from .filters import IPFabricFilterExpressionFilter
+from .filters import IPFabricFilterFilter
 from .filters import IPFabricIngestionFilter
 from .filters import IPFabricIngestionIssueFilter
 from .filters import IPFabricRelationshipFieldFilter
@@ -29,6 +31,7 @@ from ipfabric_netbox import models
 
 
 __all__ = (
+    "IPFabricEndpointType",
     "IPFabricTransformMapGroupType",
     "IPFabricTransformMapType",
     "IPFabricTransformFieldType",
@@ -39,9 +42,21 @@ __all__ = (
     "IPFabricIngestionType",
     "IPFabricIngestionIssueType",
     "IPFabricDataType",
+    "IPFabricFilterType",
+    "IPFabricFilterExpressionType",
 )
 
 
+@strawberry_django.type(
+    models.IPFabricEndpoint,
+    fields="__all__",
+)
+class IPFabricEndpointType(NetBoxObjectType):
+    name: str
+    description: str | None
+    endpoint: str
+
+
 @strawberry_django.type(
     models.IPFabricTransformMapGroup,
     fields="__all__",
@@ -57,7 +72,13 @@ class IPFabricTransformMapGroupType(NetBoxObjectType):
 )
 class IPFabricTransformMapType(NetBoxObjectType):
     name: str
-    source_model: str
+    source_endpoint: (
+        Annotated[
+            "IPFabricEndpointType",
+            strawberry.lazy("ipfabric_netbox.graphql.types"),
+        ]
+        | None
+    )
     target_model: (
         Annotated[
             "ContentTypeType",
@@ -72,6 +93,12 @@ class IPFabricTransformMapType(NetBoxObjectType):
         ]
         | None
     )
+    parents: list[
+        Annotated[
+            "IPFabricTransformMapType",
+            strawberry.lazy("ipfabric_netbox.graphql.types"),
+        ]
+    ]
 
 
 @strawberry_django.type(
@@ -214,3 +241,36 @@ class IPFabricDataType(BaseObjectType):
     snapshot_data: Annotated[
         "IPFabricSnapshotType", strawberry.lazy("ipfabric_netbox.graphql.types")
     ]
+
+
+@strawberry_django.type(
+    models.IPFabricFilter, fields="__all__", filters=IPFabricFilterFilter
+)
+class IPFabricFilterType(NetBoxObjectType):
+    name: str
+    description: str | None
+    endpoints: list[
+        Annotated[
+            "IPFabricEndpointType", strawberry.lazy("ipfabric_netbox.graphql.types")
+        ]
+    ]
+    filter_type: str
+    syncs: list[
+        Annotated["IPFabricSyncType", strawberry.lazy("ipfabric_netbox.graphql.types")]
+    ]
+
+
+@strawberry_django.type(
+    models.IPFabricFilterExpression,
+    fields="__all__",
+    filters=IPFabricFilterExpressionFilter,
+)
+class IPFabricFilterExpressionType(NetBoxObjectType):
+    name: str
+    description: str | None
+    expression: JSON
+    filters: list[
+        Annotated[
+            "IPFabricFilterType", strawberry.lazy("ipfabric_netbox.graphql.types")
+        ]
+    ]

ipfabric_netbox/jobs.py

@@ -3,6 +3,11 @@ from datetime import timedelta
 
 from core.choices import JobStatusChoices
 from core.exceptions import SyncError
+from dcim.models import Site
+from dcim.models import VirtualChassis
+from dcim.signals import assign_virtualchassis_master
+from dcim.signals import sync_cached_scope_fields
+from django.db.models import signals
 from netbox.context_managers import event_tracking
 from rq.timeouts import JobTimeoutException
 from utilities.datetime import local_now
@@ -116,7 +121,19 @@ def merge_ipfabric_ingestion(job, remove_branch=False, *args, **kwargs):
 
         job.start()
         with event_tracking(request):
-            ingestion.sync_merge()
+            try:
+                # This signal is disabled on sync, we need to disable it here too
+                signals.post_save.disconnect(
+                    assign_virtualchassis_master, sender=VirtualChassis
+                )
+                signals.post_save.disconnect(sync_cached_scope_fields, sender=Site)
+                ingestion.sync_merge()
+            finally:
+                # Re-enable the disabled signals
+                signals.post_save.connect(
+                    assign_virtualchassis_master, sender=VirtualChassis
+                )
+                signals.post_save.connect(sync_cached_scope_fields, sender=Site)
         if remove_branch:
             branching_branch = ingestion.branch
             ingestion.branch = None

ipfabric_netbox/migrations/0022_prepare_for_filters.py

@@ -0,0 +1,182 @@
+# Generated by Django 5.2.5 on 2025-12-02 12:06
+import django.db.models.deletion
+import netbox.models.deletion
+import taggit.managers
+import utilities.json
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0132_configcontextprofile"),
+        ("ipfabric_netbox", "0021_update_transform_maps"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="IPFabricEndpoint",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False
+                    ),
+                ),
+                ("created", models.DateTimeField(auto_now_add=True, null=True)),
+                ("last_updated", models.DateTimeField(auto_now=True, null=True)),
+                (
+                    "custom_field_data",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        encoder=utilities.json.CustomFieldJSONEncoder,
+                    ),
+                ),
+                ("name", models.CharField(max_length=100, unique=True)),
+                ("description", models.TextField(blank=True, null=True)),
+                ("endpoint", models.CharField(max_length=200, unique=True)),
+                (
+                    "tags",
+                    taggit.managers.TaggableManager(
+                        through="extras.TaggedItem", to="extras.Tag"
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "IP Fabric Endpoint",
+                "verbose_name_plural": "IP Fabric Endpoints",
+                "ordering": ("pk",),
+            },
+            bases=(netbox.models.deletion.DeleteMixin, models.Model),
+        ),
+        migrations.AddField(
+            model_name="ipfabrictransformmap",
+            name="source_endpoint",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                related_name="transform_maps",
+                to="ipfabric_netbox.ipfabricendpoint",
+            ),
+        ),
+        migrations.AddField(
+            model_name="ipfabrictransformmap",
+            name="parents",
+            field=models.ManyToManyField(
+                blank=True,
+                help_text="Parent transform maps, for hierarchical organization during sync.",
+                related_name="children",
+                symmetrical=False,
+                to="ipfabric_netbox.ipfabrictransformmap",
+            ),
+        ),
+        migrations.CreateModel(
+            name="IPFabricFilter",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False
+                    ),
+                ),
+                ("created", models.DateTimeField(auto_now_add=True, null=True)),
+                ("last_updated", models.DateTimeField(auto_now=True, null=True)),
+                (
+                    "custom_field_data",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        encoder=utilities.json.CustomFieldJSONEncoder,
+                    ),
+                ),
+                ("name", models.CharField(max_length=100, unique=True)),
+                ("description", models.TextField(blank=True, null=True)),
+                (
+                    "endpoints",
+                    models.ManyToManyField(
+                        blank=True,
+                        default=None,
+                        related_name="filters",
+                        to="ipfabric_netbox.ipfabricendpoint",
+                    ),
+                ),
+                ("filter_type", models.CharField(max_length=10)),
+                (
+                    "syncs",
+                    models.ManyToManyField(
+                        blank=True,
+                        default=None,
+                        related_name="filters",
+                        to="ipfabric_netbox.ipfabricsync",
+                    ),
+                ),
+                (
+                    "tags",
+                    taggit.managers.TaggableManager(
+                        through="extras.TaggedItem", to="extras.Tag"
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "IP Fabric Filter",
+                "verbose_name_plural": "IP Fabric Filters",
+                "ordering": ("pk",),
+            },
+            bases=(netbox.models.deletion.DeleteMixin, models.Model),
+        ),
+        migrations.CreateModel(
+            name="IPFabricFilterExpression",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False
+                    ),
+                ),
+                ("created", models.DateTimeField(auto_now_add=True, null=True)),
+                ("last_updated", models.DateTimeField(auto_now=True, null=True)),
+                (
+                    "custom_field_data",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        encoder=utilities.json.CustomFieldJSONEncoder,
+                    ),
+                ),
+                ("name", models.CharField(max_length=100, unique=True)),
+                ("description", models.TextField(blank=True, null=True)),
+                ("expression", models.JSONField(default=list)),
+                (
+                    "filters",
+                    models.ManyToManyField(
+                        related_name="expressions", to="ipfabric_netbox.ipfabricfilter"
+                    ),
+                ),
+                (
+                    "tags",
+                    taggit.managers.TaggableManager(
+                        through="extras.TaggedItem", to="extras.Tag"
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "IP Fabric Filter Expression",
+                "verbose_name_plural": "IP Fabric Filter Expressions",
+                "ordering": ("pk",),
+            },
+            bases=(netbox.models.deletion.DeleteMixin, models.Model),
+        ),
+        # Make source_model nullable to allow reverse data migration
+        migrations.AlterField(
+            model_name="ipfabrictransformmap",
+            name="source_model",
+            field=models.CharField(max_length=50, null=True),
+        ),
+        # Extend size of name to allow for correction tags
+        migrations.AlterField(
+            model_name="ipfabrictransformmap",
+            name="name",
+            field=models.CharField(max_length=200),
+        ),
+    ]