ipfabric_netbox 4.2.2b3__tar.gz → 4.2.2b4__tar.gz

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipfabric_netbox
-Version: 4.2.2b3
+Version: 4.2.2b4
 Summary: NetBox plugin to sync IP Fabric data into NetBox
 License: MIT
 Keywords: netbox,ipfabric,plugin,sync
@@ -24,7 +24,7 @@ Requires-Dist: ipfabric (>=6.6.4) ; extra != "ipfabric_6_10" and extra != "ipfab
 Requires-Dist: ipfabric (>=7.0.0,<7.1.0) ; extra != "ipfabric_6_10" and extra == "ipfabric_7_0" and extra != "ipfabric_7_2" and extra != "ipfabric_7_3"
 Requires-Dist: ipfabric (>=7.2.0,<7.3.0) ; extra != "ipfabric_6_10" and extra != "ipfabric_7_0" and extra == "ipfabric_7_2" and extra != "ipfabric_7_3"
 Requires-Dist: ipfabric (>=7.3.0,<7.4.0) ; extra != "ipfabric_6_10" and extra != "ipfabric_7_0" and extra != "ipfabric_7_2" and extra == "ipfabric_7_3"
-Requires-Dist: netboxlabs-netbox-branching (>=0.5.5,<0.6.0)
+Requires-Dist: netboxlabs-netbox-branching (==0.7.0)
 Requires-Dist: netutils
 Project-URL: Bug Tracker, https://gitlab.com/ip-fabric/integrations/ipfabric-netbox-sync/-/issues
 Project-URL: Homepage, https://gitlab.com/ip-fabric/integrations/ipfabric-netbox-sync
@@ -65,7 +65,9 @@ These are the required NetBox versions for corresponding plugin version. Any oth
 
 | Netbox Version | Plugin Version |
 |----------------|----------------|
-| 4.3.0 and up   | 4.0.0 and up   |
+| 4.4.0 and up   | 4.3.0 and up   |
+| 4.3.0 - 4.3.7  | 4.2.2          |
+| 4.3.0 - 4.3.6  | 4.0.0 - 4.2.1  |
 | 4.2.4 - 4.2.9  | 3.2.2 - 3.2.4  |
 | 4.2.0 - 4.2.3  | 3.2.0          |
 | 4.1.5 - 4.1.11 | 3.1.1 - 3.1.3  |

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/README.md

@@ -32,7 +32,9 @@ These are the required NetBox versions for corresponding plugin version. Any oth
 
 | Netbox Version | Plugin Version |
 |----------------|----------------|
-| 4.3.0 and up   | 4.0.0 and up   |
+| 4.4.0 and up   | 4.3.0 and up   |
+| 4.3.0 - 4.3.7  | 4.2.2          |
+| 4.3.0 - 4.3.6  | 4.0.0 - 4.2.1  |
 | 4.2.4 - 4.2.9  | 3.2.2 - 3.2.4  |
 | 4.2.0 - 4.2.3  | 3.2.0          |
 | 4.1.5 - 4.1.11 | 3.1.1 - 3.1.3  |

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/__init__.py

@@ -6,9 +6,9 @@ class NetboxIPFabricConfig(PluginConfig):
     name = "ipfabric_netbox"
     verbose_name = "NetBox IP Fabric SoT Plugin"
     description = "Sync IP Fabric into NetBox"
-    version = "4.2.2b3"
+    version = "4.2.2b4"
     base_url = "ipfabric"
-    min_version = "4.2.4"
+    min_version = "4.4.0"
 
     def ready(self):
         super().ready()

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/forms.py

@@ -531,13 +531,28 @@ class IPFabricSyncForm(NetBoxModelForm):
         widgets = {"source": HTMXSelect()}
 
     def __init__(self, *args, **kwargs):
+        # The initial data for BooleanFields change to list on HTMX requests.
+        # This causes URL to bloat, so we need to sanitize it before it's used.
+        initial = kwargs.get("initial", {}).copy()
+        for name, value in initial.items():
+            if (
+                (
+                    name.startswith("ipf_")
+                    or (
+                        name in self.base_fields
+                        and isinstance(self.base_fields[name], forms.BooleanField)
+                    )
+                )
+                and isinstance(value, list)
+                and len(value) > 1
+            ):
+                initial[name] = value[-1]  # Keep only the last value
+        kwargs["initial"] = initial
         super().__init__(*args, **kwargs)
-        self.source_type = None
-        ingestion_type = get_field_value(self, "source")
+
+        source = get_field_value(self, "source")
 
         if not self.data:
-            if ingestion_type:
-                self.source_type = IPFabricSource.objects.get(pk=ingestion_type).type
             if sites := get_field_value(self, "sites"):
                 sites = list_to_choices(str_to_list(sites))
                 self.fields["sites"].choices = sites
@@ -547,46 +562,82 @@ class IPFabricSyncForm(NetBoxModelForm):
                 snapshot_sites = IPFabricSnapshot.objects.get(pk=snapshot_id).sites
                 choices = list_to_choices(str_to_list(snapshot_sites))
                 self.fields["sites"].choices = choices
+            source = self.data.get("source")
 
+        # These values are not populated by data on instance, so we need to set them manually
         if self.instance and self.instance.pk:
             if not kwargs.get("initial"):
-                self.source_type = self.instance.snapshot_data.source.type
-                self.initial["source"] = self.instance.snapshot_data.source
+                source = self.instance.snapshot_data.source
                 if not self.data:
                     self.fields["sites"].choices = list_to_choices(
                         self.instance.snapshot_data.sites
                     )
-
-                self.initial["sites"] = self.instance.parameters.get("sites", [])
+            else:
+                source = kwargs["initial"].get(
+                    "source", self.instance.snapshot_data.source
+                )
+            self.initial["source"] = source
+            if "groups" not in self.initial:
                 self.initial["groups"] = self.instance.parameters.get("groups", [])
 
+            # Handle sites field initialization
+            if "sites" not in self.initial:
+                selected_sites = self.instance.parameters.get("sites", [])
+                self.initial["sites"] = selected_sites
+
+                # Ensure the field has the selected sites as both choices and initial values
+                if not self.data and selected_sites:
+                    # Get current choices and ensure selected sites are included
+                    current_choices = (
+                        list(self.fields["sites"].choices)
+                        if hasattr(self.fields["sites"], "choices")
+                        else []
+                    )
+                    current_choice_values = [choice[0] for choice in current_choices]
+
+                    # Add any missing selected sites to choices
+                    for site in str_to_list(selected_sites):
+                        if site not in current_choice_values:
+                            current_choices.append((site, site))
+
+                    self.fields["sites"].choices = current_choices
+                self.fields["sites"].initial = selected_sites
+            else:
+                self.fields["sites"].initial = self.initial["sites"]
+
         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 = {}
 
+        # 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.copy(form_field)
+                self.fields[field_name] = copy.deepcopy(form_field)
                 if self.instance and self.instance.parameters:
-                    self.fields[field_name].initial = self.instance.parameters.get(name)
+                    value = self.instance.parameters.get(name)
+                    self.fields[field_name].initial = value
 
         # Set fieldsets dynamically based and backend_fields
         fieldsets = [
             FieldSet("name", "source", "groups", name=_("IP Fabric Source")),
         ]
-        if self.source_type == "local":
-            fieldsets.append(
-                FieldSet("snapshot_data", "sites", name=_("Snapshot Information")),
-            )
-        else:
-            fieldsets.append(
-                FieldSet("snapshot_data", name=_("Snapshot Information")),
-            )
+        # Only show snapshot and sites 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")),
+                )
+            else:
+                fieldsets.append(
+                    FieldSet("snapshot_data", name=_("Snapshot Information")),
+                )
         for k, v in self.backend_fields.items():
             fieldsets.append(FieldSet(*v, name=f"{k.upper()} Parameters"))
         fieldsets.append(
@@ -602,10 +653,22 @@ class IPFabricSyncForm(NetBoxModelForm):
     def clean(self):
         super().clean()
 
+        source = self.cleaned_data.get("source")
+        snapshot = self.cleaned_data.get("snapshot_data")
+
+        if (
+            source
+            and snapshot
+            and IPFabricSource.objects.get(pk=source.pk)
+            != IPFabricSnapshot.objects.get(pk=snapshot.pk).source
+        ):
+            raise ValidationError(
+                {"snapshot_data": _("Snapshot does not belong to the selected source.")}
+            )
+
         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:
-            snapshot = self.cleaned_data["snapshot_data"]
             # Check if all sites are valid - fail if any site is not found in snapshot.sites
             if not all(
                 any(site in snapshot_site for snapshot_site in snapshot.sites)

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/migrations/0001_initial_squashed_0013_switch_to_branching_plugin.py

@@ -29,6 +29,7 @@ if TYPE_CHECKING:
 
 def create_custom_field(
     apps: "apps_type",
+    db_alias: str,
     field_name: str,
     label: str,
     target_models: list,
@@ -37,6 +38,7 @@ def create_custom_field(
 ):
     """Create a single custom field and link it to required models."""
     ObjectType = apps.get_model("core", "ObjectType")
+    ContentType = apps.get_model("contenttypes", "ContentType")
 
     defaults = {
         "label": label,
@@ -47,23 +49,29 @@ def create_custom_field(
         "ui_editable": getattr(CustomFieldUIEditableChoices, "NO"),
     }
 
-    custom_field, _ = apps.get_model("extras", "CustomField").objects.update_or_create(
-        type=getattr(CustomFieldTypeChoices, cf_type.upper()),
-        name=field_name,
-        defaults=defaults,
+    custom_field, _ = (
+        apps.get_model("extras", "CustomField")
+        .objects.using(db_alias)
+        .update_or_create(
+            type=getattr(CustomFieldTypeChoices, cf_type.upper()),
+            name=field_name,
+            defaults=defaults,
+        )
     )
 
     for model in target_models:
-        custom_field.object_types.add(ObjectType.objects.get_for_model(model))
+        custom_field.object_types.add(ContentType.objects.get_for_model(model))
 
 
 def prepare_custom_fields(apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"):
     """Forward migration to prepare ipfabric_netbox custom fields and links."""
+    db_alias = schema_editor.connection.alias
     Device = apps.get_model("dcim", "Device")
     Site = apps.get_model("dcim", "Site")
 
     create_custom_field(
         apps,
+        db_alias,
         "ipfabric_source",
         "IP Fabric Source",
         [Device, Site],
@@ -72,31 +80,41 @@ def prepare_custom_fields(apps: "apps_type", schema_editor: "BaseDatabaseSchemaE
     )
     create_custom_field(
         apps,
+        db_alias,
         "ipfabric_ingestion",
         "IP Fabric Last Ingestion",
         [Device, Site],
         cf_type="type_object",
         object_type=apps.get_model("ipfabric_netbox", "IPFabricIngestion"),
     )
-    cl, _ = apps.get_model("extras", "CustomLink").objects.update_or_create(
-        defaults={
-            "link_text": "{% if object.custom_field_data.ipfabric_source is defined %}{% set SOURCE_ID = object.custom_field_data.ipfabric_source %}{% if SOURCE_ID %}IP Fabric{% endif %}{% endif %}",
-            "link_url": '{% if object.custom_field_data.ipfabric_source is defined %}{% set SOURCE_ID = object.custom_field_data.ipfabric_source %}{% if SOURCE_ID %}{% set BASE_URL = object.custom_fields.filter(related_object_type__model="ipfabricsource").first().related_object_type.model_class().objects.get(pk=SOURCE_ID).url %}{{ BASE_URL }}/inventory/devices?options={"filters":{"sn": ["like","{{ object.serial }}"]}}{% endif %}{%endif%}',
-            "new_window": True,
-            "button_class": CustomLinkButtonClassChoices.BLUE,
-        },
-        name="ipfabric",
+    cl, _ = (
+        apps.get_model("extras", "CustomLink")
+        .objects.using(db_alias)
+        .update_or_create(
+            defaults={
+                "link_text": "{% if object.custom_field_data.ipfabric_source is defined %}{% set SOURCE_ID = object.custom_field_data.ipfabric_source %}{% if SOURCE_ID %}IP Fabric{% endif %}{% endif %}",
+                "link_url": '{% if object.custom_field_data.ipfabric_source is defined %}{% set SOURCE_ID = object.custom_field_data.ipfabric_source %}{% if SOURCE_ID %}{% set BASE_URL = object.custom_fields.filter(related_object_type__model="ipfabricsource").first().related_object_type.model_class().objects.get(pk=SOURCE_ID).url %}{{ BASE_URL }}/inventory/devices?options={"filters":{"sn": ["like","{{ object.serial }}"]}}{% endif %}{%endif%}',
+                "new_window": True,
+                "button_class": CustomLinkButtonClassChoices.BLUE,
+            },
+            name="ipfabric",
+        )
     )
     cl.object_types.add(
-        apps.get_model("core", "ObjectType").objects.get_for_model(Device)
+        apps.get_model("contenttypes", "ContentType")
+        .objects.db_manager(db_alias)
+        .get_for_model(Device)
     )
 
 
 def cleanup_custom_fields(apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"):
     """Reverse migration to prepare ipfabric_netbox custom fields and links."""
+    db_alias = schema_editor.connection.alias
     for field_name in ["ipfabric_source", "ipfabric_ingestion"]:
-        custom_field = apps.get_model("extras", "CustomField").objects.get(
-            name=field_name
+        custom_field = (
+            apps.get_model("extras", "CustomField")
+            .objects.using(db_alias)
+            .get(name=field_name)
         )
         for model in custom_field.object_types.all()[:]:
             custom_field.object_types.remove(model)
@@ -109,7 +127,9 @@ def prepare_transform_maps(
     """Create transform maps if they do not exist yet.
     They used to be created during plugin.ready() so they might be present on older DBs.
     """
-    build_transform_maps(data=get_transform_map(), apps=apps)
+    build_transform_maps(
+        data=get_transform_map(), apps=apps, db_alias=schema_editor.connection.alias
+    )
 
 
 class Migration(migrations.Migration):

ipfabric_netbox-4.2.2b4/ipfabric_netbox/migrations/0019_alter_ipfabrictransformmap_options_and_more.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.2.5 on 2025-09-22 07:43
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("ipfabric_netbox", "0018_remove_type_field"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="ipfabrictransformmap",
+            options={"ordering": ("pk",)},
+        ),
+        migrations.AlterModelOptions(
+            name="ipfabrictransformmapgroup",
+            options={"ordering": ("pk",)},
+        ),
+    ]

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/models.py

@@ -1,4 +1,5 @@
 import ast
+import functools
 import json
 import logging
 import traceback
@@ -35,10 +36,10 @@ from netbox.models import NetBoxModel
 from netbox.models import PrimaryModel
 from netbox.models.features import JobsMixin
 from netbox.models.features import TagsMixin
-from netbox.registry import registry
 from netbox_branching.choices import BranchStatusChoices
 from netbox_branching.contextvars import active_branch
 from netbox_branching.models import Branch
+from netbox_branching.utilities import supports_branching
 from utilities.querysets import RestrictedQuerySet
 from utilities.request import NetBoxFakeRequest
 
@@ -176,13 +177,17 @@ class IPFabricTransformMap(NetBoxModel):
             )
         return cleaned_data
 
+    @functools.cache
     def get_models(self):
         _context = dict()
 
-        for app, model_names in registry["model_features"]["custom_fields"].items():
+        for app, app_models in apps.all_models.items():
             _context.setdefault(app, {})
-            for model_name in model_names:
-                model = apps.get_registered_model(app, model_name)
+            for model in app_models:
+                if isinstance(model, str):
+                    model = apps.get_registered_model(app, model)
+                if not supports_branching(model):
+                    continue
                 _context[app][model.__name__] = model
         _context["contenttypes"] = {}
         _context["contenttypes"]["ContentType"] = ContentType
@@ -249,10 +254,16 @@ class IPFabricTransformMap(NetBoxModel):
                 # See NetBox docs Customization -> Custom Scripts -> Change Logging
                 instance = queryset.get(**context)
                 instance.snapshot()
+                changed = False
                 for attr, value in defaults.items():
+                    # Only run data validation and save if something has changed
+                    if getattr(instance, attr) == value:
+                        continue
+                    changed = True
                     setattr(instance, attr, value)
-                instance.full_clean()
-                instance.save(using=connection_name)
+                if changed:
+                    instance.full_clean()
+                    instance.save(using=connection_name)
             except target_class.DoesNotExist:
                 for field in list(context.keys()):
                     # When assigning we need to replace `field__isnull=True` with `field=None`

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/template_content.py

@@ -9,7 +9,7 @@ logger = logging.getLogger("ipfabric_netbox.template_content")
 
 
 class SiteTopologyButtons(PluginTemplateExtension):
-    model = "dcim.site"
+    models = ["dcim.site"]
 
     def buttons(self):
         try:

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/templates/ipfabric_netbox/inc/site_topology_button.html

@@ -1,4 +1,3 @@
-{% if object.custom_field_data.ipfabric_source %}
 <div class="btn-group" role="group" aria-label="Button group with nested dropdown">
   <div class="btn-group" role="group">
     <button id="btnGroupDrop1" type="button" class="btn btn-sm btn-success dropdown-toggle" data-bs-toggle="dropdown"
@@ -48,7 +47,6 @@
     </div>
   </div>
 </div>
-{% endif %}
 
 {% block javascript %}
 <script>

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/templates/ipfabric_netbox/ipfabricsync.html

@@ -3,6 +3,7 @@
 {% load helpers %}
 {% load plugins %}
 {% load render_table from django_tables2 %}
+{% load perms %}
 {% load ipfabric_netbox_helpers %}
 
 {% block extra_controls %}
@@ -22,7 +23,7 @@
       </span>
     {% endif %}
   {% endif %}
-{% endblock %}
+{% endblock extra_controls %}
 
 {% block content %}
 <div class="row mb-3">

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/tests/api/test_api.py

@@ -620,7 +620,7 @@ class IPFabricSyncTest(APIViewTestCases.APIViewTestCase):
             name="Sync Test E",
             snapshot_data=snapshots[1],
             parameters={"device": True, "interface": True},
-            auto_merge=True,
+            auto_merge=False,
         )
         IPFabricSync.objects.create(
             name="Sync Test F",

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/tests/test_forms.py

@@ -808,13 +808,6 @@ class IPFabricSyncFormTestCase(TestCase):
         )
         self.assertTrue(form.is_valid(), form.errors)
 
-    def test_form_initialization_with_source_no_data(self):
-        """Test source handling without data"""
-        form = IPFabricSyncForm(initial={"source": self.source.pk})
-
-        # Verify that source_type is set when there's a source and no data
-        self.assertEqual(form.source_type, IPFabricSourceTypeChoices.LOCAL)
-
     def test_form_initialization_with_sites_no_data(self):
         """Test sites handling without data"""
         form = IPFabricSyncForm(initial={"sites": ["site1", "site2"]})
@@ -905,9 +898,6 @@ class IPFabricSyncFormTestCase(TestCase):
         # Test form initialization with existing instance but no data
         form = IPFabricSyncForm(instance=sync_instance)
 
-        # Verify that source_type is set from the instance
-        self.assertEqual(form.source_type, IPFabricSourceTypeChoices.LOCAL)
-
         # Verify that initial values are set from instance parameters
         self.assertEqual(form.initial["source"], self.source)
         self.assertEqual(form.initial["sites"], ["site1", "site2"])
@@ -932,18 +922,121 @@ class IPFabricSyncFormTestCase(TestCase):
             instance=sync_instance, initial={"name": "Override Name"}
         )
 
-        # When initial kwargs are provided, the form skips the instance initialization block
-        # This means source_type remains None as intended by the form logic
-        self.assertIsNone(form.source_type)
-
-        # initial should not be set from instance when initial kwargs are provided
-        self.assertNotIn("source", form.initial)
-        self.assertNotIn("sites", form.initial)
-        self.assertNotIn("groups", form.initial)
+        # These should be set from instance even when not in initial kwarg
+        self.assertIn("source", form.initial)
+        self.assertIn("sites", form.initial)
+        self.assertIn("groups", form.initial)
 
         # But the provided initial value should be present
         self.assertEqual(form.initial.get("name"), "Override Name")
 
+    def test_sites_initial_value_set_from_form_initial(self):
+        """Test that sites field initial is set from self.initial["sites"]"""
+        # Create an existing sync instance with sites in parameters
+        sync_instance = IPFabricSync.objects.create(
+            name="Existing Sync",
+            snapshot_data=self.snapshot,
+            parameters={
+                "sites": ["site1", "site2"],
+                "groups": [self.transform_map_group.pk],
+            },
+        )
+
+        # Initialize form with existing instance and additional initial data for sites
+        # This will trigger the else branch where self.initial["sites"] is used
+        form = IPFabricSyncForm(
+            instance=sync_instance,
+            initial={"sites": ["override_site1", "override_site2"]},
+        )
+
+        # Verify sites field initial is set from self.initial
+        self.assertEqual(
+            form.fields["sites"].initial, ["override_site1", "override_site2"]
+        )
+
+        # Also verify that self.initial contains the expected sites
+        self.assertEqual(form.initial["sites"], ["override_site1", "override_site2"])
+
+    def test_htmx_boolean_field_list_values_handled(self):
+        """Test sanitizing HTMX BooleanField list values like ['', 'on']"""
+        # Simulate HTMX request where BooleanField values become lists
+        # This happens when `source` field value is changed and form is re-drawn via HTMX
+        form = IPFabricSyncForm(
+            initial={
+                "auto_merge": ["", "on"],  # HTMX sends BooleanField as list
+                "update_custom_fields": ["", "on"],  # Another BooleanField as list
+                "ipf_site": ["", "on"],  # ipf_ prefixed field as list
+                "name": "Test Sync",  # Normal field (not affected)
+            },
+            data={
+                "name": "Test Sync HTMX",
+                "source": self.source.pk,
+                "snapshot_data": self.snapshot.pk,
+            },
+        )
+
+        # The last value from ['', 'on'] should be 'on' which evaluates to True for BooleanFields
+        self.assertEqual(form.initial["auto_merge"], "on")
+        self.assertEqual(form.initial["update_custom_fields"], "on")
+        self.assertEqual(form.initial["ipf_site"], "on")
+        self.assertEqual(form.initial["name"], "Test Sync")  # Normal field unchanged
+
+        # Verify the form is still valid and processes correctly
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test_htmx_boolean_field_single_values_unchanged(self):
+        """Test that normal single values are not affected by the HTMX list handling"""
+        # Test with normal single values (not lists)
+        form = IPFabricSyncForm(
+            initial={
+                "auto_merge": True,  # Normal boolean value
+                "update_custom_fields": False,  # Normal boolean value
+                "ipf_site": "on",  # Normal string value
+                "name": "Test Sync",  # Normal string value
+            },
+            data={
+                "name": "Test Sync Normal",
+                "source": self.source.pk,
+                "snapshot_data": self.snapshot.pk,
+            },
+        )
+
+        # Verify that single values are not processed by value sanitization
+        self.assertEqual(form.initial["auto_merge"], True)
+        self.assertEqual(form.initial["update_custom_fields"], False)
+        self.assertEqual(form.initial["ipf_site"], "on")
+        self.assertEqual(form.initial["name"], "Test Sync")
+
+        # Verify the form is still valid
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test_clean_snapshot_does_not_belong_to_source(self):
+        """Test form validation when snapshot doesn't belong to the selected source"""
+        # Create a second source
+        different_source = IPFabricSource.objects.create(
+            name="Different Source",
+            type=IPFabricSourceTypeChoices.LOCAL,
+            url="https://different.ipfabric.local",
+            status=DataSourceStatusChoices.NEW,
+        )
+
+        # Try to use self.snapshot (which belongs to self.source) with different_source
+        form = IPFabricSyncForm(
+            data={
+                "name": "Test Sync Mismatched Source",
+                "source": different_source.pk,
+                "snapshot_data": self.snapshot.pk,  # This snapshot belongs to self.source, not different_source
+            }
+        )
+
+        # Form should be invalid due to snapshot/source mismatch validation
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertIn("snapshot_data", form.errors)
+        self.assertTrue(
+            "Snapshot does not belong to the selected source"
+            in str(form.errors["snapshot_data"])
+        )
+
     def test_clean_sites_not_part_of_snapshot(self):
         """Test form validation when selected sites are not part of the snapshot"""
         form = IPFabricSyncForm(

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/tests/test_views.py

@@ -37,6 +37,7 @@ from ipfabric_netbox.models import IPFabricSync
 from ipfabric_netbox.models import IPFabricTransformField
 from ipfabric_netbox.models import IPFabricTransformMap
 from ipfabric_netbox.models import IPFabricTransformMapGroup
+from ipfabric_netbox.tables import DeviceIPFTable
 
 
 class PluginPathMixin:
@@ -1971,7 +1972,19 @@ class IPFabricTableViewTestCase(PluginPathMixin, ModelTestCase):
         # Validate context variables
         self.assertEqual(response.context["object"], self.device)
         self.assertIsNotNone(response.context["form"])
-        self.assertEqual(response.context["table"], tableChoices[0][0])
+
+        table = response.context["table"]
+        self.assertIsInstance(table, DeviceIPFTable)
+
+        # Verify the table has the expected structure for empty data scenario
+        self.assertEqual(len(table.data), 0)  # Should be empty when no source
+        self.assertIn(
+            "hostname", [col.name for col in table.columns]
+        )  # Should have default hostname column
+
+        # Verify table meta attributes
+        self.assertEqual(table.empty_text, "No results found")
+        self.assertIn("table-hover", table.attrs.get("class", ""))
 
         # When no source is available, source should be None
         self.assertIsNone(response.context["source"])

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/utilities/transform_map.py

@@ -8,10 +8,10 @@ from django.apps import apps as django_apps
 # see https://docs.djangoproject.com/en/5.1/topics/migrations/#historical-models
 
 
-def build_fields(data, apps):
+def build_fields(data, apps, db_alias):
     ContentType = apps.get_model("contenttypes", "ContentType")
     if "target_model" in data:
-        ct = ContentType.objects.get_for_model(
+        ct = ContentType.objects.db_manager(db_alias).get_for_model(
             apps.get_model(
                 data["target_model"]["app_label"],
                 data["target_model"]["model"],
@@ -19,7 +19,7 @@ def build_fields(data, apps):
         )
         data["target_model"] = ct
     elif "source_model" in data:
-        ct = ContentType.objects.get_for_model(
+        ct = ContentType.objects.db_manager(db_alias).get_for_model(
             apps.get_model(
                 data["source_model"]["app_label"],
                 data["source_model"]["model"],
@@ -29,7 +29,7 @@ def build_fields(data, apps):
     return data
 
 
-def build_transform_maps(data, apps: django_apps = None):
+def build_transform_maps(data, apps: django_apps = None, db_alias: str = "default"):
     apps = apps or django_apps
     IPFabricTransformMap = apps.get_model("ipfabric_netbox", "IPFabricTransformMap")
     IPFabricTransformField = apps.get_model("ipfabric_netbox", "IPFabricTransformField")
@@ -37,14 +37,16 @@ def build_transform_maps(data, apps: django_apps = None):
         "ipfabric_netbox", "IPFabricRelationshipField"
     )
     for tm in data:
-        field_data = build_fields(tm["data"], apps)
-        tm_obj = IPFabricTransformMap.objects.create(**field_data)
+        field_data = build_fields(tm["data"], apps, db_alias)
+        tm_obj = IPFabricTransformMap.objects.using(db_alias).create(**field_data)
         for fm in tm["field_maps"]:
-            field_data = build_fields(fm, apps)
-            IPFabricTransformField.objects.create(transform_map=tm_obj, **field_data)
+            field_data = build_fields(fm, apps, db_alias)
+            IPFabricTransformField.objects.using(db_alias).create(
+                transform_map=tm_obj, **field_data
+            )
         for rm in tm["relationship_maps"]:
-            relationship_data = build_fields(rm, apps)
-            IPFabricRelationshipField.objects.create(
+            relationship_data = build_fields(rm, apps, db_alias)
+            IPFabricRelationshipField.objects.using(db_alias).create(
                 transform_map=tm_obj, **relationship_data
             )
 

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/ipfabric_netbox/views.py

@@ -544,13 +544,13 @@ class IPFabricSyncEditView(generic.ObjectEditView):
 @register_model_view(IPFabricSync)
 class IPFabricSyncView(generic.ObjectView):
     queryset = IPFabricSync.objects.all()
-    actions = ("edit",)
 
     def get(self, request, **kwargs):
-        instance = self.get_object(**kwargs)
-        last_ingestion = instance.ipfabricingestion_set.last()
-
+        # Handle HTMX requests separately
         if request.htmx:
+            instance = self.get_object(**kwargs)
+            last_ingestion = instance.ipfabricingestion_set.last()
+
             response = render(
                 request,
                 "ipfabric_netbox/partials/sync_last_ingestion.html",
@@ -565,15 +565,8 @@ class IPFabricSyncView(generic.ObjectView):
                 response["HX-Refresh"] = "true"
             return response
 
-        return render(
-            request,
-            self.get_template_name(),
-            {
-                "object": instance,
-                "tab": self.tab,
-                **self.get_extra_context(request, instance),
-            },
-        )
+        # For regular requests, use the parent method which includes actions
+        return super().get(request, **kwargs)
 
     def get_extra_context(self, request, instance):
         if request.GET.get("format") in ["json", "yaml"]:
@@ -641,6 +634,26 @@ class IPFabricTransformMapTabView(generic.ObjectChildrenView):
         )
 
 
+@register_model_view(IPFabricSync, "ingestion")
+class IPFabricIngestionTabView(generic.ObjectChildrenView):
+    queryset = IPFabricSync.objects.all()
+    child_model = IPFabricIngestion
+    table = IPFabricIngestionTable
+    filterset = IPFabricIngestionFilterSet
+    tab = ViewTab(
+        label="Ingestions",
+        badge=lambda obj: IPFabricIngestion.objects.filter(sync=obj).count(),
+        permission="ipfabric_netbox.view_ipfabricingestion",
+    )
+
+    def get_children(self, request, parent):
+        return self.child_model.objects.filter(sync=parent).annotate(
+            description=models.F("branch__description"),
+            user=models.F("sync__user__username"),
+            staged_changes=models.Count(models.F("branch__changediff")),
+        )
+
+
 # Ingestion
 class IPFabricIngestionListView(generic.ObjectListView):
     queryset = IPFabricIngestion.objects.annotate(
@@ -870,34 +883,15 @@ class IPFabricIngestionDeleteView(generic.ObjectDeleteView):
     queryset = IPFabricIngestion.objects.all()
 
 
-@register_model_view(IPFabricSync, "ingestion")
-class IPFabricIngestionTabView(generic.ObjectChildrenView):
-    queryset = IPFabricSync.objects.all()
-    child_model = IPFabricIngestion
-    table = IPFabricIngestionTable
-    filterset = IPFabricIngestionFilterSet
-    template_name = "generic/object_children.html"
-    tab = ViewTab(
-        label="Ingestions",
-        badge=lambda obj: IPFabricIngestion.objects.filter(sync=obj).count(),
-        permission="ipfabric_netbox.view_ipfabricingestion",
-    )
-
-    def get_children(self, request, parent):
-        return self.child_model.objects.filter(sync=parent).annotate(
-            description=models.F("branch__description"),
-            user=models.F("sync__user__username"),
-            staged_changes=models.Count(models.F("branch__changediff")),
-        )
-
-
 @register_model_view(Device, "ipfabric")
-class IPFabricTable(View):
+class IPFabricTable(generic.ObjectView):
     template_name = "ipfabric_netbox/ipfabric_table.html"
     tab = ViewTab("IP Fabric", permission="ipfabric_netbox.view_devicetable")
+    queryset = Device.objects.all()
 
-    def get(self, request, pk):
-        device = get_object_or_404(Device, pk=pk)
+    def get_extra_context(self, request, instance):
+        """Process form and prepare table data for the template."""
+        device = instance
         form = (
             IPFabricTableForm(request.GET)
             if "table" in request.GET
@@ -908,7 +902,7 @@ class IPFabricTable(View):
         source = None
 
         if form.is_valid():
-            table = form.cleaned_data["table"]
+            table_name = form.cleaned_data["table"]
             test = {
                 "True": True,
                 "False": False,
@@ -929,36 +923,24 @@ class IPFabricTable(View):
                 snapshot_id = form.cleaned_data["snapshot_data"].snapshot_id
                 source = source or form.cleaned_data["snapshot_data"].source
 
-            if source is None:
-                return render(
-                    request,
-                    self.template_name,
-                    {
-                        "object": device,
-                        "source": source,
-                        "tab": self.tab,
-                        "form": form,
-                        "table": table,
-                    },
-                )
-
-            source.parameters["snapshot_id"] = snapshot_id
-            source.parameters["base_url"] = source.url
-
-            cache_key = (
-                f"ipfabric_{table}_{device.serial}_{source.parameters['snapshot_id']}"
-            )
-            if cache_enable:
-                data = cache.get(cache_key)
-
-            if not data:
-                try:
-                    ipf = IPFabric(parameters=source.parameters)
-                    raw_data, columns = ipf.get_table_data(table=table, device=device)
-                    data = {"data": raw_data, "columns": columns}
-                    cache.set(cache_key, data, 60 * 60 * 24)
-                except Exception as e:
-                    messages.error(request, e)
+            if source is not None:
+                source.parameters["snapshot_id"] = snapshot_id
+                source.parameters["base_url"] = source.url
+
+                cache_key = f"ipfabric_{table_name}_{device.serial}_{source.parameters['snapshot_id']}"
+                if cache_enable:
+                    data = cache.get(cache_key)
+
+                if not data:
+                    try:
+                        ipf = IPFabric(parameters=source.parameters)
+                        raw_data, columns = ipf.get_table_data(
+                            table=table_name, device=device
+                        )
+                        data = {"data": raw_data, "columns": columns}
+                        cache.set(cache_key, data, 60 * 60 * 24)
+                    except Exception as e:
+                        messages.error(request, e)
 
         if not data:
             data = {"data": [], "columns": []}
@@ -973,32 +955,34 @@ class IPFabricTable(View):
             },
         ).configure(table)
 
+        if not source:
+            if source_id := device.custom_field_data.get("ipfabric_source"):
+                source = IPFabricSource.objects.filter(pk=source_id).first()
+            else:
+                source = IPFabricSource.get_for_site(device.site).first()
+
+        return {
+            "source": source,
+            "form": form,
+            "table": table,
+        }
+
+    def get(self, request, **kwargs):
+        """Handle GET requests, with special handling for HTMX table updates."""
+        # For HTMX requests, we only need to return the table HTML
         if request.htmx:
+            device = get_object_or_404(Device, pk=kwargs.get("pk"))
+            context = self.get_extra_context(request, device)
             return render(
                 request,
                 "htmx/table.html",
                 {
-                    "table": table,
+                    "table": context["table"],
                 },
             )
 
-        if not source:
-            if source_id := device.custom_field_data.get("ipfabric_source"):
-                source = IPFabricSource.objects.filter(pk=source_id).first()
-            else:
-                source = IPFabricSource.get_for_site(device.site).first()
-
-        return render(
-            request,
-            self.template_name,
-            {
-                "object": device,
-                "source": source,
-                "tab": self.tab,
-                "form": form,
-                "table": table,
-            },
-        )
+        # For regular requests, use the parent's get() method which will call get_extra_context()
+        return super().get(request, **kwargs)
 
 
 @register_model_view(

{ipfabric_netbox-4.2.2b3 → ipfabric_netbox-4.2.2b4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ipfabric_netbox"
-version = "4.2.2b3"
+version = "4.2.2b4"
 description = "NetBox plugin to sync IP Fabric data into NetBox"
 authors = ["Solution Architecture <solution.architecture@ipfabric.io>"]
 license = "MIT"
@@ -29,7 +29,7 @@ ipfabric = [
     {version = "~=7.2.0", markers = "extra != 'ipfabric_6_10' and extra != 'ipfabric_7_0' and extra == 'ipfabric_7_2' and extra != 'ipfabric_7_3'", optional = true},
     {version = "~=7.3.0", markers = "extra != 'ipfabric_6_10' and extra != 'ipfabric_7_0' and extra != 'ipfabric_7_2' and extra == 'ipfabric_7_3'", optional = true},
 ]
-netboxlabs-netbox-branching = "^0.5.5"
+netboxlabs-netbox-branching = "0.7.0"
 netutils = "*"
 
 [tool.poetry.extras]