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

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.3.2b10"
+    version = "4.3.2b11"
     base_url = "ipfabric"
-    min_version = "4.4.9"
+    min_version = "4.4.0"
 
     def ready(self):
         super().ready()

ipfabric_netbox/choices.py

@@ -173,6 +173,7 @@ class IPFabricEndpointChoices(ChoiceSet):
     SITES = "/inventory/sites/overview"
     DEVICES = "/inventory/devices"
     VIRTUALCHASSIS = "/technology/platforms/stack/members"
+    VSS_CHASSIS = "/technology/platforms/vss/chassis"
     INTERFACES = "/inventory/interfaces"
     PARTNUMBERS = "/inventory/part-numbers"
     VLANS = "/technology/vlans/site-summary"
@@ -184,6 +185,7 @@ class IPFabricEndpointChoices(ChoiceSet):
         (SITES, SITES, "cyan"),
         (DEVICES, DEVICES, "gray"),
         (VIRTUALCHASSIS, VIRTUALCHASSIS, "grey"),
+        (VSS_CHASSIS, VSS_CHASSIS, "gray"),
         (INTERFACES, INTERFACES, "gray"),
         (PARTNUMBERS, PARTNUMBERS, "gray"),
         (VLANS, VLANS, "gray"),

ipfabric_netbox/data/endpoint.json

@@ -14,6 +14,11 @@
     "description": "",
     "endpoint": "/technology/platforms/stack/members"
   },
+  {
+    "name": "Default VSS Chassis Endpoint",
+    "description": "",
+    "endpoint": "/technology/platforms/vss/chassis"
+  },
   {
     "name": "Default Interfaces Endpoint",
     "description": "",

ipfabric_netbox/data/filters.json

@@ -29,7 +29,7 @@
     },
     {
       "name": "Default Child Devices Filter",
-      "endpoints": ["/technology/platforms/stack/members", "/inventory/interfaces", "/technology/routing/vrf/detail", "/technology/addressing/managed-ip/ipv4"],
+      "endpoints": ["/technology/platforms/stack/members", "/technology/platforms/vss/chassis", "/inventory/interfaces", "/technology/routing/vrf/detail", "/technology/addressing/managed-ip/ipv4"],
       "expressions": ["Default Device Child Filter Expression"]
     },
     {

ipfabric_netbox/data/transform_map.json

@@ -153,7 +153,7 @@
                 "source_field": "master",
                 "target_field": "name",
                 "coalesce": true,
-                "template": ""
+                "template": "{% if object.master is defined and object.master %}{{ object.master }}{% else %}{{ object.hostname }}{% endif %}"
             }
         ],
         "relationship_maps": [
@@ -233,7 +233,7 @@
                 "source_field": "hostname",
                 "target_field": "vc_position",
                 "coalesce": false,
-                "template": "{% if object.virtual_chassis %}{{ object.virtual_chassis.member }}{% else %}None{% endif %}"
+                "template": "{% if object.virtual_chassis %}{% if object.virtual_chassis.member is defined and object.virtual_chassis.member %}{{ object.virtual_chassis.member }}{% else %}{{ object.virtual_chassis.chassisId }}{% endif %}{% else %}None{% endif %}"
             }
         ],
         "relationship_maps": [
@@ -244,7 +244,7 @@
                 },
                 "target_field": "virtual_chassis",
                 "coalesce": false,
-                "template": "{% if object.virtual_chassis %}{{ dcim.VirtualChassis.objects.filter(name=object.virtual_chassis.master).first().pk }}{% endif %}"
+                "template": "{% if object.virtual_chassis %}{% if object.virtual_chassis.master is defined and object.virtual_chassis.master %}{{ dcim.VirtualChassis.objects.filter(name=object.virtual_chassis.master).first().pk }}{% else %}{{ dcim.VirtualChassis.objects.filter(name=object.virtual_chassis.hostname).first().pk }}{% endif %}{% endif %}"
             },
             {
                 "source_model": {

ipfabric_netbox/forms.py

@@ -630,10 +630,10 @@ class IPFabricSyncForm(NetBoxModelForm):
         ),
     )
 
-    filters = forms.ModelMultipleChoiceField(
+    filters = DynamicModelMultipleChoiceField(
         queryset=IPFabricFilter.objects.all(),
+        label=_("Filters"),
         required=False,
-        widget=forms.SelectMultiple(),
     )
 
     update_custom_fields = forms.BooleanField(
@@ -773,8 +773,8 @@ class IPFabricSyncForm(NetBoxModelForm):
 
         # Prepare buttons for each target Model, order according to model hierarchy
         hierarchy = [
-            f"{m.app_label}.{m.model}"
-            for m in IPFabricSync.get_model_hierarchy(
+            f"{tm.target_model.app_label}.{tm.target_model.model}"
+            for tm in IPFabricSync.get_model_hierarchy(
                 group_ids=self.initial.get("groups", [])
             )
         ]
@@ -903,7 +903,12 @@ class IPFabricSyncForm(NetBoxModelForm):
                 ]
         self.instance.parameters = dict(sorted(parameters.items()))
         self.instance.status = IPFabricSyncStatusChoices.NEW
-        return super().save(*args, **kwargs)
+
+        instance = super().save(*args, **kwargs)
+        # M2M relationships need to be set after the instance is saved
+        # But only if they are set from the side where they are not defined on model
+        instance.filters.set(self.cleaned_data["filters"])
+        return instance
 
 
 class IPFabricSyncBulkEditForm(NetBoxModelBulkEditForm):

ipfabric_netbox/jobs.py

@@ -6,7 +6,12 @@ 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
+
+try:
+    # Got added in NetBox 4.4.9
+    from dcim.signals import sync_cached_scope_fields
+except ImportError:
+    sync_cached_scope_fields = None
 from django.db.models import signals
 from netbox.context_managers import event_tracking
 from rq.timeouts import JobTimeoutException
@@ -126,14 +131,16 @@ def merge_ipfabric_ingestion(job, remove_branch=False, *args, **kwargs):
                 signals.post_save.disconnect(
                     assign_virtualchassis_master, sender=VirtualChassis
                 )
-                signals.post_save.disconnect(sync_cached_scope_fields, sender=Site)
+                if sync_cached_scope_fields is not None:
+                    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 sync_cached_scope_fields is not None:
+                    signals.post_save.connect(sync_cached_scope_fields, sender=Site)
         if remove_branch:
             branching_branch = ingestion.branch
             ingestion.branch = None

ipfabric_netbox/migrations/0023_populate_filters_data.py

@@ -45,6 +45,7 @@ def migrate_source_model_to_endpoint(
     """Migrate IPFabricTransformMap source_model data to source_endpoint."""
     IPFabricTransformMap = apps.get_model("ipfabric_netbox", "IPFabricTransformMap")
     IPFabricEndpoint = apps.get_model("ipfabric_netbox", "IPFabricEndpoint")
+    ContentType = apps.get_model("contenttypes", "ContentType")
 
     source_model_to_endpoint = {
         "site": "/inventory/sites/overview",
@@ -69,6 +70,15 @@ def migrate_source_model_to_endpoint(
     ).all():
         endpoint_value = source_model_to_endpoint.get(transform_map.source_model)
 
+        # Special case: source_model="device" with target_model="dcim.virtualchassis"
+        # should map to /technology/platforms/stack/members, not /inventory/devices
+        if transform_map.source_model == "device" and transform_map.target_model:
+            virtualchassis_ct = ContentType.objects.using(
+                schema_editor.connection.alias
+            ).get(app_label="dcim", model="virtualchassis")
+            if transform_map.target_model_id == virtualchassis_ct.id:
+                endpoint_value = "/technology/platforms/stack/members"
+
         # If no mapping exists, use fallback and mark the name for manual fix
         if not endpoint_value:
             if not transform_map.name.startswith("[NEEDS CORRECTION]"):
@@ -97,6 +107,7 @@ def migrate_endpoint_to_source_model(
     """Reverse migration: migrate IPFabricTransformMap source_endpoint data back to source_model."""
     IPFabricTransformMap = apps.get_model("ipfabric_netbox", "IPFabricTransformMap")
     IPFabricEndpoint = apps.get_model("ipfabric_netbox", "IPFabricEndpoint")
+    ContentType = apps.get_model("contenttypes", "ContentType")
 
     endpoint_to_source_model = {
         "/inventory/sites/overview": "site",
@@ -122,6 +133,19 @@ def migrate_endpoint_to_source_model(
                 schema_editor.connection.alias
             ).get(pk=transform_map.source_endpoint_id)
             source_model_value = endpoint_to_source_model.get(endpoint.endpoint)
+
+            # Special case: source_endpoint="/technology/platforms/stack/members" with
+            # target_model="dcim.virtualchassis" should map back to source_model="device"
+            if (
+                endpoint.endpoint == "/technology/platforms/stack/members"
+                and transform_map.target_model
+            ):
+                virtualchassis_ct = ContentType.objects.using(
+                    schema_editor.connection.alias
+                ).get(app_label="dcim", model="virtualchassis")
+                if transform_map.target_model_id == virtualchassis_ct.id:
+                    source_model_value = "device"
+
             transform_map.source_model = source_model_value
         except IPFabricEndpoint.DoesNotExist:
             pass

ipfabric_netbox/migrations/0025_add_vss_chassis_endpoint.py

@@ -0,0 +1,166 @@
+from typing import TYPE_CHECKING
+
+from django.db import migrations
+
+from ipfabric_netbox.utilities.endpoint import do_endpoint_change
+from ipfabric_netbox.utilities.endpoint import EndpointRecord
+from ipfabric_netbox.utilities.transform_map import do_change
+from ipfabric_netbox.utilities.transform_map import FieldRecord
+from ipfabric_netbox.utilities.transform_map import RelationshipRecord
+from ipfabric_netbox.utilities.transform_map import TransformMapRecord
+
+if TYPE_CHECKING:
+    from django.apps import apps as apps_type
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+ENDPOINTS = (
+    EndpointRecord(
+        name="Default VSS Chassis Endpoint",
+        description="",
+        endpoint="/technology/platforms/vss/chassis",
+    ),
+)
+
+TRANSFORM_MAP_CHANGES = (
+    TransformMapRecord(
+        source_endpoint="/technology/platforms/stack/members",
+        target_model="dcim.virtualchassis",
+        fields=(
+            FieldRecord(
+                source_field="master",
+                target_field="name",
+                old_template="",
+                new_template="{% if object.master is defined and object.master %}{{ object.master }}{% else %}{{ object.hostname }}{% endif %}",
+            ),
+        ),
+    ),
+    TransformMapRecord(
+        source_endpoint="/inventory/devices",
+        target_model="dcim.device",
+        fields=(
+            FieldRecord(
+                source_field="hostname",
+                target_field="vc_position",
+                old_template="{% if object.virtual_chassis %}{{ object.virtual_chassis.member }}{% else %}None{% endif %}",
+                new_template="{% if object.virtual_chassis %}{% if object.virtual_chassis.member is defined and object.virtual_chassis.member %}{{ object.virtual_chassis.member }}{% else %}{{ object.virtual_chassis.chassisId }}{% endif %}{% else %}None{% endif %}",
+            ),
+        ),
+        relationships=(
+            RelationshipRecord(
+                source_model="dcim.virtualchassis",
+                target_field="virtual_chassis",
+                old_template="{% if object.virtual_chassis %}{{ dcim.VirtualChassis.objects.filter(name=object.virtual_chassis.master).first().pk }}{% endif %}",
+                new_template="{% if object.virtual_chassis %}{% if object.virtual_chassis.master is defined and object.virtual_chassis.master %}{{ dcim.VirtualChassis.objects.filter(name=object.virtual_chassis.master).first().pk }}{% else %}{{ dcim.VirtualChassis.objects.filter(name=object.virtual_chassis.hostname).first().pk }}{% endif %}{% endif %}",
+            ),
+        ),
+    ),
+)
+
+
+def add_vss_chassis_endpoint(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """Add VSS chassis endpoint."""
+    do_endpoint_change(apps, schema_editor, ENDPOINTS, forward=True)
+
+
+def remove_vss_chassis_endpoint(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """Remove VSS chassis endpoint."""
+    do_endpoint_change(apps, schema_editor, ENDPOINTS, forward=False)
+
+
+def forward_transform_maps_change(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """Replace old template with updated version."""
+    do_change(apps, schema_editor, changes=TRANSFORM_MAP_CHANGES, forward=True)
+
+
+def revert_transform_maps_change(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """Revert template back to the previous exact template."""
+    do_change(apps, schema_editor, changes=TRANSFORM_MAP_CHANGES, forward=False)
+
+
+def add_vss_to_child_filter(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """Add VSS chassis endpoint to Default Child Devices Filter idempotently."""
+    IPFabricFilter = apps.get_model("ipfabric_netbox", "IPFabricFilter")
+    IPFabricEndpoint = apps.get_model("ipfabric_netbox", "IPFabricEndpoint")
+
+    # Get the filter
+    try:
+        child_filter = IPFabricFilter.objects.using(schema_editor.connection.alias).get(
+            name="Default Child Devices Filter"
+        )
+    except IPFabricFilter.DoesNotExist:
+        # Filter doesn't exist, nothing to update
+        return
+
+    # Get the VSS chassis endpoint
+    try:
+        vss_endpoint = IPFabricEndpoint.objects.using(
+            schema_editor.connection.alias
+        ).get(endpoint="/technology/platforms/vss/chassis")
+    except IPFabricEndpoint.DoesNotExist:
+        # Endpoint doesn't exist yet, skip (will be created by add_vss_chassis_endpoint)
+        return
+
+    # Add the endpoint to the filter if not already present
+    if not child_filter.endpoints.filter(pk=vss_endpoint.pk).exists():
+        child_filter.endpoints.add(vss_endpoint)
+
+
+def remove_vss_from_child_filter(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    """Remove VSS chassis endpoint from Default Child Devices Filter."""
+    IPFabricFilter = apps.get_model("ipfabric_netbox", "IPFabricFilter")
+    IPFabricEndpoint = apps.get_model("ipfabric_netbox", "IPFabricEndpoint")
+
+    # Get the filter
+    try:
+        child_filter = IPFabricFilter.objects.using(schema_editor.connection.alias).get(
+            name="Default Child Devices Filter"
+        )
+    except IPFabricFilter.DoesNotExist:
+        # Filter doesn't exist, nothing to update
+        return
+
+    # Get the VSS chassis endpoint
+    try:
+        vss_endpoint = IPFabricEndpoint.objects.using(
+            schema_editor.connection.alias
+        ).get(endpoint="/technology/platforms/vss/chassis")
+    except IPFabricEndpoint.DoesNotExist:
+        # Endpoint doesn't exist, nothing to remove
+        return
+
+    # Remove the endpoint from the filter if present
+    if child_filter.endpoints.filter(pk=vss_endpoint.pk).exists():
+        child_filter.endpoints.remove(vss_endpoint)
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("ipfabric_netbox", "0024_finish_filters"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            add_vss_chassis_endpoint,
+            remove_vss_chassis_endpoint,
+        ),
+        migrations.RunPython(
+            forward_transform_maps_change,
+            revert_transform_maps_change,
+        ),
+        migrations.RunPython(
+            add_vss_to_child_filter,
+            remove_vss_from_child_filter,
+        ),
+    ]

ipfabric_netbox/models.py

@@ -300,17 +300,19 @@ class IPFabricTransformMap(NetBoxModel):
         qs = IPFabricTransformMap.objects.filter(
             group=self.group,
             target_model_id=self.target_model_id,
+            source_endpoint_id=self.source_endpoint_id,
         )
         if self.pk:
             qs = qs.exclude(pk=self.pk)
         if qs.exists():
             err_msg = _(
-                f"A transform map with group '{self.group}' and target model '{self.target_model}' already exists."
+                f"A transform map with group '{self.group}', target model '{self.target_model}', and source endpoint '{self.source_endpoint}' already exists."
             )
             raise ValidationError(
                 {
                     "group": err_msg,
                     "target_model": err_msg,
+                    "source_endpoint": err_msg,
                 }
             )
 
@@ -412,7 +414,9 @@ class IPFabricTransformMap(NetBoxModel):
                 keys.update(
                     re.findall(r"object\.([a-zA-Z_0-9]+)(?=.*)", field.template)
                 )
-        return {k: source_data[k] for k in keys}
+        # FIXME: Make it raise KeyError when key is missing during IN-68
+        #  This is temporary hack to allow missing keys when syncing VSS
+        return {k: source_data.get(k) for k in keys}
 
     def get_context(self, source_data):
         new_data = deepcopy(source_data)
@@ -887,76 +891,91 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
         """
         Returns a queryset of IPFabricTransformMap objects that would be used by this sync,
         following group and default precedence logic.
+
+        Transform maps are unique by (target_model, source_endpoint) combination.
+        Groups have precedence: later groups override earlier groups and defaults.
         """
         default_maps = IPFabricTransformMap.objects.filter(group__isnull=True)
         group_ids = group_ids or []
-        maps_by_target = {tm.target_model_id: tm for tm in default_maps}
+
+        # Use composite key: (target_model_id, source_endpoint_id)
+        maps_by_composite_key = {
+            (tm.target_model_id, tm.source_endpoint_id): tm for tm in default_maps
+        }
+
         # Replace default maps with the ones from the groups, in given order.
         if group_ids:
             for group_id in group_ids:
                 group_maps = IPFabricTransformMap.objects.filter(group_id=group_id)
                 for tm in group_maps:
-                    maps_by_target[tm.target_model_id] = tm
+                    maps_by_composite_key[
+                        (tm.target_model_id, tm.source_endpoint_id)
+                    ] = tm
+
         return IPFabricTransformMap.objects.filter(
-            pk__in=[tm.pk for tm in maps_by_target.values()]
+            pk__in=[tm.pk for tm in maps_by_composite_key.values()]
         )
 
     @classmethod
-    def get_model_hierarchy(cls, group_ids=None) -> list[ContentType]:
+    def get_model_hierarchy(cls, group_ids=None) -> list["IPFabricTransformMap"]:
         """
-        Get target models from transform maps in hierarchical order.
+        Get transform maps in hierarchical order based on parent relationships.
         Uses topological sort (Kahn's algorithm) to support multiple parents.
-        Models without parents come first, then their children, etc.
+        Transform maps without parents come first, then their children, etc.
 
-        Example: IP Address has parents [Interface, VRF], so it will only be
-        processed after both Interface AND VRF have been processed.
+        Example: IP Address transform map has parents [Interface, VRF], so it will only be
+        processed after both Interface AND VRF transform maps have been processed.
+
+        Returns list of transform maps ordered by dependencies.
         """
         maps = cls.get_transform_maps(group_ids)
 
-        # Build adjacency list and in-degree count
-        graph = {}  # parent_ct -> [child_ct, ...]
-        in_degree = {}  # ct -> count of unprocessed parents
-        ct_to_map = {}  # ct -> transform_map (for reference)
+        # Build adjacency list and in-degree count using transform map IDs
+        graph = {}  # parent_tm_id -> [child_tm_id, ...]
+        in_degree = {}  # tm_id -> count of unprocessed parents
+        tm_by_id = {}  # tm_id -> transform_map
 
         for transform_map in maps:
-            ct = transform_map.target_model
-            ct_to_map[ct] = transform_map
+            tm_id = transform_map.id
+            tm_by_id[tm_id] = transform_map
 
             # Get all parents for this transform map
             parent_maps = transform_map.parents.all()
 
             # Set in-degree (number of parents)
-            in_degree[ct] = parent_maps.count()
+            in_degree[tm_id] = parent_maps.count()
 
             # Build adjacency list (parent -> children)
             for parent_map in parent_maps:
-                parent_ct = parent_map.target_model
-                graph.setdefault(parent_ct, []).append(ct)
+                parent_id = parent_map.id
+                graph.setdefault(parent_id, []).append(tm_id)
 
         # Topological sort using Kahn's algorithm (BFS-based)
-        queue = [ct for ct, degree in in_degree.items() if degree == 0]
+        queue = [tm_id for tm_id, degree in in_degree.items() if degree == 0]
         ordered = []
 
         while queue:
             # Pop from front to maintain BFS/level-order
-            current_ct = queue.pop(0)
-            ordered.append(current_ct)
+            current_tm_id = queue.pop(0)
+            ordered.append(current_tm_id)
 
             # Reduce in-degree for all children
-            for child_ct in graph.get(current_ct, []):
-                in_degree[child_ct] -= 1
-                if in_degree[child_ct] == 0:
-                    queue.append(child_ct)
+            for child_tm_id in graph.get(current_tm_id, []):
+                in_degree[child_tm_id] -= 1
+                if in_degree[child_tm_id] == 0:
+                    queue.append(child_tm_id)
 
         # Check for circular dependencies
         if len(ordered) != len(in_degree):
-            unprocessed = set(in_degree.keys()) - set(ordered)
+            unprocessed_ids = set(in_degree.keys()) - set(ordered)
+            unprocessed_maps = [tm_by_id[tm_id] for tm_id in unprocessed_ids]
             raise ValidationError(
                 f"Circular dependency detected in transform map hierarchy. "
-                f"Unprocessed models: {', '.join(str(ct) for ct in unprocessed)}"
+                f"Unprocessed maps: {', '.join(str(tm) for tm in unprocessed_maps)}"
             )
 
-        return ordered
+        # Return ordered list of transform maps
+        return [tm_by_id[tm_id] for tm_id in ordered]
 
     def delete_scheduled_jobs(self) -> None:
         Job.objects.filter(
@@ -1239,6 +1258,30 @@ class IPFabricIngestion(JobsMixin, models.Model):
                     statistics[model] = stats["current"] / stats["total"] * 100
                 else:
                     statistics[model] = stats["current"] / 1 * 100
+
+        # Sort statistics according to transform map hierarchy
+        # This ensures consistent ordering in the progress display matching sync order
+        try:
+            group_ids = self.sync.parameters.get("groups", [])
+            transform_maps = self.sync.get_model_hierarchy(group_ids=group_ids)
+
+            # Create ordered dict following the hierarchy
+            ordered_statistics = {}
+            for transform_map in transform_maps:
+                model_string = f"{transform_map.target_model.app_label}.{transform_map.target_model.model}"
+                if model_string in statistics:
+                    ordered_statistics[model_string] = statistics[model_string]
+
+            # Add any remaining statistics that weren't in the hierarchy
+            for model_string, value in statistics.items():
+                if model_string not in ordered_statistics:
+                    ordered_statistics[model_string] = value
+
+            statistics = ordered_statistics
+        except Exception:
+            # If hierarchy ordering fails, fall back to alphabetical sorting
+            statistics = dict(sorted(statistics.items()))
+
         return {"job_results": job_results, "statistics": statistics}
 
     def sync_merge(self):

ipfabric_netbox/templatetags/ipfabric_netbox_helpers.py

@@ -45,10 +45,13 @@ def sort_parameters_hierarchical(
     try:
         group_ids = parameters_dict.get("groups", [])
 
-        # Get the hierarchical model order from IPFabricSync
-        model_hierarchy = sync_obj.__class__.get_model_hierarchy(group_ids)
-        # Convert ContentType objects to app_label.model format
-        hierarchy_order = [f"{ct.app_label}.{ct.model}" for ct in model_hierarchy]
+        # Get the hierarchical model order from IPFabricSync (returns transform maps)
+        transform_maps = sync_obj.__class__.get_model_hierarchy(group_ids)
+        # Convert transform maps to app_label.model format
+        hierarchy_order = [
+            f"{tm.target_model.app_label}.{tm.target_model.model}"
+            for tm in transform_maps
+        ]
 
         # Group models by app label while maintaining hierarchical order
         app_models = OrderedDict()