ipfabric_netbox 3.1.3__py3-none-any.whl → 3.2.1__py3-none-any.whl

ipfabric_netbox/forms.py

@@ -1,16 +1,15 @@
 import copy
 
 from core.choices import DataSourceStatusChoices
+from core.choices import JobIntervalChoices
 from django import forms
-from django.conf import settings
 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 _
-from extras.choices import DurationChoices
 from netbox.forms import NetBoxModelFilterSetForm
 from netbox.forms import NetBoxModelForm
-from packaging import version
+from netbox.forms.mixins import SavedFiltersMixin
 from utilities.datetime import local_now
 from utilities.forms import add_blank_choice
 from utilities.forms import FilterForm
@@ -34,12 +33,6 @@ from .models import IPFabricSync
 from .models import IPFabricTransformField
 from .models import IPFabricTransformMap
 
-NETBOX_CURRENT_VERSION = version.parse(settings.VERSION)
-
-if NETBOX_CURRENT_VERSION >= version.parse("3.7.0"):
-    from netbox.forms.mixins import SavedFiltersMixin
-else:
-    from extras.forms.mixins import SavedFiltersMixin
 
 exclude_fields = [
     "id",
@@ -83,6 +76,7 @@ dcim_parameters = {
         required=False, label=_("Virtual Chassis"), initial=True
     ),
     "interface": forms.BooleanField(required=False, label=_("Interfaces")),
+    "macaddress": forms.BooleanField(required=False, label=_("MAC Addresses")),
     "inventoryitem": forms.BooleanField(required=False, label=_("Part Numbers")),
 }
 ipam_parameters = {
@@ -482,7 +476,7 @@ class IPFabricSyncForm(NetBoxModelForm):
         required=False,
         min_value=1,
         label=_("Recurs every"),
-        widget=NumberWithOptions(options=DurationChoices),
+        widget=NumberWithOptions(options=JobIntervalChoices),
         help_text=_("Interval at which this sync is re-run (in minutes)"),
     )
     auto_merge = forms.BooleanField(

ipfabric_netbox/migrations/0007_prepare_custom_fields.py

@@ -0,0 +1,102 @@
+from typing import TYPE_CHECKING
+
+from django.db import migrations
+from extras.choices import CustomFieldTypeChoices
+from extras.choices import CustomFieldUIEditableChoices
+from extras.choices import CustomFieldUIVisibleChoices
+from extras.choices import CustomLinkButtonClassChoices
+
+
+if TYPE_CHECKING:
+    from django.apps import apps
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+
+def create_custom_field(
+    apps: "apps",
+    field_name: str,
+    label: str,
+    models: list,
+    object_type=None,
+    cf_type: str | None = "type_text",
+):
+    """Create a single custom field and link it to required models."""
+    ObjectType = apps.get_model("core", "ObjectType")
+
+    defaults = {
+        "label": label,
+        "related_object_type": ObjectType.objects.get_for_model(object_type)
+        if object_type
+        else None,
+        "ui_visible": getattr(CustomFieldUIVisibleChoices, "ALWAYS"),
+        "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,
+    )
+
+    for model in models:
+        custom_field.object_types.add(ObjectType.objects.get_for_model(model))
+
+
+def prepare_custom_fields(apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"):
+    """Forward migration to prepare ipfabric_netbox custom fields and links."""
+    Device = apps.get_model("dcim", "Device")
+    Site = apps.get_model("dcim", "Site")
+
+    create_custom_field(
+        apps,
+        "ipfabric_source",
+        "IP Fabric Source",
+        [Device, Site],
+        cf_type="type_object",
+        object_type=apps.get_model("ipfabric_netbox", "IPFabricSource"),
+    )
+    create_custom_field(
+        apps,
+        "ipfabric_branch",
+        "IP Fabric Last Sync",
+        [Device, Site],
+        cf_type="type_object",
+        object_type=apps.get_model("ipfabric_netbox", "IPFabricBranch"),
+    )
+    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.object_types.add(
+        apps.get_model("core", "ObjectType").objects.get_for_model(Device)
+    )
+
+
+def cleanup_custom_fields(apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"):
+    """Reverse migration to prepare ipfabric_netbox custom fields and links."""
+    for custom_field_name in ["ipfabric_source", "ipfabric_branch"]:
+        custom_field = apps.get_model("extras", "CustomField").objects.get(
+            name=custom_field_name
+        )
+        for model in custom_field.object_types.all()[:]:
+            custom_field.object_types.remove(model)
+        custom_field.delete()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("dcim", "0191_module_bay_rebuild"),
+        ("extras", "0121_customfield_related_object_filter"),
+        (
+            "ipfabric_netbox",
+            "0006_alter_ipfabrictransformmap_target_model",
+        ),
+    ]
+    operations = [
+        migrations.RunPython(prepare_custom_fields, cleanup_custom_fields),
+    ]

ipfabric_netbox/migrations/0008_prepare_transform_maps.py

@@ -0,0 +1,42 @@
+from typing import TYPE_CHECKING
+
+from django.db import migrations
+
+from ipfabric_netbox.utilities.transform_map import build_transform_maps
+from ipfabric_netbox.utilities.transform_map import get_transform_map
+
+
+if TYPE_CHECKING:
+    from django.apps import apps
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+
+def prepare_transform_maps(apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"):
+    """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.
+    """
+    if apps.get_model("ipfabric_netbox", "IPFabricTransformMap").objects.count() == 0:
+        build_transform_maps(data=get_transform_map())
+
+
+def cleanup_transform_maps(apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"):
+    """Delete all transform maps."""
+    # IPFabricTransformField and IPFabricRelationshipField are deleted by CASCADE
+    apps.get_model("ipfabric_netbox", "IPFabricTransformMap").objects.all().delete()
+
+
+class Migration(migrations.Migration):
+    # Depend on all models that are used in transform maps
+    dependencies = [
+        ("core", "0012_job_object_type_optional"),
+        ("dcim", "0191_module_bay_rebuild"),
+        ("extras", "0121_customfield_related_object_filter"),
+        ("ipam", "0070_vlangroup_vlan_id_ranges"),
+        (
+            "ipfabric_netbox",
+            "0007_prepare_custom_fields",
+        ),
+    ]
+    operations = [
+        migrations.RunPython(prepare_transform_maps, cleanup_transform_maps),
+    ]

ipfabric_netbox/migrations/0009_transformmap_changes_for_netbox_v4_2.py

@@ -0,0 +1,224 @@
+import contextlib
+import re
+from typing import TYPE_CHECKING
+
+import django.db.models.deletion
+from django.db import migrations
+from django.db import models
+
+from ipfabric_netbox.utilities.transform_map import build_transform_maps
+from ipfabric_netbox.utilities.transform_map import get_transform_map
+
+
+if TYPE_CHECKING:
+    from django.apps import apps
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+    from ipfabric_netbox.models import IPFabricTransformField, IPFabricTransformMap
+
+
+def get_current_transform_map(
+    apps: "apps",
+    target_model: str,
+    app_label: str = "dcim",
+    source_model: str = "interface",
+) -> "IPFabricTransformMap":
+    return apps.get_model("ipfabric_netbox", "IPFabricTransformMap").objects.get(
+        source_model=source_model,
+        target_model=apps.get_model("contenttypes", "ContentType").objects.get(
+            app_label=app_label,
+            model=target_model,
+        ),
+    )
+
+
+def get_current_map_field(apps: "apps", target_model: str) -> "IPFabricTransformField":
+    """Finds the current TransformMapField for MAC address so we keep the template.
+    We need to do this because some customer might have altered it."""
+    return apps.get_model("ipfabric_netbox", "IPFabricTransformField").objects.get(
+        source_field="mac",
+        target_field="mac_address",
+        transform_map=get_current_transform_map(apps, target_model),
+    )
+
+
+def create_transform_map(apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"):
+    """Create transform map structure for MAC Address (new in NetBox v4.2).
+    Keeps current template for MAC Address if it exists.
+
+    Also fixes interface.duplex not being populated."""
+
+    with contextlib.suppress(
+        apps.get_model("ipfabric_netbox", "IPFabricTransformMap").DoesNotExist
+    ):
+        # The map will already be present if we're using newer transform map.
+        # This means we don't need to run the migration since it got created with 0008_prepare_transform_maps migration
+        get_current_transform_map(apps, "macaddress")
+        return
+
+    # region - MAC Address
+    current_mac_field = get_current_map_field(apps, "interface")
+    transform_map_data = get_transform_map()
+
+    mac_address_transform_map = None
+    # Get MAC Address transform map defined in transform_map.json
+    for i, transform_map in enumerate(transform_map_data[:]):
+        if transform_map["data"]["name"] == "MAC Address Transform Map":
+            mac_address_transform_map = [transform_map]
+    # Replace the template only the current field is there
+    if current_mac_field:
+        for field_map in mac_address_transform_map[0]["field_maps"]:
+            if field_map["source_field"] == "mac":
+                field_map["template"] = current_mac_field.template
+
+    build_transform_maps(mac_address_transform_map)
+    current_mac_field.delete()
+    # endregion
+
+    # region - duplex
+    # Create duplex transform field for Interface. Ignore if it already exists
+    IPFabricTransformField = apps.get_model("ipfabric_netbox", "IPFabricTransformField")
+    field_data = {
+        "source_field": "duplex",
+        "target_field": "duplex",
+        "transform_map": get_current_transform_map(apps, "interface"),
+    }
+    try:
+        IPFabricTransformField.objects.get(**field_data)
+    except IPFabricTransformField.DoesNotExist:
+        IPFabricTransformField(**field_data).save()
+    # endregion
+
+    # region - Prefix site
+    # Prefix.site has changed to Prefix.scope relation (to allow site groups etc.)
+    prefix_transform_map = get_current_transform_map(
+        apps, source_model="prefix", app_label="ipam", target_model="prefix"
+    )
+    current_site_relationship = prefix_transform_map.relationship_maps.get(
+        target_field="site"
+    )
+    IPFabricTransformField(
+        source_field="siteName",
+        target_field="scope_id",
+        coalesce=True,
+        template="{% if object.siteName is defined %}"
+        + current_site_relationship.template
+        + "{% else %}None{% endif %}",
+        transform_map=prefix_transform_map,
+    ).save()
+    current_site_relationship.template = '{% if object.siteName is defined %}{{ contenttypes.ContentType.objects.get(app_label="dcim", model="site").pk }}{% else %}None{% endif %}'
+    current_site_relationship.source_model = apps.get_model(
+        "contenttypes", "ContentType"
+    ).objects.get(app_label="contenttypes", model="contenttype")
+    current_site_relationship.target_field = "scope_type"
+    current_site_relationship.save()
+    # endregion
+
+
+def delete_transform_map(apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"):
+    current_mac_field = get_current_map_field(apps, "macaddress")
+
+    # region - MAC Address
+    apps.get_model("ipfabric_netbox", "IPFabricTransformField")(
+        coalesce=False,
+        source_field="mac",
+        target_field="mac_address",
+        template=current_mac_field.template,
+        transform_map=get_current_transform_map(apps, "interface"),
+    ).save()
+
+    # Use CASCADE to delete the transform fields and relationships
+    current_mac_field.transform_map.delete()
+    # endregion
+
+    # region - duplex
+    # Delete new duplex field
+    apps.get_model("ipfabric_netbox", "IPFabricTransformField").objects.get(
+        source_field="duplex",
+        target_field="duplex",
+        transform_map=get_current_transform_map(apps, "interface"),
+    ).delete()
+    # endregion
+
+    # region - Prefix site
+    prefix_transform_map = get_current_transform_map(
+        apps, source_model="prefix", app_label="ipam", target_model="prefix"
+    )
+    current_site_relationship = prefix_transform_map.relationship_maps.get(
+        target_field="scope_type"
+    )
+    current_site_field = prefix_transform_map.field_maps.get(source_field="siteName")
+    match = re.search(r"is defined %}(.*){% else %}None", current_site_field.template)
+    current_site_field.delete()
+    if match:
+        current_site_relationship.template = match.group(1)
+    else:
+        current_site_relationship.template = "{% set SLUG = object.siteName | slugify %}{{ dcim.Site.objects.filter(slug=SLUG).first().pk }}"
+    current_site_relationship.source_model = apps.get_model(
+        "contenttypes", "ContentType"
+    ).objects.get(app_label="dcim", model="site")
+    current_site_relationship.target_field = "site"
+    current_site_relationship.save()
+    # endregion
+
+
+def set_macaddress_sync_param(apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"):
+    IPFabricSync = apps.get_model("ipfabric_netbox", "IPFabricSync")
+    for sync in IPFabricSync.objects.all():
+        if sync.parameters.get("interface"):
+            sync.parameters["macaddress"] = True
+        else:
+            sync.parameters["macaddress"] = False
+        sync.save()
+
+
+def remove_macaddress_sync_param(
+    apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"
+):
+    IPFabricSync = apps.get_model("ipfabric_netbox", "IPFabricSync")
+    for sync in IPFabricSync.objects.all():
+        sync.parameters.pop("macaddress", None)
+        sync.save()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("contenttypes", "0002_remove_content_type_name"),
+        ("ipfabric_netbox", "0008_prepare_transform_maps"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="ipfabrictransformmap",
+            name="target_model",
+            field=models.ForeignKey(
+                limit_choices_to=models.Q(
+                    models.Q(
+                        models.Q(("app_label", "dcim"), ("model", "site")),
+                        models.Q(("app_label", "dcim"), ("model", "manufacturer")),
+                        models.Q(("app_label", "dcim"), ("model", "platform")),
+                        models.Q(("app_label", "dcim"), ("model", "devicerole")),
+                        models.Q(("app_label", "dcim"), ("model", "devicetype")),
+                        models.Q(("app_label", "dcim"), ("model", "device")),
+                        models.Q(("app_label", "dcim"), ("model", "virtualchassis")),
+                        models.Q(("app_label", "dcim"), ("model", "interface")),
+                        models.Q(("app_label", "dcim"), ("model", "macaddress")),
+                        models.Q(("app_label", "ipam"), ("model", "vlan")),
+                        models.Q(("app_label", "ipam"), ("model", "vrf")),
+                        models.Q(("app_label", "ipam"), ("model", "prefix")),
+                        models.Q(("app_label", "ipam"), ("model", "ipaddress")),
+                        models.Q(
+                            ("app_label", "contenttypes"), ("model", "contenttype")
+                        ),
+                        models.Q(("app_label", "tenancy"), ("model", "tenant")),
+                        models.Q(("app_label", "dcim"), ("model", "inventoryitem")),
+                        _connector="OR",
+                    )
+                ),
+                on_delete=django.db.models.deletion.PROTECT,
+                related_name="+",
+                to="contenttypes.contenttype",
+            ),
+        ),
+        migrations.RunPython(set_macaddress_sync_param, remove_macaddress_sync_param),
+        migrations.RunPython(create_transform_map, delete_transform_map),
+    ]

ipfabric_netbox/migrations/0010_remove_uuid_from_get_or_create.py

@@ -0,0 +1,95 @@
+from typing import TYPE_CHECKING
+
+from django.db import migrations
+
+from ipfabric_netbox.utilities.transform_map import get_transform_map
+
+if TYPE_CHECKING:
+    from django.apps import apps
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+
+items_to_change = {
+    ("ip_address", "ipam", "ipaddress"): {"fields": [], "relationships": ["vrf"]},
+    ("device", "dcim", "platform"): {"fields": [], "relationships": ["manufacturer"]},
+    ("device", "dcim", "device"): {
+        "fields": [],
+        "relationships": ["platform", "site", "device_type", "role"],
+    },
+    ("device", "dcim", "devicetype"): {"fields": [], "relationships": ["manufacturer"]},
+    ("interface", "dcim", "interface"): {"fields": [], "relationships": ["device"]},
+    ("part_number", "dcim", "inventoryitem"): {
+        "fields": ["part_id"],
+        "relationships": ["device", "manufacturer"],
+    },
+    ("vlan", "ipam", "vlan"): {"fields": ["name"], "relationships": ["site"]},
+    ("prefix", "ipam", "prefix"): {"fields": ["scope_id"], "relationships": ["vrf"]},
+    ("virtualchassis", "dcim", "virtualchassis"): {
+        "fields": [],
+        "relationships": ["master"],
+    },
+}
+
+
+def add_templates(apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"):
+    transform_map_data = get_transform_map()
+
+    for item in transform_map_data:
+        transform_map_id = (
+            item["data"]["source_model"],
+            item["data"]["target_model"]["app_label"],
+            item["data"]["target_model"]["model"],
+        )
+        if transform_map_id not in items_to_change:
+            continue
+        source_model, app_label, target_model = transform_map_id
+        transform_map = apps.get_model(
+            "ipfabric_netbox", "IPFabricTransformMap"
+        ).objects.get(
+            source_model=source_model,
+            target_model=apps.get_model("contenttypes", "ContentType").objects.get(
+                app_label=app_label,
+                model=target_model,
+            ),
+        )
+
+        change_data = items_to_change[transform_map_id]
+
+        for field_map in item["field_maps"]:
+            if field_map["target_field"] not in change_data["fields"]:
+                continue
+            field = apps.get_model(
+                "ipfabric_netbox", "IPFabricTransformField"
+            ).objects.get(
+                target_field=field_map["target_field"], transform_map=transform_map
+            )
+            field.template = field_map["template"]
+            field.save()
+
+        for relationship_map in item["relationship_maps"]:
+            if relationship_map["target_field"] not in change_data["relationships"]:
+                continue
+            relationship = apps.get_model(
+                "ipfabric_netbox", "IPFabricRelationshipField"
+            ).objects.get(
+                target_field=relationship_map["target_field"],
+                transform_map=transform_map,
+            )
+            relationship.template = relationship_map["template"]
+            relationship.save()
+
+
+def return_templates(apps: "apps", schema_editor: "BaseDatabaseSchemaEditor"):
+    """It would be way too complex to revert this migration and there is no need to do so.
+    The original code works the same with or without the templates."""
+    pass
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("ipfabric_netbox", "0009_transformmap_changes_for_netbox_v4_2"),
+    ]
+
+    operations = [
+        migrations.RunPython(add_templates, return_templates),
+    ]