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

ipfabric_netbox/utilities/logging.py

@@ -66,22 +66,22 @@ class SyncLogging:
         self._log(obj, message, level=LogLevelChoices.LOG_FAILURE)
         self.logger.info(f"Failure | {obj}: {message}")
 
-    def init_statistics(self, model: str, total: int) -> dict[str, int]:
+    def init_statistics(self, model_string: str, total: int) -> dict[str, int]:
         statistics = self.log_data.get("statistics")
-        if not statistics.get(model):
-            stats = statistics[model] = {"current": 0, "total": total}
+        if not statistics.get(model_string):
+            stats = statistics[model_string] = {"current": 0, "total": total}
         else:
-            stats = statistics.get(model)
+            stats = statistics.get(model_string)
         return stats
 
-    def increment_statistics(self, model: str, total: int = None) -> None:
-        stats = self.init_statistics(model, total)
+    def increment_statistics(self, model_string: str, total: int = None) -> None:
+        stats = self.init_statistics(model_string, total)
         if total:
             stats["total"] = total
         stats["current"] += 1
         cache.set(self.cache_key, self.log_data, self.cache_timeout)
         self.logger.info(
-            f"{model} - {stats['current']} out of {stats['total']} processed"
+            f"{model_string} - {stats['current']} out of {stats['total']} processed"
         )
 
     def clear_log(self):

ipfabric_netbox/utilities/transform_map.py

@@ -1,8 +1,14 @@
 import importlib.resources
 import json
+import logging
+from typing import Any
+from typing import Callable
 
 from django.apps import apps as django_apps
 
+
+logger = logging.getLogger("ipfabric_netbox.utilities.transform_map")
+
 # region Transform Map Creation
 
 # These functions are used in the migration file to prepare the transform maps
@@ -33,14 +39,81 @@ def build_fields(data, apps, db_alias):
 
 def build_transform_maps(data, apps: django_apps = None, db_alias: str = "default"):
     apps = apps or django_apps
+    ContentType = apps.get_model("contenttypes", "ContentType")
     IPFabricTransformMap = apps.get_model("ipfabric_netbox", "IPFabricTransformMap")
     IPFabricTransformField = apps.get_model("ipfabric_netbox", "IPFabricTransformField")
     IPFabricRelationshipField = apps.get_model(
         "ipfabric_netbox", "IPFabricRelationshipField"
     )
+
+    # Mapping for backward compatibility (endpoint -> source_model)
+    # Used only when running against old model that still has source_model field
+    # TODO: Remove once migrations are squashed and old versions are no longer supported
+    endpoint_to_source_model = {
+        "/technology/addressing/managed-ip/ipv4": "ipaddress",
+        "/inventory/devices": "device",
+        "/inventory/sites/overview": "site",
+        "/inventory/interfaces": "interface",
+        "/inventory/part-numbers": "part_number",
+        "/technology/vlans/site-summary": "vlan",
+        "/technology/routing/vrf/detail": "vrf",
+        "/technology/networks/managed-networks": "prefix",
+        "/technology/platforms/stack1/members": "virtualchassis",
+    }
+
+    model_fields = {f.name for f in IPFabricTransformMap._meta.get_fields()}
     for tm in data:
         field_data = build_fields(tm["data"], apps, db_alias)
+
+        endpoint_value = field_data.pop("source_endpoint")
+
+        if "source_endpoint" in model_fields:
+            # New model: use source_endpoint foreign key to IPFabricEndpoint
+            # This models does not exist when TMs are populated, so need to get it here
+            IPFabricEndpoint = apps.get_model("ipfabric_netbox", "IPFabricEndpoint")
+            try:
+                endpoint = IPFabricEndpoint.objects.using(db_alias).get(
+                    endpoint=endpoint_value
+                )
+                field_data["source_endpoint"] = endpoint
+            except IPFabricEndpoint.DoesNotExist:
+                # Use first endpoint as fallback
+                endpoint = IPFabricEndpoint.objects.using(db_alias).first()
+                field_data["source_endpoint"] = endpoint
+                field_data[
+                    "name"
+                ] = f"[NEEDS CORRECTION - Expected endpoint '{endpoint_value}' not found] {field_data['name']}"
+
+        else:
+            # Old model: convert source_endpoint value to source_model string
+            source_model_value = endpoint_to_source_model.get(endpoint_value, "device")
+            field_data["source_model"] = source_model_value
+
+        # This field was not present in the old model, so remove it if exists
+        tm_parents = []
+        if parents := field_data.pop("parents", None):
+            if isinstance(parents, str):
+                parents = [parents]
+            for parent in parents:
+                if "parents" not in model_fields:
+                    continue
+                # New model: set parents MTM field to IPFabricTransformMap
+                app, model = parent.split(".")
+                try:
+                    parent_tm = IPFabricTransformMap.objects.using(db_alias).get(
+                        target_model=ContentType.objects.using(db_alias).get(
+                            app_label=app, model=model
+                        ),
+                        group__isnull=True,
+                    )
+                    tm_parents.append(parent_tm)
+                except IPFabricTransformMap.DoesNotExist:
+                    raise ValueError(f"Parent Transform Map '{parent}' not found")
+
         tm_obj = IPFabricTransformMap.objects.using(db_alias).create(**field_data)
+        # Old migrations may not have parents field
+        if hasattr(tm_obj, "parents"):
+            tm_obj.parents.set(tm_parents)
         for fm in tm["field_maps"]:
             field_data = build_fields(fm, apps, db_alias)
             IPFabricTransformField.objects.using(db_alias).create(
@@ -108,12 +181,15 @@ class RelationshipRecord(Record):
 class TransformMapRecord:
     def __init__(
         self,
-        source_model: str,
         target_model: str,
         fields: tuple[FieldRecord, ...] = tuple(),
         relationships: tuple[RelationshipRecord, ...] = tuple(),
+        # Support both source_model string and source_endpoint string for backward compatibility
+        source_model: str | None = None,
+        source_endpoint: str | None = None,
     ):
         self.source_model = source_model
+        self.source_endpoint = source_endpoint
         self.target_model = target_model
         self.fields = fields
         self.relationships = relationships
@@ -135,10 +211,20 @@ def do_change(
         for change in changes:
             app, model = change.target_model.split(".")
             try:
-                transform_map = IPFabricTransformMap.objects.get(
-                    source_model=change.source_model,
-                    target_model=ContentType.objects.get(app_label=app, model=model),
-                )
+                if change.source_model:
+                    transform_map = IPFabricTransformMap.objects.get(
+                        source_model=change.source_model,
+                        target_model=ContentType.objects.get(
+                            app_label=app, model=model
+                        ),
+                    )
+                else:
+                    transform_map = IPFabricTransformMap.objects.get(
+                        source_endpoint__endpoint=change.source_endpoint,
+                        target_model=ContentType.objects.get(
+                            app_label=app, model=model
+                        ),
+                    )
             except IPFabricTransformMap.DoesNotExist:
                 continue
 
@@ -231,3 +317,56 @@ def do_change(
 
 
 # endregion
+
+# region Cycle Detection
+
+
+def has_cycle_dfs(
+    node_id: int,
+    get_parents_func: Callable[[int, Any], Any],
+    parent_override: Any = None,
+    visited: set[int] | None = None,
+    rec_stack: set[int] | None = None,
+) -> bool:
+    """
+    DFS helper to detect cycles in transform map parent relationships.
+
+    Args:
+        node_id: The ID of the current node being checked
+        get_parents_func: Function that takes (node_id, parent_override) and returns parent objects
+        parent_override: Optional override for parents of a specific node (used for validation)
+        visited: Set of already visited node IDs (created automatically if not provided)
+        rec_stack: Set of node IDs in the current recursion stack (created automatically if not provided)
+
+    Returns:
+        True if a cycle is detected, False otherwise
+    """
+    if visited is None:
+        visited = set()
+    if rec_stack is None:
+        rec_stack = set()
+
+    visited.add(node_id)
+    rec_stack.add(node_id)
+
+    try:
+        parents = get_parents_func(node_id, parent_override)
+
+        for parent in parents:
+            parent_pk = parent.pk if hasattr(parent, "pk") else parent.id
+            if parent_pk not in visited:
+                if has_cycle_dfs(
+                    parent_pk, get_parents_func, visited=visited, rec_stack=rec_stack
+                ):
+                    return True
+            elif parent_pk in rec_stack:
+                # Found a back edge - cycle detected
+                return True
+    except Exception as err:
+        logger.warning(f"Error applying Transform map updates: {err}")
+
+    rec_stack.remove(node_id)
+    return False
+
+
+# endregion