ipfabric_netbox 4.3.0b6__py3-none-any.whl → 4.3.0b8__py3-none-any.whl

ipfabric_netbox/__init__.py

@@ -6,7 +6,7 @@ class NetboxIPFabricConfig(PluginConfig):
     name = "ipfabric_netbox"
     verbose_name = "NetBox IP Fabric SoT Plugin"
     description = "Sync IP Fabric into NetBox"
-    version = "4.3.0b6"
+    version = "4.3.0b8"
     base_url = "ipfabric"
     min_version = "4.4.0"
 

ipfabric_netbox/api/serializers.py

@@ -176,6 +176,7 @@ class IPFabricSnapshotSerializer(NestedGroupModelSerializer):
 
 class IPFabricSyncSerializer(NestedGroupModelSerializer):
     snapshot_data = IPFabricSnapshotSerializer(nested=True)
+    parameters = serializers.JSONField()
 
     class Meta:
         model = IPFabricSync
@@ -244,3 +245,7 @@ class IPFabricIngestionIssueSerializer(NestedGroupModelSerializer):
             "message",
             "model",
         )
+
+
+class EmptySerializer(serializers.Serializer):
+    pass

ipfabric_netbox/api/views.py

@@ -1,10 +1,15 @@
+from core.api.serializers_.jobs import JobSerializer
+from django.core.exceptions import PermissionDenied
 from django.db import transaction
+from django.http import HttpResponseBadRequest
+from drf_spectacular.utils import extend_schema
 from netbox.api.viewsets import NetBoxModelViewSet
 from netbox.api.viewsets import NetBoxReadOnlyModelViewSet
 from rest_framework.decorators import action
 from rest_framework.response import Response
 from utilities.query import count_related
 
+from .serializers import EmptySerializer
 from .serializers import IPFabricIngestionIssueSerializer
 from .serializers import IPFabricIngestionSerializer
 from .serializers import IPFabricRelationshipFieldSerializer
@@ -56,6 +61,27 @@ class IPFabricSyncViewSet(NetBoxModelViewSet):
     queryset = IPFabricSync.objects.all()
     serializer_class = IPFabricSyncSerializer
 
+    @extend_schema(
+        methods=["post"],
+        request=EmptySerializer(),
+        responses={201: JobSerializer()},
+    )
+    @action(detail=True, methods=["post"])
+    def sync(self, request, pk):
+        if not request.user.has_perm("ipfabric_netbox.sync_ipfabricsync"):
+            raise PermissionDenied(
+                "This user does not have permission to sync IPFabricSync."
+            )
+        sync = self.get_object()
+        if not sync.ready_for_sync:
+            return HttpResponseBadRequest(
+                f"Sync '{sync.name}' is not ready to be synced."
+            )
+        job = sync.enqueue_sync_job(user=request.user, adhoc=True)
+        return Response(
+            JobSerializer(job, context={"request": request}).data, status=201
+        )
+
 
 class IPFabricIngestionViewSet(NetBoxReadOnlyModelViewSet):
     queryset = IPFabricIngestion.objects.all()
@@ -122,3 +148,24 @@ class IPFabricSourceViewSet(NetBoxModelViewSet):
     )
     serializer_class = IPFabricSourceSerializer
     filterset_class = IPFabricSourceFilterSet
+
+    @extend_schema(
+        methods=["post"],
+        request=EmptySerializer(),
+        responses={201: JobSerializer()},
+    )
+    @action(detail=True, methods=["post"])
+    def sync(self, request, pk):
+        if not request.user.has_perm("ipfabric_netbox.sync_ipfabricsource"):
+            raise PermissionDenied(
+                "This user does not have permission to sync IPFabricSource."
+            )
+        source = self.get_object()
+        if not source.ready_for_sync:
+            return HttpResponseBadRequest(
+                f"Source '{source.name}' is not ready to be synced."
+            )
+        job = source.enqueue_sync_job(request=request)
+        return Response(
+            JobSerializer(job, context={"request": request}).data, status=201
+        )

ipfabric_netbox/forms.py

@@ -802,11 +802,7 @@ class IPFabricSyncForm(NetBoxModelForm):
                 ]
         self.instance.parameters = parameters
         self.instance.status = DataSourceStatusChoices.NEW
-
-        object = super().save(*args, **kwargs)
-        if object.scheduled:
-            object.enqueue_sync_job()
-        return object
+        return super().save(*args, **kwargs)
 
 
 class IPFabricSyncBulkEditForm(NetBoxModelBulkEditForm):

ipfabric_netbox/jobs.py

@@ -4,7 +4,6 @@ from datetime import timedelta
 from core.choices import DataSourceStatusChoices
 from core.choices import JobStatusChoices
 from core.exceptions import SyncError
-from core.models import Job
 from netbox.context_managers import event_tracking
 from rq.timeouts import JobTimeoutException
 from utilities.datetime import local_now
@@ -36,15 +35,15 @@ def sync_ipfabricsource(job, *args, **kwargs):
 
 
 def sync_ipfabric(job, *args, **kwargs):
-    obj = IPFabricSync.objects.get(pk=job.object_id)
+    sync = IPFabricSync.objects.get(pk=job.object_id)
 
     try:
         job.start()
-        obj.sync(job=job)
+        sync.sync(job=job)
         job.terminate()
     except Exception as e:
         job.terminate(status=JobStatusChoices.STATUS_ERRORED)
-        IPFabricSync.objects.filter(pk=obj.pk).update(
+        IPFabricSync.objects.filter(pk=sync.pk).update(
             status=DataSourceStatusChoices.FAILED
         )
         if type(e) in (SyncError, JobTimeoutException):
@@ -52,15 +51,38 @@ def sync_ipfabric(job, *args, **kwargs):
         else:
             raise e
     finally:
-        if obj.interval and not kwargs.get("adhoc"):
-            new_scheduled_time = local_now() + timedelta(minutes=obj.interval)
-            job = Job.enqueue(
-                sync_ipfabric,
-                name=f"{obj.name} - (scheduled)",
-                instance=obj,
-                user=obj.user,
-                schedule_at=new_scheduled_time,
-                interval=obj.interval,
+        if sync.interval and not kwargs.get("adhoc"):
+            new_scheduled_time = local_now() + timedelta(minutes=sync.interval)
+            # We want to create new Job only if scheduled time was before this Job started
+            # The current sync might have been changed while this job was running
+            sync.refresh_from_db()
+            if not sync.scheduled or (sync.scheduled and sync.scheduled > job.started):
+                logger.info(
+                    f"Not scheduling a new job for IPFabricSync {sync.pk} as the scheduled time was changed while the job was running."
+                )
+                return
+            # Update the sync object with the new scheduled time
+            # This also triggers the creation of a new Job
+            # Running in fake request context to ensure user is set for changelog
+            request = NetBoxFakeRequest(
+                {
+                    "META": {},
+                    "POST": sync.parameters,
+                    "GET": {},
+                    "FILES": {},
+                    "user": sync.user,
+                    "path": "",
+                    "id": job.job_id,
+                }
+            )
+
+            with event_tracking(request):
+                sync.scheduled = new_scheduled_time
+                sync.status = DataSourceStatusChoices.QUEUED
+                sync.full_clean()
+                sync.save()
+            logger.info(
+                f"Scheduled next sync for IPFabricSync {sync.pk} at {new_scheduled_time}."
             )
 
 

ipfabric_netbox/migrations/0020_clean_scheduled_jobs.py

@@ -0,0 +1,70 @@
+from datetime import timedelta
+from typing import TYPE_CHECKING
+
+from django.db import migrations
+from utilities.datetime import local_now
+
+if TYPE_CHECKING:
+    from django.apps import apps as apps_type
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+
+def clean_scheduled_jobs(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+) -> None:
+    Job = apps.get_model("core", "Job")
+    IPFabricSync = apps.get_model("ipfabric_netbox", "IPFabricSync")
+    ObjectType = apps.get_model("core", "ObjectType")
+
+    for sync in IPFabricSync.objects.all():
+        try:
+            scheduled_jobs = Job.objects.filter(
+                object_id=sync.id,
+                object_type=ObjectType.objects.get_for_model(sync),
+                scheduled__isnull=False,
+            ).order_by("scheduled")
+            if not scheduled_jobs.exists():
+                continue
+            if not sync.scheduled:
+                # Delete all scheduled jobs if the sync is not scheduled
+                scheduled_jobs.delete()
+                continue
+            if scheduled_jobs.count() == 1:
+                # Only one scheduled job exists, let's update scheduled time on the sync object
+                # This does not create a new job since sync is a Faked object in migration
+                sync.scheduled = scheduled_jobs.first().scheduled
+                sync.full_clean()
+                sync.save()
+                continue
+            # More than one scheduled job exists
+            # Find the one that is closest to scheduled + N * interval
+            interval = timedelta(minutes=sync.interval)
+            elapsed = local_now() - sync.scheduled
+            intervals_passed = (elapsed // interval) + 1
+            closest_future_scheduled = sync.scheduled + intervals_passed * interval
+            closest_job = min(
+                scheduled_jobs,
+                key=lambda job: abs(job.scheduled - closest_future_scheduled),
+            )
+            for job in scheduled_jobs:
+                if job != closest_job:
+                    job.delete()
+            sync.scheduled = closest_job.scheduled
+            sync.full_clean()
+            sync.save()
+        except Exception as err:
+            # Always be safe inside a migration
+            print(f"Error cleaning scheduled jobs for IPFabricSync {sync.id}: {err}")
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        (
+            "ipfabric_netbox",
+            "0019_alter_ipfabrictransformmap_options_and_more",
+        ),
+    ]
+
+    operations = [
+        migrations.RunPython(clean_scheduled_jobs, migrations.RunPython.noop),
+    ]

ipfabric_netbox/models.py

@@ -8,6 +8,7 @@ from uuid import uuid4
 
 import httpx
 from core.choices import DataSourceStatusChoices
+from core.choices import JobStatusChoices
 from core.exceptions import SyncError
 from core.models import Job
 from core.models import ObjectType
@@ -669,6 +670,11 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
     def get_status_color(self):
         return DataSourceStatusChoices.colors.get(self.status)
 
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        if self.scheduled:
+            self.enqueue_sync_job()
+
     @property
     def ready_for_sync(self):
         if self.status not in (DataSourceStatusChoices.SYNCING,):
@@ -705,32 +711,56 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
             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
-        IPFabricSync.objects.filter(pk=self.pk).update(status=self.status)
-
-        Job.enqueue(
-            import_string("ipfabric_netbox.jobs.sync_ipfabricsource"),
-            name=f"{self.name} Snapshot Sync (Pre Ingestion)",
-            instance=self.snapshot_data.source,
-            user=self.user,
-        )
+    def delete_scheduled_jobs(self) -> None:
+        Job.objects.filter(
+            object_type=ObjectType.objects.get_for_model(self),
+            object_id=self.pk,
+            status__in=[
+                JobStatusChoices.STATUS_PENDING,
+                JobStatusChoices.STATUS_SCHEDULED,
+            ],
+        ).delete()
+
+    def enqueue_sync_job(self, adhoc=False, user=None) -> Job | None:
+        def set_syncing_status():
+            self.status = DataSourceStatusChoices.QUEUED
+            IPFabricSync.objects.filter(pk=self.pk).update(status=self.status)
+
+        def sync_snapshots():
+            Job.enqueue(
+                import_string("ipfabric_netbox.jobs.sync_ipfabricsource"),
+                name=f"{self.name} Snapshot Sync (Pre Ingestion)",
+                instance=self.snapshot_data.source,
+                user=self.user,
+            )
 
         # Enqueue a sync job
         if not user:
             user = self.user
 
-        if not adhoc and self.scheduled:
-            job = Job.enqueue(
-                import_string("ipfabric_netbox.jobs.sync_ipfabric"),
-                name=f"{self.name} - (scheduled)",
-                instance=self,
-                user=self.user,
-                schedule_at=self.scheduled,
-                interval=self.interval,
-            )
-        elif adhoc:
+        if not adhoc:
+            if self.scheduled:
+                # We want to schedule a recurring Job
+                # We need to replace the old scheduled Job to make sure it has current context
+                self.delete_scheduled_jobs()
+                set_syncing_status()
+                sync_snapshots()
+                job = Job.enqueue(
+                    import_string("ipfabric_netbox.jobs.sync_ipfabric"),
+                    name=f"{self.name} - (scheduled)",
+                    instance=self,
+                    user=self.user,
+                    schedule_at=self.scheduled,
+                    interval=self.interval,
+                )
+            else:
+                # There should be no scheduled Job anymore, clean it up
+                self.delete_scheduled_jobs()
+                job = None
+        else:
+            # Start adhoc job immediately
+            set_syncing_status()
+            sync_snapshots()
             job = Job.enqueue(
                 import_string("ipfabric_netbox.jobs.sync_ipfabric"),
                 instance=self,

ipfabric_netbox/templates/ipfabric_netbox/ipfabricsync.html

@@ -58,7 +58,7 @@
           </tr>
           <tr>
             <th scope="row">Schedule</th>
-            <td><div>{{ object.scheduled }}</div></td>
+            <td><div>{% if scheduled_job %}<a href="{% url 'core:job' pk=scheduled_job.pk %}">{{ object.scheduled }}</a>{% else %} {{ object.scheduled | placeholder }} {% endif %}</div></td>
           </tr>
           <tr>
             <th scope="row">Interval</th>

ipfabric_netbox/tests/api/test_api.py

@@ -1,3 +1,4 @@
+from core.choices import DataSourceStatusChoices
 from django.contrib.contenttypes.models import ContentType
 from django.utils import timezone
 from rest_framework import status
@@ -15,7 +16,7 @@ from ipfabric_netbox.models import IPFabricTransformMap
 from ipfabric_netbox.models import IPFabricTransformMapGroup
 
 
-BASE = "/api/plugins/ipfabric/"
+BASE = "/api/plugins/ipfabric"
 
 
 class IPFabricTransformMapGroupTest(APIViewTestCases.APIViewTestCase):
@@ -36,10 +37,10 @@ class IPFabricTransformMapGroupTest(APIViewTestCases.APIViewTestCase):
     }
 
     def _get_list_url(self):
-        return f"{BASE}transform-map-group/"
+        return f"{BASE}/transform-map-group/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}transform-map-group/{instance.pk}/"
+        return f"{BASE}/transform-map-group/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -62,10 +63,10 @@ class IPFabricTransformMapTest(APIViewTestCases.APIViewTestCase):
     ]
 
     def _get_list_url(self):
-        return f"{BASE}transform-map/"
+        return f"{BASE}/transform-map/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}transform-map/{instance.pk}/"
+        return f"{BASE}/transform-map/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -132,10 +133,10 @@ class IPFabricTransformFieldTest(APIViewTestCases.APIViewTestCase):
     ]
 
     def _get_list_url(self):
-        return f"{BASE}transform-field/"
+        return f"{BASE}/transform-field/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}transform-field/{instance.pk}/"
+        return f"{BASE}/transform-field/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -235,10 +236,10 @@ class IPFabricRelationshipFieldTest(APIViewTestCases.APIViewTestCase):
     ]
 
     def _get_list_url(self):
-        return f"{BASE}relationship-field/"
+        return f"{BASE}/relationship-field/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}relationship-field/{instance.pk}/"
+        return f"{BASE}/relationship-field/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -340,10 +341,10 @@ class IPFabricSourceTest(APIViewTestCases.APIViewTestCase):
     graphql_base_name = "ipfabric_source"
 
     def _get_list_url(self):
-        return f"{BASE}source/"
+        return f"{BASE}/source/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}source/{instance.pk}/"
+        return f"{BASE}/source/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -387,6 +388,66 @@ class IPFabricSourceTest(APIViewTestCases.APIViewTestCase):
             },
         ]
 
+    def test_sync_action_success(self):
+        """Test successful sync action with proper permissions and ready source."""
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsource",
+            "ipfabric_netbox.sync_ipfabricsource",
+        )
+        # Get the first source from setUpTestData
+        source = IPFabricSource.objects.first()
+        # Set status to make ready_for_sync return True
+        source.status = DataSourceStatusChoices.COMPLETED
+        source.save()
+
+        with self.settings(CELERY_TASK_ALWAYS_EAGER=True):
+            # Create a mock job object to simulate enqueue_sync_job response
+            from unittest.mock import Mock, patch
+
+            mock_job = Mock()
+            mock_job.id = "test-job-123"
+            mock_job.status = "queued"
+
+            with patch.object(source, "enqueue_sync_job", return_value=mock_job):
+                url = f"{BASE}/source/{source.pk}/sync/"
+                response = self.client.post(url, **self.header)
+
+                self.assertHttpStatus(response, status.HTTP_201_CREATED)
+                self.assertIn("id", response.data)
+
+    def test_sync_action_permission_denied(self):
+        """Test sync action without proper permissions."""
+        # Note: Not adding sync_ipfabricsource permission
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsource",
+        )
+
+        source = IPFabricSource.objects.first()
+        url = f"{BASE}/source/{source.pk}/sync/"
+        response = self.client.post(url, **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+
+    def test_sync_action_not_ready(self):
+        """Test sync action when source is not ready for sync."""
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsource",
+            "ipfabric_netbox.sync_ipfabricsource",
+        )
+
+        source = IPFabricSource.objects.first()
+        # Set status to make ready_for_sync return False
+        source.status = DataSourceStatusChoices.SYNCING
+        source.save()
+
+        url = f"{BASE}/source/{source.pk}/sync/"
+        response = self.client.post(url, **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            f"Source '{source.name}' is not ready to be synced.", str(response.content)
+        )
+
 
 class IPFabricSnapshotTest(
     APIViewTestCases.GetObjectViewTestCase,
@@ -407,10 +468,10 @@ class IPFabricSnapshotTest(
     ]
 
     def _get_list_url(self):
-        return f"{BASE}snapshot/"
+        return f"{BASE}/snapshot/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}snapshot/{instance.pk}/"
+        return f"{BASE}/snapshot/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -468,7 +529,7 @@ class IPFabricSnapshotTest(
     def test_sites_action_lists_all_and_filters(self):
         self.add_permissions("ipfabric_netbox.view_ipfabricsnapshot")
         # list all
-        url = f"{BASE}snapshot/{self.snapshots[0].pk}/sites/"
+        url = f"{BASE}/snapshot/{self.snapshots[0].pk}/sites/"
         resp = self.client.get(url, **self.header)
         self.assertHttpStatus(resp, status.HTTP_200_OK)
         body = resp.json()
@@ -477,7 +538,7 @@ class IPFabricSnapshotTest(
             labels = [i["name"] for i in body["results"]]
             self.assertEqual(labels, self.snapshots[0].data["sites"])
         # filter
-        url = f"{BASE}snapshot/{self.snapshots[0].pk}/sites/?q=site"
+        url = f"{BASE}/snapshot/{self.snapshots[0].pk}/sites/?q=site"
         resp = self.client.get(url, **self.header)
         self.assertHttpStatus(resp, status.HTTP_200_OK)
         body = resp.json()
@@ -496,7 +557,7 @@ class IPFabricSnapshotTest(
             IPFabricData.objects.filter(snapshot_data=self.snapshots[0]).count(), 0
         )
         # PATCH raw
-        url = f"{BASE}snapshot/{self.snapshots[0].pk}/raw/"
+        url = f"{BASE}/snapshot/{self.snapshots[0].pk}/raw/"
         payload = {
             "data": [
                 {"data": {"example": 1}, "type": "device"},
@@ -550,10 +611,10 @@ class IPFabricSyncTest(APIViewTestCases.APIViewTestCase):
     }
 
     def _get_list_url(self):
-        return f"{BASE}sync/"
+        return f"{BASE}/sync/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}sync/{instance.pk}/"
+        return f"{BASE}/sync/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -637,6 +698,72 @@ class IPFabricSyncTest(APIViewTestCases.APIViewTestCase):
         cls.create_data[1]["parameters"] = {"ipaddress": True, "prefix": True}
         cls.create_data[2]["parameters"] = {"device": True, "interface": True}
 
+    def test_sync_action_success(self):
+        """Test successful sync action with proper permissions and ready sync."""
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsync",
+            "ipfabric_netbox.sync_ipfabricsync",
+        )
+        # Get the first sync from setUpTestData
+        sync = IPFabricSync.objects.first()
+        # Set status and ensure snapshot has data to make ready_for_sync return True
+        sync.status = DataSourceStatusChoices.COMPLETED
+        sync.save()
+
+        # Ensure the snapshot has data
+        sync.snapshot_data.source.type = (
+            "local"  # For local type, ready_for_sync checks are simpler
+        )
+        sync.snapshot_data.source.save()
+
+        with self.settings(CELERY_TASK_ALWAYS_EAGER=True):
+            # Create a mock job object to simulate enqueue_sync_job response
+            from unittest.mock import Mock, patch
+
+            mock_job = Mock()
+            mock_job.id = "test-sync-job-456"
+            mock_job.status = "queued"
+
+            with patch.object(sync, "enqueue_sync_job", return_value=mock_job):
+                url = f"{BASE}/sync/{sync.pk}/sync/"
+                response = self.client.post(url, **self.header)
+
+                self.assertHttpStatus(response, status.HTTP_201_CREATED)
+                self.assertIn("id", response.data)
+
+    def test_sync_action_permission_denied(self):
+        """Test sync action without proper permissions."""
+        # Note: Not adding sync_ipfabricsource permission
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsync",
+        )
+
+        sync = IPFabricSync.objects.first()
+        url = f"{BASE}/sync/{sync.pk}/sync/"
+        response = self.client.post(url, **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+
+    def test_sync_action_not_ready(self):
+        """Test sync action when sync is not ready for sync."""
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsync",
+            "ipfabric_netbox.sync_ipfabricsync",
+        )
+
+        sync = IPFabricSync.objects.first()
+        # Set status to make ready_for_sync return False
+        sync.status = DataSourceStatusChoices.SYNCING
+        sync.save()
+
+        url = f"{BASE}/sync/{sync.pk}/sync/"
+        response = self.client.post(url, **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            f"Sync '{sync.name}' is not ready to be synced.", str(response.content)
+        )
+
 
 class IPFabricIngestionTest(
     APIViewTestCases.GetObjectViewTestCase,
@@ -653,10 +780,10 @@ class IPFabricIngestionTest(
     ]
 
     def _get_list_url(self):
-        return f"{BASE}ingestion/"
+        return f"{BASE}/ingestion/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}ingestion/{instance.pk}/"
+        return f"{BASE}/ingestion/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -754,10 +881,10 @@ class IPFabricIngestionIssueTest(
     ]
 
     def _get_list_url(self):
-        return f"{BASE}ingestion-issues/"
+        return f"{BASE}/ingestion-issues/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}ingestion-issues/{instance.pk}/"
+        return f"{BASE}/ingestion-issues/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):

ipfabric_netbox/tests/test_views.py

@@ -1,4 +1,5 @@
 import random
+from datetime import timedelta
 from unittest.mock import patch
 from uuid import uuid4
 
@@ -611,7 +612,7 @@ class IPFabricSyncTestCase(
     # ViewTestCases.BulkImportObjectsViewTestCase,
 ):
     model = IPFabricSync
-    user_permissions = ("ipfabric_netbox.start_ipfabricsync",)
+    user_permissions = ("ipfabric_netbox.sync_ipfabricsync",)
 
     @classmethod
     def setUpTestData(cls):
@@ -656,6 +657,8 @@ class IPFabricSyncTestCase(
                 status=DataSourceStatusChoices.NEW,
                 parameters=get_parameters(),
                 last_synced=timezone.now(),
+                scheduled=timezone.now() + timedelta(hours=6),
+                interval=123456,
             ),
             IPFabricSync(
                 name="Sync Job 2",
@@ -716,7 +719,7 @@ class IPFabricSyncTestCase(
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_get_htmx_request(self):
-        instance = self._get_queryset().first()
+        instance = self._get_queryset().last()
         # Try GET with HTMX
         response = self.client.get(
             instance.get_absolute_url(), **{"HTTP_HX-Request": "true"}

ipfabric_netbox/views.py

@@ -782,7 +782,15 @@ class IPFabricSyncView(generic.ObjectView):
 
         last_ingestion = instance.ipfabricingestion_set.last()
 
-        return {"format": format, "last_ingestion": last_ingestion}
+        scheduled_job = None
+        if instance.scheduled:
+            scheduled_job = instance.jobs.filter(scheduled=instance.scheduled).last()
+
+        return {
+            "format": format,
+            "last_ingestion": last_ingestion,
+            "scheduled_job": scheduled_job,
+        }
 
 
 @register_model_view(IPFabricSync, "sync")
@@ -790,7 +798,7 @@ class IPFabricStartSyncView(BaseObjectView):
     queryset = IPFabricSync.objects.all()
 
     def get_required_permission(self):
-        return "ipfabric_netbox.start_ipfabricsync"
+        return "ipfabric_netbox.sync_ipfabricsync"
 
     def get(self, request, pk):
         ipfabric = get_object_or_404(self.queryset, pk=pk)

{ipfabric_netbox-4.3.0b6.dist-info → ipfabric_netbox-4.3.0b8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipfabric_netbox
-Version: 4.3.0b6
+Version: 4.3.0b8
 Summary: NetBox plugin to sync IP Fabric data into NetBox
 License: MIT
 Keywords: netbox,ipfabric,plugin,sync

{ipfabric_netbox-4.3.0b6.dist-info → ipfabric_netbox-4.3.0b8.dist-info}/RECORD

@@ -1,19 +1,19 @@
-ipfabric_netbox/__init__.py,sha256=-W7W2QVW8zRl8VHGc4Pgv6uo7r0otVcpDjE3vuvPyFw,674
+ipfabric_netbox/__init__.py,sha256=OTnSDhJRsShw8su9ERPqVv7GzWob31Rb6yfngwD91Mo,674
 ipfabric_netbox/api/__init__.py,sha256=XRclTGWVR0ZhAAwgYul5Wm_loug5_hUjEumbLQEwKYM,47
-ipfabric_netbox/api/serializers.py,sha256=7cmVsIzGzz9u6htLKizLr2Ar0OC7uV8rMX3U7EzRmG4,6482
+ipfabric_netbox/api/serializers.py,sha256=lr_PWG0tqAxaKtkIIm8Gx2B-tn9yENQIfKY9cvu8Cco,6581
 ipfabric_netbox/api/urls.py,sha256=1fXXVTxNY5E64Nfz6b7zXD9bZI3FcefuxAWKMe0w_QU,1240
-ipfabric_netbox/api/views.py,sha256=gluK311fDx3sLsQ6iE6O1M_s3Kz1_sjD0sfmWR_UE2Q,5064
+ipfabric_netbox/api/views.py,sha256=qOBTIzPtOBY75tTjirsTBbiRXrQQid478Tp15-WKbmQ,6859
 ipfabric_netbox/choices.py,sha256=gXRV_c04OnQl_kJTsAH1k88u8PWbiVXvcYwufZPKMdM,5035
 ipfabric_netbox/data/transform_map.json,sha256=4PsucgMHcLW3SPoKEptQCd0gA5tCF4hjrR4bGQFCWy8,21744
 ipfabric_netbox/exceptions.py,sha256=DT4dpbakvqoROtBR_F0LzvQCMNWpGhufFcUbZTx0OLY,2655
 ipfabric_netbox/filtersets.py,sha256=vaWlxf8DTwduv_aQ35kJxwyzmM1XvE781GjUj2z4QGQ,7845
-ipfabric_netbox/forms.py,sha256=nSEOlqPDvxgFuWVVmRf4AvubfMEAqh0ZlyyfoMQurCk,50024
+ipfabric_netbox/forms.py,sha256=WI1OypOG4Zqry6jiH991ZBVBMnfwzUDhNJAZCUQNaUg,49932
 ipfabric_netbox/graphql/__init__.py,sha256=-a5w_VY7pc-RVt8MvThkTzeAqCC3xCan4Ue6iMefmjI,754
 ipfabric_netbox/graphql/enums.py,sha256=QFhwiwUKJekxQfsOGk_-70_WnkzrKEP_zIBMrin0S0Q,1343
 ipfabric_netbox/graphql/filters.py,sha256=B8xy9r9a18vWfV6a6tHXAN1FUcoxI6MOrbsdNmzusNI,12991
 ipfabric_netbox/graphql/schema.py,sha256=5UVHA1hHRvho5eLuuS-HLXTVTbxpUUx68ovG03gumGE,3209
 ipfabric_netbox/graphql/types.py,sha256=8RxdxiA-WnoaWSzh-tUJCuZBYGmd6QjfJiJcLirRMKY,5961
-ipfabric_netbox/jobs.py,sha256=KrTUeCuFUIU7vKCUS3RiBYCBG7g7GzhGagM_qFMGQJ4,3089
+ipfabric_netbox/jobs.py,sha256=rFQuuc_6WVZlJ2EGDDj2ml14L4JeFneSSTiKA8N1SUg,4189
 ipfabric_netbox/migrations/0001_initial.py,sha256=VphxkWL6QzWq2tcrdXlog718xQtiEGizKwS830z_fOs,13824
 ipfabric_netbox/migrations/0001_initial_squashed_0013_switch_to_branching_plugin.py,sha256=OvofuA8ImeJmjrbtCrZPcRxAUWx2Ww4DUXLBZYsy6qE,21381
 ipfabric_netbox/migrations/0002_ipfabricsnapshot_status.py,sha256=xQpouHjOutyj6riN2B592njzSvz_icpkUbo5W7nWLYw,431
@@ -34,8 +34,9 @@ ipfabric_netbox/migrations/0016_tags_and_changelog_for_snapshots.py,sha256=XqftT
 ipfabric_netbox/migrations/0017_ipfabricsync_update_custom_fields.py,sha256=IVbAL2WdigYT40sXN0A8K3HweJ_O4QqyzjB06TbkG5E,447
 ipfabric_netbox/migrations/0018_remove_type_field.py,sha256=ffxW6IS3BLCbvM5M9DbDb_x6spMmRxnV1iq8IuXxMGw,385
 ipfabric_netbox/migrations/0019_alter_ipfabrictransformmap_options_and_more.py,sha256=ieDVedt9KpJBicAiC3kdZXzHeos12N0L9EdRXKmIVgY,501
+ipfabric_netbox/migrations/0020_clean_scheduled_jobs.py,sha256=zjCVKnCWTKYYkpVRwHjqRIRR2j6ALSKXYMfraRjNu7Y,2652
 ipfabric_netbox/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ipfabric_netbox/models.py,sha256=czXxzdEWyVJKDEG1cK9tDvnoltD2guv42UboK0Cekis,36956
+ipfabric_netbox/models.py,sha256=PgcxznpcihHwkdWlBJN1q2YshyvYS3lKvDvgQVSSDbI,38105
 ipfabric_netbox/navigation.py,sha256=2dEJ_wKHb52Tl0FOV1TH3JbxRe8YZ56ewrTsBFGKpCg,2210
 ipfabric_netbox/signals.py,sha256=cGa5PVD2i24pGXiVNfbu6ruIDqPVdwKQHTSWe9Ura84,1838
 ipfabric_netbox/tables.py,sha256=BpPmL6-KClX16Ol_PIADyOx9NtDR9oauXH5iO4GeSoI,9008
@@ -54,7 +55,7 @@ ipfabric_netbox/templates/ipfabric_netbox/ipfabric_table.html,sha256=TsF34lK2CyD
 ipfabric_netbox/templates/ipfabric_netbox/ipfabricingestion.html,sha256=fm_X2FLnoTS6s6AL3WmU6p3puDojROSkPG0jA4EBQeM,4435
 ipfabric_netbox/templates/ipfabric_netbox/ipfabricsnapshot.html,sha256=hj8ORs_4mM_xTjmw3McHN-da5seC8nbbkzobn0f1TSc,3482
 ipfabric_netbox/templates/ipfabric_netbox/ipfabricsource.html,sha256=DQOA2TA7f1nI5YpxXthS1VzjIU1kMZus37l6bYSCauE,3869
-ipfabric_netbox/templates/ipfabric_netbox/ipfabricsync.html,sha256=vgkxhJBWnfuZmDxfstLFJEAXc7FCY8Q7Hcu2MydI45A,4480
+ipfabric_netbox/templates/ipfabric_netbox/ipfabricsync.html,sha256=dt8HYuHCzIN4otLS9QK3e1aES14isFI-1jyp8jrENXU,4616
 ipfabric_netbox/templates/ipfabric_netbox/ipfabrictransformmap.html,sha256=qFo_Ku5oksx5co4HVtVq0xAVFI6CLWs-iBrwYzGsEGA,1460
 ipfabric_netbox/templates/ipfabric_netbox/ipfabrictransformmap_list.html,sha256=p8zqn0-B6mawSUM3zQrus6dsKUM5SRBTO0X94pLboX8,452
 ipfabric_netbox/templates/ipfabric_netbox/ipfabrictransformmap_restore.html,sha256=TV7gAZWtSd-c7mzOen_nv7Z8MZr2Vw8vkHP4zW9au4w,2580
@@ -71,17 +72,17 @@ ipfabric_netbox/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 ipfabric_netbox/templatetags/ipfabric_netbox_helpers.py,sha256=STw4pAd2qG7hgf-O6UNTwsO5VqEa_gxf5wLv50BWL4Q,417
 ipfabric_netbox/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ipfabric_netbox/tests/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ipfabric_netbox/tests/api/test_api.py,sha256=-pW0xRqHUEr574HFL27C3FE77slI_bEh3Y5nfPDfcao,30283
+ipfabric_netbox/tests/api/test_api.py,sha256=9o9k4kfnT3Zz9Hg0qnI0_XASt6pi5BCZQ3RhBjsb_iE,35215
 ipfabric_netbox/tests/test_forms.py,sha256=C8giV6E3PbMB9_864C12ebvfQ3Vlvdn39VIQQSP6GV8,61566
 ipfabric_netbox/tests/test_models.py,sha256=FFrIT5xxv_yvujKpxGjRJPNPBDF2Pqi8zbY0vxuJeQs,16043
-ipfabric_netbox/tests/test_views.py,sha256=ofKGbj3aSzl9l0CrdeLpcXBnCpVfsodKfYB9Q4L_F_c,87645
+ipfabric_netbox/tests/test_views.py,sha256=pyUPdsgkvcfHC_BgmFtAQvENQfGvtEVSyNnRikLrlxc,87770
 ipfabric_netbox/urls.py,sha256=qF2BzZEDnPRd3opFaRfiMdaarYKFfv69iMaAbU2rsBU,2702
 ipfabric_netbox/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ipfabric_netbox/utilities/ipfutils.py,sha256=wFmL5oriuF-is1ZlrIcLmoeYUY5ih-CA9weRQrx5AiA,31885
 ipfabric_netbox/utilities/logging.py,sha256=GYknjocMN6LQ2873_az3y0RKm29TCXaWviUIIneH-x0,3445
 ipfabric_netbox/utilities/nbutils.py,sha256=kFBEiJOGvr_49hJWCS2duXojx2-A9kVk0Xp_vj0ohfs,2641
 ipfabric_netbox/utilities/transform_map.py,sha256=GpM_7Mm6FE0qV2qbyj4YfDn0l-JkeeEHQOZkNVSSHk4,2391
-ipfabric_netbox/views.py,sha256=np1aYd9tBy7yERAhtwXMJvi2vDoXTkTx_ayLglw1LJ0,44521
-ipfabric_netbox-4.3.0b6.dist-info/METADATA,sha256=yIiT8CpHWwHj8ynUd48Q1YFpHwheTUaMtQ_aBKedL8I,4754
-ipfabric_netbox-4.3.0b6.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-ipfabric_netbox-4.3.0b6.dist-info/RECORD,,
+ipfabric_netbox/views.py,sha256=n3tTDs1xOAY5xtcMmhM6VrnpEr-2IzqeliFNgthQf1U,44746
+ipfabric_netbox-4.3.0b8.dist-info/METADATA,sha256=A9F-rJ7Tl1pmXn__yVo7FfDRoZc1C03CWF8gv67JXzE,4754
+ipfabric_netbox-4.3.0b8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+ipfabric_netbox-4.3.0b8.dist-info/RECORD,,