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

ipfabric_netbox/urls.py

@@ -46,6 +46,41 @@ urlpatterns = (
         "ingestion/<int:pk>/",
         include(get_model_urls("ipfabric_netbox", "ipfabricingestion")),
     ),
+    # Endpoint
+    path(
+        "filter/",
+        include(get_model_urls("ipfabric_netbox", "ipfabricfilter", detail=False)),
+    ),
+    path(
+        "filter/<int:pk>/",
+        include(get_model_urls("ipfabric_netbox", "ipfabricfilter")),
+    ),
+    # Endpoint
+    path(
+        "filter-expression/",
+        include(
+            get_model_urls("ipfabric_netbox", "ipfabricfilterexpression", detail=False)
+        ),
+    ),
+    # Test endpoint for unsaved expressions (no pk required)
+    path(
+        "filter-expression/test/",
+        views.IPFabricFilterExpressionTestView.as_view(),
+        name="ipfabricfilterexpression_test_no_pk",
+    ),
+    path(
+        "filter-expression/<int:pk>/",
+        include(get_model_urls("ipfabric_netbox", "ipfabricfilterexpression")),
+    ),
+    # Endpoint
+    path(
+        "endpoint/",
+        include(get_model_urls("ipfabric_netbox", "ipfabricendpoint", detail=False)),
+    ),
+    path(
+        "endpoint/<int:pk>/",
+        include(get_model_urls("ipfabric_netbox", "ipfabricendpoint")),
+    ),
     # Transform Map Group
     path(
         "transform-map-group/",

ipfabric_netbox/utilities/endpoint.py

@@ -0,0 +1,83 @@
+import importlib.resources
+import json
+
+from netbox.settings import django_apps
+
+
+# region Endpoint Creation
+
+# These functions are used in the migration file to prepare the endpoints
+# Because of this we have to use historical models
+# see https://docs.djangoproject.com/en/5.1/topics/migrations/#historical-models
+
+
+def build_endpoints(data, apps: django_apps = None, db_alias: str = "default") -> None:
+    apps = apps or django_apps
+    IPFabricEndpoint = apps.get_model("ipfabric_netbox", "IPFabricEndpoint")
+    for endpoint_data in data:
+        IPFabricEndpoint.objects.using(db_alias).create(**endpoint_data)
+
+
+def get_endpoint_data() -> dict:
+    for data_file in importlib.resources.files("ipfabric_netbox.data").iterdir():
+        if data_file.name != "endpoint.json":
+            continue
+        with open(data_file, "rb") as data_file:
+            return json.load(data_file)
+    raise FileNotFoundError("'endpoint.json' not found in installed package")
+
+
+# endregion Endpoint Creation
+
+# region Endpoint Updating
+
+
+class EndpointRecord:
+    """Record for endpoint creation/deletion in migrations."""
+
+    def __init__(self, name: str, description: str, endpoint: str):
+        self.name = name
+        self.description = description
+        self.endpoint = endpoint
+
+
+def do_endpoint_change(
+    apps, schema_editor, endpoints: tuple[EndpointRecord, ...], forward: bool = True
+):
+    """
+    Apply endpoint changes, `forward` determines direction.
+
+    Forward: Creates endpoints if they don't exist (idempotent using get_or_create).
+    Reverse: Deletes endpoints by endpoint path.
+
+    Args:
+        apps: Django apps registry (historical models)
+        schema_editor: Database schema editor
+        endpoints: Tuple of EndpointRecord objects to process
+        forward: True for forward migration (create), False for reverse (delete)
+    """
+    IPFabricEndpoint = apps.get_model("ipfabric_netbox", "IPFabricEndpoint")
+    db_alias = schema_editor.connection.alias
+
+    try:
+        for endpoint_record in endpoints:
+            if forward:
+                # Forward: Create endpoint if it doesn't exist (idempotent)
+                IPFabricEndpoint.objects.using(db_alias).get_or_create(
+                    endpoint=endpoint_record.endpoint,
+                    defaults={
+                        "name": endpoint_record.name,
+                        "description": endpoint_record.description,
+                    },
+                )
+            else:
+                # Reverse: Delete endpoint by endpoint path
+                IPFabricEndpoint.objects.using(db_alias).filter(
+                    endpoint=endpoint_record.endpoint
+                ).delete()
+
+    except Exception as e:
+        print(f"Error applying endpoint changes: {e}")
+
+
+# endregion

ipfabric_netbox/utilities/filters.py

@@ -0,0 +1,88 @@
+import importlib.resources
+import json
+
+from netbox.settings import django_apps
+
+from ..choices import IPFabricSourceTypeChoices
+
+# region Filter Expression
+
+
+def get_filter_expression_test_candidates(expression_instance):
+    """
+    Get potential LOCAL sources and endpoints from filters associated with a filter expression.
+
+    Args:
+        expression_instance: An IPFabricFilterExpression instance
+
+    Returns:
+        tuple: (sources_set, endpoints_set) - Sets of IPFabricSource and IPFabricEndpoint objects
+    """
+    if not expression_instance or not expression_instance.pk:
+        return set(), set()
+
+    sources = set()
+    endpoints = set()
+
+    # Query all filters that use this expression
+    for filter_obj in expression_instance.filters.all():
+        # Get LOCAL sources from syncs
+        for sync in filter_obj.syncs.all():
+            if (
+                sync.snapshot_data
+                and sync.snapshot_data.source
+                and sync.snapshot_data.source.type == IPFabricSourceTypeChoices.LOCAL
+            ):
+                sources.add(sync.snapshot_data.source)
+
+        # Get endpoints
+        for endpoint in filter_obj.endpoints.all():
+            endpoints.add(endpoint)
+
+    return sources, endpoints
+
+
+# endregion Filter Expression
+
+
+# region Filter Creation
+
+# These functions are used in the migration file to prepare the filters
+# Because of this we have to use historical models
+# see https://docs.djangoproject.com/en/5.1/topics/migrations/#historical-models
+
+
+def build_filters(data, apps: django_apps = None, db_alias: str = "default") -> None:
+    apps = apps or django_apps
+    IPFabricEndpoint = apps.get_model("ipfabric_netbox", "IPFabricEndpoint")
+    IPFabricFilter = apps.get_model("ipfabric_netbox", "IPFabricFilter")
+    IPFabricFilterExpression = apps.get_model(
+        "ipfabric_netbox", "IPFabricFilterExpression"
+    )
+    for expressions_data in data["expressions"]:
+        IPFabricFilterExpression.objects.using(db_alias).create(**expressions_data)
+    for filter_data in data["filters"]:
+        filter_data["filter_type"] = "and"
+        endpoints = [
+            IPFabricEndpoint.objects.filter(endpoint=endpoint).first()
+            for endpoint in filter_data.pop("endpoints", [])
+        ]
+        expressions = [
+            IPFabricFilterExpression.objects.filter(name=expr).first()
+            for expr in filter_data.pop("expressions", [])
+        ]
+        _filter = IPFabricFilter.objects.using(db_alias).create(**filter_data)
+        _filter.endpoints.set(endpoints)
+        _filter.expressions.set(expressions)
+
+
+def get_filter_data() -> dict:
+    for data_file in importlib.resources.files("ipfabric_netbox.data").iterdir():
+        if data_file.name != "filters.json":
+            continue
+        with open(data_file, "rb") as data_file:
+            return json.load(data_file)
+    raise FileNotFoundError("'filters.json' not found in installed package")
+
+
+# endregion Filter Creation