ipfabric_netbox 4.0.1__tar.gz → 4.0.1b1__tar.gz

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ipfabric_netbox
-Version: 4.0.1
+Version: 4.0.1b1
 Summary: NetBox plugin to sync IP Fabric data into NetBox
 License: MIT
 Keywords: netbox,ipfabric,plugin,sync

ipfabric_netbox-4.0.1b1/ipfabric_netbox/__init__.py

@@ -0,0 +1,25 @@
+from django.db.models.signals import post_delete
+from netbox.plugins import PluginConfig
+
+
+class NetboxIPFabricConfig(PluginConfig):
+    name = "ipfabric_netbox"
+    verbose_name = "NetBox IP Fabric SoT Plugin"
+    description = "Sync IP Fabric into NetBox"
+    version = "4.0.1b1"
+    base_url = "ipfabric"
+    min_version = "4.2.4"
+
+    def ready(self):
+        super().ready()
+
+        from ipfabric_netbox.signals import remove_group_from_syncs
+
+        post_delete.connect(
+            remove_group_from_syncs,
+            sender="ipfabric_netbox.IPFabricTransformMapGroup",
+            dispatch_uid="remove_group_from_syncs",
+        )
+
+
+config = NetboxIPFabricConfig

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/api/serializers.py

@@ -15,6 +15,7 @@ from ipfabric_netbox.models import IPFabricSource
 from ipfabric_netbox.models import IPFabricSync
 from ipfabric_netbox.models import IPFabricTransformField
 from ipfabric_netbox.models import IPFabricTransformMap
+from ipfabric_netbox.models import IPFabricTransformMapGroup
 
 __all__ = (
     "IPFabricSyncSerializer",
@@ -89,6 +90,18 @@ class IPFabricRelationshipFieldSerializer(NetBoxModelSerializer):
         ]
 
 
+class IPFabricTransformMapGroupSerializer(NetBoxModelSerializer):
+    class Meta:
+        model = IPFabricTransformMapGroup
+        fields = [
+            "name",
+            "description",
+            "transform_maps",
+            "created",
+            "last_updated",
+        ]
+
+
 class IPFabricTransformMapSerializer(NetBoxModelSerializer):
     target_model = ContentTypeField(read_only=True)
 

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/api/urls.py

@@ -7,12 +7,14 @@ from ipfabric_netbox.api.views import IPFabricSnapshotViewSet
 from ipfabric_netbox.api.views import IPFabricSourceViewSet
 from ipfabric_netbox.api.views import IPFabricSyncViewSet
 from ipfabric_netbox.api.views import IPFabricTransformFieldiewSet
+from ipfabric_netbox.api.views import IPFabricTransformMapGroupViewSet
 from ipfabric_netbox.api.views import IPFabricTransformMapViewSet
 
 
 router = NetBoxRouter()
 router.register("source", IPFabricSourceViewSet)
 router.register("snapshot", IPFabricSnapshotViewSet)
+router.register("transform-map-group", IPFabricTransformMapGroupViewSet)
 router.register("transform-map", IPFabricTransformMapViewSet)
 router.register("sync", IPFabricSyncViewSet)
 router.register("ingestion", IPFabricIngestionViewSet)

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/api/views.py

@@ -11,6 +11,7 @@ from .serializers import IPFabricSnapshotSerializer
 from .serializers import IPFabricSourceSerializer
 from .serializers import IPFabricSyncSerializer
 from .serializers import IPFabricTransformFieldSerializer
+from .serializers import IPFabricTransformMapGroupSerializer
 from .serializers import IPFabricTransformMapSerializer
 from ipfabric_netbox.filtersets import IPFabricSnapshotFilterSet
 from ipfabric_netbox.filtersets import IPFabricSourceFilterSet
@@ -23,6 +24,12 @@ from ipfabric_netbox.models import IPFabricSource
 from ipfabric_netbox.models import IPFabricSync
 from ipfabric_netbox.models import IPFabricTransformField
 from ipfabric_netbox.models import IPFabricTransformMap
+from ipfabric_netbox.models import IPFabricTransformMapGroup
+
+
+class IPFabricTransformMapGroupViewSet(NetBoxReadOnlyModelViewSet):
+    queryset = IPFabricTransformMapGroup.objects.all()
+    serializer_class = IPFabricTransformMapGroupSerializer
 
 
 class IPFabricTransformMapViewSet(NetBoxReadOnlyModelViewSet):

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/choices.py

@@ -142,6 +142,23 @@ transform_field_source_columns = {
     ],
 }
 
+required_transform_map_contenttypes = [
+    ("dcim", "site"),
+    ("dcim", "manufacturer"),
+    ("dcim", "platform"),
+    ("dcim", "devicerole"),
+    ("dcim", "devicetype"),
+    ("dcim", "device"),
+    ("dcim", "virtualchassis"),
+    ("dcim", "interface"),
+    ("dcim", "macaddress"),
+    ("ipam", "vlan"),
+    ("ipam", "vrf"),
+    ("ipam", "prefix"),
+    ("ipam", "ipaddress"),
+    ("dcim", "inventoryitem"),
+]
+
 
 class IPFabricTransformMapSourceModelChoices(ChoiceSet):
     SITE = "site"

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/filtersets.py

@@ -14,6 +14,7 @@ from .models import IPFabricSnapshot
 from .models import IPFabricSource
 from .models import IPFabricSync
 from .models import IPFabricTransformMap
+from .models import IPFabricTransformMapGroup
 
 
 class IPFabricIngestionChangeFilterSet(BaseFilterSet):
@@ -121,6 +122,43 @@ class IPFabricIngestionFilterSet(BaseFilterSet):
         )
 
 
+class IPFabricTransformMapGroupFilterSet(NetBoxModelFilterSet):
+    q = django_filters.CharFilter(method="search")
+
+    class Meta:
+        model = IPFabricTransformMapGroup
+        fields = ("id", "name", "description")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(name__icontains=value) | Q(description__icontains=value)
+        )
+
+
+class IPFabricTransformMapFilterSet(NetBoxModelFilterSet):
+    q = django_filters.CharFilter(method="search")
+    group_id = django_filters.ModelMultipleChoiceFilter(
+        queryset=IPFabricTransformMapGroup.objects.all(),
+        label=_("Transform Map Group (ID)"),
+    )
+    group = django_filters.ModelMultipleChoiceFilter(
+        queryset=IPFabricTransformMapGroup.objects.all(), label=_("Transform Map Group")
+    )
+
+    class Meta:
+        model = IPFabricTransformMap
+        fields = ("id", "name", "group", "source_model", "target_model")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(group__name__icontains=value) | Q(name__icontains=value)
+        )
+
+
 class IPFabricTransformFieldFilterSet(BaseFilterSet):
     transform_map = django_filters.ModelMultipleChoiceFilter(
         queryset=IPFabricTransformMap.objects.all(), label=_("Transform Map")

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/forms.py

@@ -3,6 +3,7 @@ import copy
 from core.choices import DataSourceStatusChoices
 from core.choices import JobIntervalChoices
 from django import forms
+from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
@@ -24,6 +25,7 @@ from utilities.forms.widgets import HTMXSelect
 from utilities.forms.widgets import NumberWithOptions
 
 from .choices import IPFabricSnapshotStatusModelChoices
+from .choices import required_transform_map_contenttypes
 from .choices import transform_field_source_columns
 from .models import IPFabricIngestion
 from .models import IPFabricRelationshipField
@@ -32,6 +34,7 @@ from .models import IPFabricSource
 from .models import IPFabricSync
 from .models import IPFabricTransformField
 from .models import IPFabricTransformMap
+from .models import IPFabricTransformMapGroup
 
 
 exclude_fields = [
@@ -274,15 +277,45 @@ class IPFabricTransformFieldForm(NetBoxModelForm):
                     )
 
 
+class IPFabricTransformMapGroupForm(forms.ModelForm):
+    class Meta:
+        model = IPFabricTransformMapGroup
+        fields = ("name", "description")
+
+
 class IPFabricTransformMapForm(forms.ModelForm):
     class Meta:
         model = IPFabricTransformMap
-        fields = ("name", "source_model", "target_model")
+        fields = ("name", "group", "source_model", "target_model")
         widgets = {
             "target_model": HTMXSelect(hx_url="/plugins/ipfabric/transform-map/add"),
         }
 
 
+class IPFabricTransformMapCloneForm(forms.Form):
+    name = forms.CharField(
+        required=True, label="Name", help_text="Name for the cloned transform map."
+    )
+    group = forms.ModelChoiceField(
+        queryset=IPFabricTransformMapGroup.objects.all(),
+        required=False,
+        label="Target Group",
+        help_text="Select the group to assign the cloned transform map to.",
+    )
+    clone_fields = forms.BooleanField(
+        required=False,
+        initial=True,
+        label="Clone Child Fields",
+        help_text="Clone all child fields of this transform map.",
+    )
+    clone_relationships = forms.BooleanField(
+        required=False,
+        initial=True,
+        label="Clone Child Relationships",
+        help_text="Clone all child relationships of this transform map.",
+    )
+
+
 class IPFabricSnapshotFilterForm(NetBoxModelFilterSetForm):
     model = IPFabricSnapshot
     fieldsets = (
@@ -413,6 +446,19 @@ class IPFabricSourceForm(NetBoxModelForm):
         return instance
 
 
+class OrderedModelMultipleChoiceField(forms.ModelMultipleChoiceField):
+    """A ModelMultipleChoiceField that preserves the order of the selected items."""
+
+    def clean(self, value):
+        qs = super().clean(value)
+        clauses = " ".join(
+            ["WHEN id=%s THEN %s" % (pk, i) for i, pk in enumerate(value)]
+        )
+        return qs.filter(pk__in=value).extra(
+            select={"ordering": "CASE %s END" % clauses}, order_by=("ordering",)
+        )
+
+
 class IPFabricSyncForm(NetBoxModelForm):
     source = forms.ModelChoiceField(
         queryset=IPFabricSource.objects.all(),
@@ -420,6 +466,15 @@ class IPFabricSyncForm(NetBoxModelForm):
         label=_("IP Fabric Source"),
         widget=HTMXSelect(),
     )
+    groups = OrderedModelMultipleChoiceField(
+        queryset=IPFabricTransformMapGroup.objects.all(),
+        required=False,
+        label=_("Transform Map Groups"),
+        widget=forms.SelectMultiple(attrs={"class": "form-control"}),
+        help_text=_(
+            "Prioritize transform maps by group in entered order for each NetBox model. Default maps will be used if no group is selected for given model."
+        ),
+    )
     snapshot_data = DynamicModelChoiceField(
         queryset=IPFabricSnapshot.objects.filter(status="loaded"),
         required=True,
@@ -478,7 +533,7 @@ class IPFabricSyncForm(NetBoxModelForm):
     @property
     def fieldsets(self):
         fieldsets = [
-            FieldSet("name", "source", name=_("IP Fabric Source")),
+            FieldSet("name", "source", "groups", name=_("IP Fabric Source")),
         ]
         if self.source_type == "local":
             fieldsets.append(
@@ -527,7 +582,8 @@ class IPFabricSyncForm(NetBoxModelForm):
                         self.instance.snapshot_data.sites
                     )
 
-                self.initial["sites"] = self.instance.parameters["sites"]
+                self.initial["sites"] = self.instance.parameters.get("sites", [])
+                self.initial["groups"] = self.instance.parameters.get("groups", [])
 
         backend_type = get_field_value(self, "type")
         backend = {}
@@ -571,6 +627,22 @@ class IPFabricSyncForm(NetBoxModelForm):
         if self.cleaned_data.get("interval") and not scheduled_time:
             self.cleaned_data["scheduled"] = local_now()
 
+        maps = IPFabricSync.get_transform_maps(self.cleaned_data.get("groups", []))
+        missing = []
+        for app_label, model in required_transform_map_contenttypes:
+            if not maps.filter(
+                target_model=ContentType.objects.get(app_label=app_label, model=model)
+            ):
+                missing.append(f"{app_label}.{model}")
+        if missing:
+            raise ValidationError(
+                {
+                    "groups": _(
+                        f"Combination of these transform map groups failed validation. Missing maps: {missing}."
+                    )
+                }
+            )
+
         return self.cleaned_data
 
     def save(self, *args, **kwargs):
@@ -580,6 +652,10 @@ class IPFabricSyncForm(NetBoxModelForm):
                 parameters[name[4:]] = self.cleaned_data[name]
             if name == "sites":
                 parameters["sites"] = self.cleaned_data["sites"]
+            if name == "groups":
+                parameters["groups"] = [
+                    group.pk for group in self.cleaned_data["groups"]
+                ]
         self.instance.parameters = parameters
         self.instance.status = DataSourceStatusChoices.NEW
 

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/migrations/0001_initial_squashed_0013_switch_to_branching_plugin.py

@@ -109,7 +109,7 @@ 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())
+    build_transform_maps(data=get_transform_map(), apps=apps)
 
 
 class Migration(migrations.Migration):

ipfabric_netbox-4.0.1b1/ipfabric_netbox/migrations/0014_ipfabrictransformmapgroup_ipfabrictransformmap_group.py

@@ -0,0 +1,65 @@
+# Generated by Django 5.2 on 2025-05-26 08:53
+import django.db.models.deletion
+import taggit.managers
+import utilities.json
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0128_tableconfig"),
+        ("ipfabric_netbox", "0001_initial_squashed_0013_switch_to_branching_plugin"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="IPFabricTransformMapGroup",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False
+                    ),
+                ),
+                ("created", models.DateTimeField(auto_now_add=True, null=True)),
+                ("last_updated", models.DateTimeField(auto_now=True, null=True)),
+                (
+                    "custom_field_data",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        encoder=utilities.json.CustomFieldJSONEncoder,
+                    ),
+                ),
+                ("name", models.CharField(max_length=100, unique=True)),
+                ("description", models.TextField(blank=True, null=True)),
+                (
+                    "tags",
+                    taggit.managers.TaggableManager(
+                        through="extras.TaggedItem", to="extras.Tag"
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "IP Fabric Transform Map Group",
+                "verbose_name_plural": "IP Fabric Transform Map Groups",
+            },
+        ),
+        migrations.AddField(
+            model_name="ipfabrictransformmap",
+            name="group",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="transform_maps",
+                to="ipfabric_netbox.ipfabrictransformmapgroup",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="ipfabrictransformmap",
+            name="name",
+            field=models.CharField(max_length=100),
+        ),
+    ]

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/models.py

@@ -18,6 +18,7 @@ from django.apps import apps
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.cache import cache
+from django.core.exceptions import ValidationError
 from django.core.validators import MinValueValidator
 from django.db import models
 from django.db import transaction
@@ -45,6 +46,7 @@ from .choices import IPFabricSnapshotStatusModelChoices
 from .choices import IPFabricSourceTypeChoices
 from .choices import IPFabricSyncTypeChoices
 from .choices import IPFabricTransformMapSourceModelChoices
+from .choices import required_transform_map_contenttypes
 from .signals import clear_other_primary_ip
 from .utilities.ipfutils import IPFabric
 from .utilities.ipfutils import IPFabricSyncRunner
@@ -94,8 +96,25 @@ IPFabricRelationshipFieldSourceModels = Q(
 )
 
 
-class IPFabricTransformMap(NetBoxModel):
+class IPFabricTransformMapGroup(NetBoxModel):
     name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+
+    class Meta:
+        verbose_name = "IP Fabric Transform Map Group"
+        verbose_name_plural = "IP Fabric Transform Map Groups"
+
+    def __str__(self):
+        return self.name
+
+    def get_absolute_url(self):
+        return reverse(
+            "plugins:ipfabric_netbox:ipfabrictransformmapgroup", args=[self.pk]
+        )
+
+
+class IPFabricTransformMap(NetBoxModel):
+    name = models.CharField(max_length=100)
     source_model = models.CharField(
         max_length=50, choices=IPFabricTransformMapSourceModelChoices
     )
@@ -109,6 +128,13 @@ class IPFabricTransformMap(NetBoxModel):
         blank=False,
         null=False,
     )
+    group = models.ForeignKey(
+        to=IPFabricTransformMapGroup,
+        on_delete=models.CASCADE,
+        related_name="transform_maps",
+        blank=True,
+        null=True,
+    )
 
     class Meta:
         verbose_name = "IP Fabric Transform Map"
@@ -128,6 +154,26 @@ class IPFabricTransformMap(NetBoxModel):
         # TODO: Add docs url
         return ""
 
+    def clean(self):
+        cleaned_data = super().clean()
+        qs = IPFabricTransformMap.objects.filter(
+            group=self.group,
+            target_model_id=self.target_model_id,
+        )
+        if self.pk:
+            qs = qs.exclude(pk=self.pk)
+        if qs.exists():
+            err_msg = _(
+                "A transform map with this group and target model already exists."
+            )
+            raise ValidationError(
+                {
+                    "group": err_msg,
+                    "target_model": err_msg,
+                }
+            )
+        return cleaned_data
+
     def get_models(self):
         _context = dict()
 
@@ -333,12 +379,9 @@ class IPFabricTransformField(models.Model):
 
 
 class IPFabricClient:
-    def get_client(self, parameters, transform_map=None):
+    def get_client(self, parameters):
         try:
-            if transform_map:
-                ipf = IPFabric(parameters=parameters, transform_map=transform_map)
-            else:
-                ipf = IPFabric(parameters=parameters)
+            ipf = IPFabric(parameters=parameters)
             return ipf.ipf
         except httpx.ConnectError as e:
             if "CERTIFICATE_VERIFY_FAILED" in str(e):
@@ -623,6 +666,25 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
         else:
             return False
 
+    @staticmethod
+    def get_transform_maps(group_ids=None):
+        """
+        Returns a queryset of IPFabricTransformMap objects that would be used by this sync,
+        following group and default precedence logic.
+        """
+        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}
+        # 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
+        return IPFabricTransformMap.objects.filter(
+            pk__in=[tm.pk for tm in maps_by_target.values()]
+        )
+
     def enqueue_sync_job(self, adhoc=False, user=None):
         # Set the status to "syncing"
         self.status = DataSourceStatusChoices.QUEUED
@@ -666,6 +728,22 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
             self.logger = SyncLogging(job=self.pk)
             user = None
 
+        maps = self.get_transform_maps(self.parameters.get("groups", []))
+        missing = []
+        for app_label, model in required_transform_map_contenttypes:
+            if not maps.filter(
+                target_model=ContentType.objects.get(app_label=app_label, model=model)
+            ):
+                missing.append(f"{app_label}.{model}")
+        if missing:
+            self.logger.log_failure(
+                f"Combination of these transform map groups failed validation. Missing maps: {missing}.",
+                obj=self,
+            )
+            raise SyncError(
+                f"Combination of these transform map groups failed validation. Missing maps: {missing}."
+            )
+
         if self.status == DataSourceStatusChoices.SYNCING:
             raise SyncError("Cannot initiate sync; ingestion already in progress.")
 
@@ -714,10 +792,7 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
             logger.info("Fetching IP Fabric Client")
 
             if self.snapshot_data.source.type == IPFabricSourceTypeChoices.LOCAL:
-                ipf = self.get_client(
-                    parameters=self.snapshot_data.source.parameters,
-                    transform_map=IPFabricTransformMap,
-                )
+                ipf = self.get_client(parameters=self.snapshot_data.source.parameters)
                 if not ipf:
                     logger.debug("Unable to connect to IP Fabric.")
                     raise SyncError("Unable to connect to IP Fabric.")
@@ -728,7 +803,6 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
                 client=ipf,
                 ingestion=ingestion,
                 settings=self.parameters,
-                transform_map=IPFabricTransformMap,
                 sync=self,
             )
 

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/navigation.py

@@ -42,6 +42,20 @@ ingestion = PluginMenuItem(
     permissions=["ipfabric_netbox.view_ipfabricsync"],
 )
 
+tmg = PluginMenuItem(
+    link="plugins:ipfabric_netbox:ipfabrictransformmapgroup_list",
+    link_text="Transform Map Groups",
+    permissions=["ipfabric_netbox.view_ipfabrictransformmapgroup"],
+    buttons=[
+        PluginMenuButton(
+            link="plugins:ipfabric_netbox:ipfabrictransformmapgroup_add",
+            title="Add",
+            icon_class="mdi mdi-plus-thick",
+            permissions=["ipfabric_netbox.add_ipfabrictransformmapgroup"],
+        )
+    ],
+)
+
 tm = PluginMenuItem(
     link="plugins:ipfabric_netbox:ipfabrictransformmap_list",
     link_text="Transform Maps",
@@ -58,5 +72,5 @@ tm = PluginMenuItem(
 menu = PluginMenu(
     label="IP Fabric",
     icon_class="mdi mdi-cloud-sync",
-    groups=(("IP Fabric", (source, snapshot, ingestion, tm)),),
+    groups=(("IP Fabric", (source, snapshot, ingestion, tmg, tm)),),
 )

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/signals.py

@@ -34,3 +34,20 @@ def clear_other_primary_ip(instance: Device, **kwargs) -> None:
             other_device.save(using=connection_name)
     except Device.DoesNotExist:
         pass
+
+
+def remove_group_from_syncs(instance, **kwargs):
+    """
+    When an IPFabricTransformMapGroup is deleted, remove its ID from any IPFabricSync.parameters['groups'] list.
+    """
+    from ipfabric_netbox.models import IPFabricSync
+
+    group_id = instance.pk
+    for sync in IPFabricSync.objects.all():
+        params = sync.parameters or {}
+        groups = params.get("groups", [])
+        if group_id not in groups:
+            continue
+        params["groups"] = [gid for gid in groups if gid != group_id]
+        sync.parameters = params
+        sync.save()

{ipfabric_netbox-4.0.1 → ipfabric_netbox-4.0.1b1}/ipfabric_netbox/tables.py

@@ -14,6 +14,7 @@ from .models import IPFabricSource
 from .models import IPFabricSync
 from .models import IPFabricTransformField
 from .models import IPFabricTransformMap
+from .models import IPFabricTransformMapGroup
 
 
 DIFF_BUTTON = """
@@ -60,13 +61,28 @@ class IPFabricTransformFieldTable(NetBoxTable):
         default_columns = ("source_field", "target_field", "coalesce", "actions")
 
 
+class IPFabricTransformMapGroupTable(NetBoxTable):
+    name = tables.Column(linkify=True)
+    maps_count = columns.LinkedCountColumn(
+        viewname="plugins:ipfabric_netbox:ipfabrictransformmap_list",
+        url_params={"group_id": "pk"},
+        verbose_name="Transform Maps",
+    )
+
+    class Meta(NetBoxTable.Meta):
+        model = IPFabricTransformMapGroup
+        fields = ("name", "description", "maps_count")
+        default_columns = ("name", "description", "maps_count")
+
+
 class IPFabricTransformMapTable(NetBoxTable):
     name = tables.Column(linkify=True)
+    group = tables.Column(linkify=True)
 
     class Meta(NetBoxTable.Meta):
         model = IPFabricTransformMap
-        fields = ("name", "source_model", "target_model")
-        default_columns = ("name", "source_model", "target_model")
+        fields = ("name", "group", "source_model", "target_model")
+        default_columns = ("name", "group", "source_model", "target_model")
 
 
 class IPFabricIngestionTable(NetBoxTable):