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

ipfabric_netbox/views.py

@@ -1,3 +1,5 @@
+import json
+
 from core.choices import ObjectChangeActionChoices
 from dcim.models import Device
 from dcim.models import Site
@@ -37,7 +39,11 @@ from utilities.views import GetRelatedModelsMixin
 from utilities.views import register_model_view
 from utilities.views import ViewTab
 
+from .choices import IPFabricSourceTypeChoices
 from .filtersets import IPFabricDataFilterSet
+from .filtersets import IPFabricEndpointFilterSet
+from .filtersets import IPFabricFilterExpressionFilterSet
+from .filtersets import IPFabricFilterFilterSet
 from .filtersets import IPFabricIngestionChangeFilterSet
 from .filtersets import IPFabricIngestionFilterSet
 from .filtersets import IPFabricIngestionIssueFilterSet
@@ -46,6 +52,12 @@ from .filtersets import IPFabricSourceFilterSet
 from .filtersets import IPFabricSyncFilterSet
 from .filtersets import IPFabricTransformMapFilterSet
 from .filtersets import IPFabricTransformMapGroupFilterSet
+from .forms import IPFabricFilterBulkEditForm
+from .forms import IPFabricFilterBulkImportForm
+from .forms import IPFabricFilterExpressionBulkEditForm
+from .forms import IPFabricFilterExpressionBulkImportForm
+from .forms import IPFabricFilterExpressionForm
+from .forms import IPFabricFilterForm
 from .forms import IPFabricIngestionFilterForm
 from .forms import IPFabricIngestionMergeForm
 from .forms import IPFabricRelationshipFieldForm
@@ -65,6 +77,9 @@ from .forms import IPFabricTransformMapGroupBulkEditForm
 from .forms import IPFabricTransformMapGroupBulkImportForm
 from .forms import IPFabricTransformMapGroupForm
 from .models import IPFabricData
+from .models import IPFabricEndpoint
+from .models import IPFabricFilter
+from .models import IPFabricFilterExpression
 from .models import IPFabricIngestion
 from .models import IPFabricIngestionIssue
 from .models import IPFabricRelationshipField
@@ -76,6 +91,9 @@ from .models import IPFabricTransformMap
 from .models import IPFabricTransformMapGroup
 from .tables import DeviceIPFTable
 from .tables import IPFabricDataTable
+from .tables import IPFabricEndpointTable
+from .tables import IPFabricFilterExpressionTable
+from .tables import IPFabricFilterTable
 from .tables import IPFabricIngestionChangesTable
 from .tables import IPFabricIngestionIssuesTable
 from .tables import IPFabricIngestionTable
@@ -86,11 +104,221 @@ from .tables import IPFabricSyncTable
 from .tables import IPFabricTransformFieldTable
 from .tables import IPFabricTransformMapGroupTable
 from .tables import IPFabricTransformMapTable
+from .utilities.filters import get_filter_expression_test_candidates
 from .utilities.ipfutils import IPFabric
 from .utilities.transform_map import build_transform_maps
 from .utilities.transform_map import get_transform_map
 
 
+# region - Base Classes for Combined Expressions Views
+
+
+class CombinedExpressionsBaseView(LoginRequiredMixin, View):
+    """Base view for displaying combined filter expressions in an HTMX modal.
+
+    This base class provides common functionality for views that display
+    combined/merged filter expressions. Subclasses must implement
+    get_context_data() to provide view-specific context.
+
+    The template (inc/combined_expressions.html) supports three context types:
+    - "filter": Display merged expressions for a single IPFabricFilter
+    - "endpoint": Display combined filters for an endpoint within a sync
+    - "endpoint_all": Display combined filters for an endpoint across all syncs
+    """
+
+    template_name = "ipfabric_netbox/inc/combined_expressions.html"
+
+    def get_context_data(self, request, **kwargs):
+        """Override this method to provide view-specific context.
+
+        Must return a dict with standardized keys:
+        - object: The main object being displayed (IPFabricFilter or IPFabricEndpoint, or None)
+        - combined_expressions: The expressions (list for filters, dict for endpoints)
+        - context_type: One of "filter", "endpoint", or "endpoint_all"
+        - is_empty: Boolean indicating if there are no expressions
+        - sync: Optional IPFabricSync object (for endpoint context type only)
+
+        Args:
+            request: The HTTP request object
+            **kwargs: URL parameters passed to the view
+
+        Returns:
+            dict: Context dictionary for template rendering
+        """
+        raise NotImplementedError(
+            "Subclasses must implement get_context_data()"
+        )  # pragma: no cover
+
+    def add_no_cache_headers(self, response):
+        """Add cache control headers to prevent browser caching.
+
+        Args:
+            response: HttpResponse object
+
+        Returns:
+            HttpResponse: The response with cache headers added
+        """
+        response["Cache-Control"] = "no-cache, no-store, must-revalidate"
+        response["Pragma"] = "no-cache"
+        response["Expires"] = "0"
+        return response
+
+    def get(self, request, **kwargs):
+        """Handle GET requests by rendering the template with context.
+
+        Args:
+            request: The HTTP request object
+            **kwargs: URL parameters
+
+        Returns:
+            HttpResponse: Rendered template with no-cache headers
+        """
+        context = self.get_context_data(request, **kwargs)
+        response = render(request, self.template_name, context)
+        return self.add_no_cache_headers(response)
+
+
+# endregion
+
+
+# region - Endpoint (Read-Only)
+@register_model_view(IPFabricEndpoint, "list", path="", detail=False)
+class IPFabricEndpointListView(generic.ObjectListView):
+    queryset = IPFabricEndpoint.objects.annotate(
+        filters_count=models.Count("filters", distinct=True)
+    )
+    table = IPFabricEndpointTable
+    filterset = IPFabricEndpointFilterSet
+    template_name = "ipfabric_netbox/htmx_list.html"
+
+
+@register_model_view(IPFabricEndpoint)
+class IPFabricEndpointView(GetRelatedModelsMixin, generic.ObjectView):
+    queryset = IPFabricEndpoint.objects.all()
+    actions = ()
+
+    def get_extra_context(self, request, instance):
+        return {
+            "related_models": self.get_related_models(
+                request,
+                instance,
+                extra=(
+                    (
+                        IPFabricFilter.objects.restrict(request.user, "view").filter(
+                            endpoints=instance
+                        ),
+                        "endpoints",
+                    ),
+                ),
+            ),
+        }
+
+
+@register_model_view(
+    IPFabricEndpoint,
+    name="filters",
+    path="filters",
+    kwargs={"model": IPFabricEndpoint},
+)
+class IPFabricEndpointFiltersView(CombinedExpressionsBaseView):
+    """Display combined filters for an endpoint with optional sync selection."""
+
+    template_name = "ipfabric_netbox/inc/endpoint_filters_with_selector.html"
+
+    def get_context_data(self, request, **kwargs):
+        """Provide context for endpoint filters with sync selection.
+
+        Args:
+            request: HTTP request (must be HTMX)
+            **kwargs: Must contain 'pk' (endpoint primary key)
+
+        Returns:
+            dict: Standardized context with endpoint object, available syncs,
+                  and combined filters (optionally filtered by sync)
+        """
+        endpoint_pk = kwargs.get("pk")
+        sync_pk = request.GET.get("sync_pk")
+        from_sync = request.GET.get("from_sync") == "true"
+
+        # Return empty context if not HTMX or missing required parameters
+        if not request.htmx or not endpoint_pk:
+            return {
+                "object": None,
+                "combined_expressions": {},
+                "is_empty": True,
+                "context_type": "endpoint_all",
+            }
+
+        # Fetch endpoint
+        endpoint_obj = IPFabricEndpoint.objects.prefetch_related("filters").get(
+            pk=endpoint_pk
+        )
+
+        # Determine if we're filtering by sync
+        sync_obj = None
+        if sync_pk:
+            try:
+                sync_obj = IPFabricSync.objects.get(pk=sync_pk)
+            except IPFabricSync.DoesNotExist:
+                pass
+
+        # Combine filters (with optional sync filter)
+        combined = endpoint_obj.combine_filters(sync=sync_obj)
+
+        # Determine context type based on sync selection
+        context_type = "endpoint" if sync_obj else "endpoint_all"
+
+        context = {
+            "object": endpoint_obj,
+            "combined_expressions": combined,
+            "is_empty": len(combined) == 0,
+            "context_type": context_type,
+            "from_sync": from_sync,
+        }
+
+        # Add sync to context if one is selected
+        if sync_obj:
+            context["sync"] = sync_obj
+
+        # Only add sync selector context if not coming from a sync view
+        if not from_sync:
+            context["available_syncs"] = IPFabricSync.objects.all().order_by("name")
+            context["selected_sync_pk"] = int(sync_pk) if sync_pk else None
+
+        return context
+
+    def get(self, request, **kwargs):
+        """Handle GET requests, using appropriate template based on context.
+
+        Args:
+            request: The HTTP request object
+            **kwargs: URL parameters
+
+        Returns:
+            HttpResponse: Rendered template with no-cache headers
+        """
+        context = self.get_context_data(request, **kwargs)
+
+        # Determine which template to use
+        from_sync = request.GET.get("from_sync") == "true"
+        sync_pk_param = request.GET.get("sync_pk")
+
+        if from_sync:
+            # Coming from sync view - use simple template without selector
+            template_name = "ipfabric_netbox/inc/combined_expressions.html"
+        elif sync_pk_param is not None and not from_sync:
+            # Sync selection change via dropdown - use content-only template
+            template_name = "ipfabric_netbox/inc/combined_expressions_content.html"
+        else:
+            # Initial load from general endpoints - use template with selector
+            template_name = self.template_name
+
+        response = render(request, template_name, context)
+        return self.add_no_cache_headers(response)
+
+
+# endregion
+
 # region - Transform Map Relationship Field
 
 
@@ -116,7 +344,6 @@ class IPFabricRelationshipFieldBulkDeleteView(generic.BulkDeleteView):
     table = IPFabricRelationshipFieldTable
 
 
-# This list is not linked in navigation, but it's needed for tests
 @register_model_view(IPFabricRelationshipField, "list", path="", detail=False)
 class IPFabricRelationshipFieldListView(generic.ObjectListView):
     queryset = IPFabricRelationshipField.objects.all()
@@ -242,9 +469,17 @@ class IPFabricTransformMapBulkDeleteView(generic.BulkDeleteView):
 
 
 @register_model_view(IPFabricTransformMap)
-class IPFabricTransformMapView(generic.ObjectView):
+class IPFabricTransformMapView(GetRelatedModelsMixin, generic.ObjectView):
     queryset = IPFabricTransformMap.objects.all()
 
+    def get_extra_context(self, request, instance):
+        return {
+            "related_models": self.get_related_models(
+                request,
+                instance,
+            ),
+        }
+
 
 @register_model_view(IPFabricTransformMap, "restore", detail=False)
 class IPFabricTransformMapRestoreView(generic.ObjectListView):
@@ -331,7 +566,7 @@ class IPFabricTransformMapCloneView(BaseObjectView):
                     # Clone the transform map - create a proper copy using Django model copying
                     new_map = IPFabricTransformMap(
                         name=form.cleaned_data["name"],
-                        source_model=obj.source_model,
+                        source_endpoint=obj.source_endpoint,
                         target_model=obj.target_model,
                         group=form.cleaned_data["group"],
                     )
@@ -446,7 +681,6 @@ class IPFabricTransformRelationshipView(generic.ObjectChildrenView):
 # region - Transform Map Field
 
 
-# This list is not linked in navigation, but it's needed for tests
 @register_model_view(IPFabricTransformField, "list", path="", detail=False)
 class IPFabricTransformFieldListView(generic.ObjectListView):
     queryset = IPFabricTransformField.objects.all()
@@ -845,7 +1079,7 @@ class IPFabricSyncBulkDeleteView(generic.BulkDeleteView):
 
 
 @register_model_view(IPFabricSync, "transformmaps")
-class IPFabricTransformMapTabView(generic.ObjectChildrenView):
+class IPFabricTransformMapSyncTabView(generic.ObjectChildrenView):
     queryset = IPFabricSync.objects.all()
     child_model = IPFabricTransformMap
     table = IPFabricTransformMapTable
@@ -865,6 +1099,105 @@ class IPFabricTransformMapTabView(generic.ObjectChildrenView):
         )
 
 
+@register_model_view(IPFabricSync, "filters")
+class IPFabricTransformMapFilterTabView(generic.ObjectChildrenView):
+    queryset = IPFabricSync.objects.all()
+    child_model = IPFabricFilter
+    table = IPFabricFilterTable
+    template_name = "generic/object_children.html"
+    actions = (AddObject, BulkDelete)
+    tab = ViewTab(
+        label=_("Filters"),
+        badge=lambda obj: obj.filters.count(),
+        permission="ipfabric_netbox.view_ipfabricfilter",
+    )
+
+    def get_children(self, request, parent):
+        return parent.filters.all()
+
+
+@register_model_view(IPFabricSync, "endpoints")
+class IPFabricSyncEndpointTabView(generic.ObjectChildrenView):
+    queryset = IPFabricSync.objects.all()
+    child_model = IPFabricEndpoint
+    table = IPFabricEndpointTable
+    template_name = "generic/object_children.html"
+    actions = ()
+    tab = ViewTab(
+        label=_("Endpoints"),
+        badge=lambda obj: IPFabricEndpoint.objects.filter(filters__syncs=obj)
+        .distinct()
+        .count(),
+        permission="ipfabric_netbox.view_ipfabricendpoint",
+    )
+
+    def get_children(self, request, parent):
+        # Get all unique endpoints used by filters in this sync
+        return (
+            IPFabricEndpoint.objects.filter(filters__syncs=parent)
+            .distinct()
+            .annotate(
+                sync_pk=models.Value(parent.pk, output_field=models.IntegerField()),
+                filters_count=models.Count(
+                    "filters", filter=models.Q(filters__syncs=parent)
+                ),
+            )
+        )
+
+    def get_table(self, *args, **kwargs):
+        table = super().get_table(*args, **kwargs)
+        # Override default columns to show the context-specific ones
+        table.default_columns = ("name", "endpoint", "filters_count", "show_filters")
+        return table
+
+
+@register_model_view(
+    IPFabricSync,
+    name="endpoint_filters",
+    path="endpoint/<int:endpoint_pk>/filters",
+    kwargs={"model": IPFabricSync},
+)
+class IPFabricSyncEndpointFiltersView(CombinedExpressionsBaseView):
+    """Display combined filters for an endpoint within a specific sync."""
+
+    def get_context_data(self, request, **kwargs):
+        """Provide context for endpoint filters within a sync.
+
+        Args:
+            request: HTTP request (must be HTMX)
+            **kwargs: Must contain 'pk' (sync primary key) and 'endpoint_pk'
+
+        Returns:
+            dict: Standardized context with endpoint, sync, and combined filters
+        """
+        sync_pk = kwargs.get("pk")
+        endpoint_pk = kwargs.get("endpoint_pk")
+
+        # Return empty context if not HTMX or missing required parameters
+        if not request.htmx or not sync_pk or not endpoint_pk:
+            return {
+                "object": None,
+                "combined_expressions": {},
+                "is_empty": True,
+                "context_type": "endpoint",
+            }
+
+        # Fetch sync and endpoint objects
+        sync_obj = IPFabricSync.objects.get(pk=sync_pk)
+        endpoint_obj = IPFabricEndpoint.objects.get(pk=endpoint_pk)
+
+        # Combine filters for this endpoint within this sync
+        combined = endpoint_obj.combine_filters(sync=sync_obj)
+
+        return {
+            "object": endpoint_obj,  # The endpoint is the main object
+            "sync": sync_obj,  # Pass sync for template context
+            "combined_expressions": combined,
+            "is_empty": len(combined) == 0,
+            "context_type": "endpoint",
+        }
+
+
 @register_model_view(IPFabricSync, "ingestion")
 class IPFabricIngestionTabView(generic.ObjectChildrenView):
     queryset = IPFabricSync.objects.all()
@@ -1234,3 +1567,384 @@ class IPFabricTable(generic.ObjectView):
 
 
 # endregion
+
+
+# region - Filter
+@register_model_view(IPFabricFilter, "list", path="", detail=False)
+class IPFabricFilterListView(generic.ObjectListView):
+    queryset = IPFabricFilter.objects.all()
+    table = IPFabricFilterTable
+    filterset = IPFabricFilterFilterSet
+    template_name = "ipfabric_netbox/htmx_list.html"
+
+
+@register_model_view(IPFabricFilter, "add", detail=False)
+@register_model_view(IPFabricFilter, "edit")
+class IPFabricFilterEditView(generic.ObjectEditView):
+    queryset = IPFabricFilter.objects.all()
+    form = IPFabricFilterForm
+    default_return_url = "plugins:ipfabric_netbox:ipfabricfilter_list"
+
+
+@register_model_view(IPFabricFilter, "delete")
+class IPFabricFilterDeleteView(generic.ObjectDeleteView):
+    queryset = IPFabricFilter.objects.all()
+    default_return_url = "plugins:ipfabric_netbox:ipfabricfilter_list"
+
+
+@register_model_view(IPFabricFilter, "bulk_import", path="import", detail=False)
+class IPFabricFilterBulkImportView(generic.BulkImportView):
+    queryset = IPFabricFilter.objects.all()
+    model_form = IPFabricFilterBulkImportForm
+
+
+@register_model_view(IPFabricFilter, "bulk_edit", path="edit", detail=False)
+class IPFabricFilterBulkEditView(generic.BulkEditView):
+    queryset = IPFabricFilter.objects.all()
+    table = IPFabricFilterTable
+    form = IPFabricFilterBulkEditForm
+
+
+@register_model_view(IPFabricFilter, "bulk_rename", path="rename", detail=False)
+class IPFabricFilterBulkRenameView(generic.BulkRenameView):
+    queryset = IPFabricFilter.objects.all()
+
+
+@register_model_view(IPFabricFilter, "bulk_delete", path="delete", detail=False)
+class IPFabricFilterBulkDeleteView(generic.BulkDeleteView):
+    queryset = IPFabricFilter.objects.all()
+    table = IPFabricFilterTable
+
+
+@register_model_view(IPFabricFilter)
+class IPFabricFilterView(GetRelatedModelsMixin, generic.ObjectView):
+    queryset = IPFabricFilter.objects.all()
+
+    def get_extra_context(self, request, instance):
+        return {
+            "related_models": self.get_related_models(
+                request,
+                instance,
+                extra=(
+                    (
+                        IPFabricSync.objects.restrict(request.user, "view").filter(
+                            filters__in=[instance]
+                        ),
+                        "filter_id",
+                    ),
+                    (
+                        IPFabricEndpoint.objects.restrict(request.user, "view").filter(
+                            filters__in=[instance]
+                        ),
+                        "ipfabric_filter_id",
+                    ),
+                    (
+                        IPFabricFilterExpression.objects.restrict(
+                            request.user, "view"
+                        ).filter(filters__in=[instance]),
+                        "ipfabric_filter_id",
+                    ),
+                ),
+            ),
+        }
+
+
+@register_model_view(
+    IPFabricFilter,
+    name="combined_expressions",
+    path="combined-expressions",
+    kwargs={"model": IPFabricFilter},
+)
+class IPFabricFilterCombinedExpressionsView(CombinedExpressionsBaseView):
+    """Display merged expressions for a single filter."""
+
+    def get_context_data(self, request, **kwargs):
+        """Provide context for filter's merged expressions.
+
+        Args:
+            request: HTTP request (must be HTMX)
+            **kwargs: Must contain 'pk' (filter primary key)
+
+        Returns:
+            dict: Standardized context with filter object and merged expressions
+        """
+        filter_pk = kwargs.get("pk")
+
+        # Return empty context if not HTMX or missing required parameters
+        if not request.htmx or not filter_pk:
+            return {
+                "object": None,
+                "combined_expressions": [],
+                "is_empty": True,
+                "context_type": "filter",
+            }
+
+        # Force fresh query from database, prefetch expressions
+        filter_obj = IPFabricFilter.objects.prefetch_related("expressions").get(
+            pk=filter_pk
+        )
+        combined = filter_obj.merge_expressions()
+
+        return {
+            "object": filter_obj,
+            "combined_expressions": combined,
+            "is_empty": len(combined) == 0,
+            "context_type": "filter",
+        }
+
+
+# endregion
+
+
+# region - Filter Expression
+@register_model_view(IPFabricFilterExpression, "list", path="", detail=False)
+class IPFabricFilterExpressionListView(generic.ObjectListView):
+    queryset = IPFabricFilterExpression.objects.all()
+    table = IPFabricFilterExpressionTable
+    filterset = IPFabricFilterExpressionFilterSet
+
+
+@register_model_view(IPFabricFilterExpression, "add", detail=False)
+@register_model_view(IPFabricFilterExpression, "edit")
+class IPFabricFilterExpressionEditView(generic.ObjectEditView):
+    queryset = IPFabricFilterExpression.objects.all()
+    form = IPFabricFilterExpressionForm
+    default_return_url = "plugins:ipfabric_netbox:ipfabricfilterexpression_list"
+    template_name = "ipfabric_netbox/ipfabricfilterexpression_edit.html"
+
+    def get_extra_context(self, request, instance):
+        """Add test configuration context to the template."""
+        context = super().get_extra_context(request, instance)
+
+        # Add test-related context if editing existing object
+        if instance.pk:
+            # Get available test sources and endpoints
+            sources, endpoints = get_filter_expression_test_candidates(instance)
+            context["available_test_sources"] = list(sources)
+            context["available_test_endpoints"] = list(endpoints)
+            context["can_test"] = bool(sources and endpoints)
+        else:
+            context["can_test"] = False
+
+        return context
+
+
+@register_model_view(IPFabricFilterExpression, "delete")
+class IPFabricFilterExpressionDeleteView(generic.ObjectDeleteView):
+    queryset = IPFabricFilterExpression.objects.all()
+    default_return_url = "plugins:ipfabric_netbox:ipfabricfilterexpression_list"
+
+
+@register_model_view(
+    IPFabricFilterExpression, "bulk_import", path="import", detail=False
+)
+class IPFabricFilterExpressionBulkImportView(generic.BulkImportView):
+    queryset = IPFabricFilterExpression.objects.all()
+    model_form = IPFabricFilterExpressionBulkImportForm
+
+
+@register_model_view(IPFabricFilterExpression, "bulk_edit", path="edit", detail=False)
+class IPFabricFilterExpressionBulkEditView(generic.BulkEditView):
+    queryset = IPFabricFilterExpression.objects.all()
+    table = IPFabricFilterExpressionTable
+    form = IPFabricFilterExpressionBulkEditForm
+
+
+@register_model_view(
+    IPFabricFilterExpression, "bulk_rename", path="rename", detail=False
+)
+class IPFabricFilterExpressionBulkRenameView(generic.BulkRenameView):
+    queryset = IPFabricFilterExpression.objects.all()
+
+
+@register_model_view(
+    IPFabricFilterExpression, "bulk_delete", path="delete", detail=False
+)
+class IPFabricFilterExpressionBulkDeleteView(generic.BulkDeleteView):
+    queryset = IPFabricFilterExpression.objects.all()
+    table = IPFabricFilterExpressionTable
+
+
+@register_model_view(IPFabricFilterExpression)
+class IPFabricFilterExpressionView(GetRelatedModelsMixin, generic.ObjectView):
+    queryset = IPFabricFilterExpression.objects.all()
+
+    def get_extra_context(self, request, instance):
+        return {
+            "related_models": self.get_related_models(
+                request,
+                instance,
+                extra=(
+                    (
+                        IPFabricFilter.objects.restrict(request.user, "view").filter(
+                            expressions__in=[instance]
+                        ),
+                        "expression_id",
+                    ),
+                ),
+            ),
+        }
+
+
+@register_model_view(IPFabricFilterExpression, "test")
+class IPFabricFilterExpressionTestView(View):
+    """Test a filter expression against IP Fabric API."""
+
+    def post(self, request, pk=None):
+        # Get test parameters from POST data
+        test_source_id = request.POST.get("test_source")
+        test_endpoint_id = request.POST.get("test_endpoint")
+        expression_json = request.POST.get("expression")
+
+        return self._test_expression_logic(
+            request, test_source_id, test_endpoint_id, expression_json
+        )
+
+    @staticmethod
+    def _test_expression_logic(
+        request, test_source_id, test_endpoint_id, expression_json
+    ):
+        """Shared logic for testing filter expressions (works for both saved and unsaved)."""
+
+        # Validate required fields
+        if not test_source_id:
+            return HttpResponse(
+                json.dumps({"success": False, "error": "Please select a Test Source."}),
+                content_type="application/json",
+            )
+
+        if not test_endpoint_id:
+            return HttpResponse(
+                json.dumps(
+                    {"success": False, "error": "Please select a Test Endpoint."}
+                ),
+                content_type="application/json",
+            )
+
+        # Validate expression JSON
+        if expression_json:
+            try:
+                expression_data = json.loads(expression_json)
+                if not isinstance(expression_data, list):
+                    return HttpResponse(
+                        json.dumps(
+                            {
+                                "success": False,
+                                "error": "Expression must be a JSON list.",
+                            }
+                        ),
+                        content_type="application/json",
+                    )
+                for idx, item in enumerate(expression_data):
+                    if not isinstance(item, dict):
+                        return HttpResponse(
+                            json.dumps(
+                                {
+                                    "success": False,
+                                    "error": f"Expression item at index {idx} must be a dictionary.",
+                                }
+                            ),
+                            content_type="application/json",
+                        )
+            except json.JSONDecodeError as e:
+                return HttpResponse(
+                    json.dumps({"success": False, "error": f"Invalid JSON: {str(e)}"}),
+                    content_type="application/json",
+                )
+        else:
+            return HttpResponse(
+                json.dumps({"success": False, "error": "Expression is required."}),
+                content_type="application/json",
+            )
+
+        # Get source and endpoint objects
+        try:
+            source = IPFabricSource.objects.get(pk=test_source_id)
+        except IPFabricSource.DoesNotExist:
+            return HttpResponse(
+                json.dumps({"success": False, "error": "Selected source not found."}),
+                content_type="application/json",
+                status=404,
+            )
+
+        # Check if source is LOCAL
+        if source.type != IPFabricSourceTypeChoices.LOCAL:
+            return HttpResponse(
+                json.dumps(
+                    {
+                        "success": False,
+                        "error": "Cannot test against REMOTE sources. Please select a LOCAL IP Fabric source with direct API access.",
+                    }
+                ),
+                content_type="application/json",
+            )
+
+        try:
+            endpoint = IPFabricEndpoint.objects.get(pk=test_endpoint_id)
+        except IPFabricEndpoint.DoesNotExist:
+            return HttpResponse(
+                json.dumps({"success": False, "error": "Selected endpoint not found."}),
+                content_type="application/json",
+                status=404,
+            )
+
+        # Test the expression against IP Fabric API
+        try:
+            # Check that source has auth token
+            auth = source.parameters.get("auth")
+            if not auth:
+                return HttpResponse(
+                    json.dumps(
+                        {
+                            "success": False,
+                            "error": "Source is missing API authentication token.",
+                        }
+                    ),
+                    content_type="application/json",
+                )
+
+            # Prepare parameters for IPFabric client (same pattern as other views)
+            parameters = source.parameters.copy()
+            parameters.update(
+                {
+                    "snapshot_id": "$last",
+                    "base_url": source.url,
+                    "pagination": {"limit": 1, "start": 0},
+                }
+            )
+            # Build filter - use AND type as default (IPF doesn't distinguish between types at this level)
+            filter_dict = {"and": expression_data}
+            ipf = IPFabric(parameters=parameters)
+            results = ipf.ipf.fetch_all(
+                url=endpoint.endpoint, snapshot_id="$last", filters=filter_dict
+            )
+
+            # Return success
+            return HttpResponse(
+                json.dumps(
+                    {
+                        "success": True,
+                        "count": len(results),
+                        "message": f"Test successful! Expression matched {len(results)} result(s) (limited to 1 for testing).",
+                    }
+                ),
+                content_type="application/json",
+            )
+
+        except Exception as e:
+            # Return error with helpful context
+            error_msg = str(e)
+
+            # Enhance error message for common issues
+            if "Unrecognized key(s)" in error_msg:
+                error_msg += f" | Hint: The field name in your expression doesn't exist in the '{endpoint.endpoint}' endpoint. Check the IP Fabric API documentation for valid field names for this table."
+            elif "Invalid Input" in error_msg or "VALIDATION_FAILED" in error_msg:
+                error_msg += f" | Hint: Check that your filter syntax is correct and field names are valid for endpoint '{endpoint.endpoint}'."
+
+            return HttpResponse(
+                json.dumps({"success": False, "error": f"API Error: {error_msg}"}),
+                content_type="application/json",
+            )
+
+
+# endregion