nautobot 2.4.3__py3-none-any.whl → 2.4.4__py3-none-any.whl

nautobot/dcim/templates/dcim/virtualdevicecontext_retrieve.html

@@ -4,65 +4,3 @@
 {% block extra_breadcrumbs %}
     <li><a href="{% url 'dcim:device' pk=object.device.pk %}">{{ object.device }}</a></li>
 {% endblock extra_breadcrumbs %}
-
-
-{% block content_left_page %}
-    <div class="panel panel-default">
-        <div class="panel-heading">
-            <strong>Virtual Device Context</strong>
-        </div>
-        <table class="table table-hover panel-body attr-table">
-            <tr>
-                <td>Name</td>
-                <td>
-                    {{ object.name }}
-                </td>
-            </tr>
-            <tr>
-                <td>Identifier</td>
-                <td>
-                    {{ object.identifier }}
-                </td>
-            </tr>
-            <tr>
-                <td>Role</td>
-                <td>
-                    {{ object.role| hyperlinked_object_with_color }}
-                </td>
-            </tr>
-            <tr>
-                <td>Status</td>
-                <td>
-                    {{ object.status| hyperlinked_object_with_color }}
-                </td>
-            </tr>
-            <tr>
-                <td>Device</td>
-                <td>
-                    {{ object.device|hyperlinked_object }}
-                </td>
-            </tr>
-            <tr>
-                <td>Primary IPv4</td>
-                <td>
-                    {{ object.primary_ip4|hyperlinked_object }}
-                </td>
-            </tr>
-            <tr>
-                <td>Primary IPv6</td>
-                <td>
-                    {{ object.primary_ip6|hyperlinked_object }}
-                </td>
-            </tr>
-            {% include 'inc/tenant_table_row.html' %}
-            <tr>
-                <td>Description</td>
-                <td>{{ object.description|placeholder }}</td>
-            </tr>
-        </table>
-    </div>
-{% endblock content_left_page %}
-
-{% block content_full_width_page %}
-    {% include 'panel_table.html' with table=interfaces_table heading="Interfaces" %}
-{% endblock content_full_width_page %}

nautobot/dcim/templates/dcim/virtualdevicecontext_update.html

@@ -23,6 +23,12 @@
             {% endif %}
         </div>
     </div>
+    <div class="panel panel-default">
+        <div class="panel-heading"><strong>VRF Assignments</strong></div>
+        <div class="panel-body">
+            {% render_field form.vrfs %}
+        </div>
+    </div>
     {% include 'inc/tenancy_form_panel.html' %}
     {% include 'inc/extras_features_edit_form_fields.html' %}
 {% endblock %}

nautobot/dcim/tests/test_api.py

@@ -1716,6 +1716,182 @@ class DeviceTest(APIViewTestCases.APIViewTestCase):
         )
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
+    def _parent_device_test_data(self):
+        location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        device_role = Role.objects.get_for_model(Device).first()
+        device_type = DeviceType.objects.first()
+
+        device_type_parent = DeviceType.objects.create(
+            manufacturer=device_type.manufacturer,
+            model=f"{device_type.model} Parent",
+            u_height=device_type.u_height,
+            subdevice_role=SubdeviceRoleChoices.ROLE_PARENT,
+        )
+        device_type_child = DeviceType.objects.create(
+            manufacturer=device_type.manufacturer,
+            model=f"{device_type.model} Child",
+            u_height=device_type.u_height,
+            subdevice_role=SubdeviceRoleChoices.ROLE_CHILD,
+        )
+
+        parent_device = Device.objects.create(
+            device_type=device_type_parent,
+            role=device_role,
+            status=device_status,
+            name="Device Parent",
+            location=location,
+        )
+        device_bay_1 = DeviceBay.objects.create(name="db1", device_id=parent_device.pk)
+        device_bay_2 = DeviceBay.objects.create(name="db2", device_id=parent_device.pk)
+
+        return parent_device, device_bay_1, device_bay_2, device_type_child
+
+    def test_creating_device_with_parent_bay(self):
+        # Create test data
+        parent_device, device_bay_1, device_bay_2, device_type_child = self._parent_device_test_data()
+
+        self.add_permissions("dcim.add_device")
+        url = reverse("dcim-api:device-list")
+
+        # Test creating device with parent bay by device bay data
+        data = {
+            "device_type": device_type_child.pk,
+            "role": parent_device.role.pk,
+            "location": parent_device.location.pk,
+            "name": "Device parent bay test #1",
+            "status": parent_device.status.pk,
+            "parent_bay": {"device": {"name": parent_device.name}, "name": device_bay_1.name},
+        }
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+
+        created_device = Device.objects.get(name="Device parent bay test #1")
+        self.assertEqual(created_device.parent_bay.pk, device_bay_1.pk)
+
+        # Test creating device with parent bay by device_bay.pk
+        data = {
+            "device_type": device_type_child.pk,
+            "role": parent_device.role.pk,
+            "location": parent_device.location.pk,
+            "name": "Device parent bay test #2",
+            "status": parent_device.status.pk,
+            "parent_bay": device_bay_2.pk,
+        }
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+
+        created_device = Device.objects.get(name="Device parent bay test #2")
+        self.assertEqual(created_device.parent_bay.pk, device_bay_2.pk)
+
+        # Test creating device with parent bay already taken
+        data = {
+            "device_type": device_type_child.pk,
+            "role": parent_device.role.pk,
+            "location": parent_device.location.pk,
+            "name": "Device parent bay test #3",
+            "status": parent_device.status.pk,
+            "parent_bay": device_bay_1.pk,
+        }
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("Cannot install device; parent bay is already taken", response.content.decode(response.charset))
+
+        # Assert that on the #1 device, parent bay stayed the same
+        old_device = Device.objects.get(name="Device parent bay test #1")
+        self.assertEqual(old_device.parent_bay.pk, device_bay_1.pk)
+
+    def test_update_device_with_parent_bay(self):
+        # Create test data
+        parent_device, device_bay_1, device_bay_2, device_type_child = self._parent_device_test_data()
+
+        self.add_permissions("dcim.change_device")
+
+        child_device = Device.objects.create(
+            device_type=device_type_child,
+            role=parent_device.role,
+            location=parent_device.location,
+            name="Device parent bay test #4",
+            status=parent_device.status,
+        )
+        # Test setting parent bay during the update
+        patch_data = {"parent_bay": device_bay_1.pk}
+        response = self.client.patch(self._get_detail_url(child_device), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        updated_device = Device.objects.get(name="Device parent bay test #4")
+        self.assertEqual(updated_device.parent_bay.pk, device_bay_1.pk)
+
+        # Changing the parent bay is not allowed without removing it first
+        patch_data = {"parent_bay": device_bay_2.pk}
+        response = self.client.patch(self._get_detail_url(child_device), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            f"Cannot install the specified device; device is already installed in {device_bay_1.name}",
+            response.content.decode(response.charset),
+        )
+
+        # Assert that parent bay stayed the same
+        updated_device = Device.objects.get(name="Device parent bay test #4")
+        self.assertEqual(updated_device.parent_bay.pk, device_bay_1.pk)
+
+    def test_reassign_device_to_parent_bay(self):
+        # Create test data
+        parent_device, device_bay_1, device_bay_2, device_type_child = self._parent_device_test_data()
+        device_name = "Device parent bay test #5"
+        child_device = Device.objects.create(
+            device_type=device_type_child,
+            role=parent_device.role,
+            location=parent_device.location,
+            name=device_name,
+            status=parent_device.status,
+        )
+        device_bay_1.installed_device = child_device
+        device_bay_1.save()
+
+        self.add_permissions("dcim.change_device", "dcim.view_device", "dcim.change_devicebay")
+        child_device_detail_url = self._get_detail_url(child_device)
+
+        response = self.client.get(child_device_detail_url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(response.json()["parent_bay"]["id"], str(device_bay_1.pk))
+
+        # Test unassigning parent bay
+        patch_data = {"parent_bay": None}
+        response = self.client.patch(child_device_detail_url, patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        with self.assertRaises(DeviceBay.DoesNotExist):
+            child_device.parent_bay
+
+        # And assign it again
+        patch_data = {"parent_bay": device_bay_2.pk}
+        response = self.client.patch(child_device_detail_url, patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        self.assertEqual(child_device.parent_bay.pk, device_bay_2.pk)
+
+        # Unassign it through device bay
+        patch_data = {"installed_device": None}
+        response = self.client.patch(self._get_detail_url(device_bay_2), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        self.assertFalse(hasattr(child_device, "parent_bay"))
+
+        # And assign through device bay
+        patch_data = {"installed_device": child_device.pk}
+        response = self.client.patch(self._get_detail_url(device_bay_1), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        self.assertEqual(child_device.parent_bay.pk, device_bay_1.pk)
+
 
 class ModuleTestCase(APIViewTestCases.APIViewTestCase):
     model = Module

nautobot/dcim/tests/test_filters.py

@@ -157,6 +157,8 @@ def common_test_data(cls):
     cls.loc0 = loc0
     cls.loc1 = loc1
     cls.nested_loc = nested_loc
+    cls.loc2 = loc2
+    cls.loc3 = loc3
 
     provider = Provider.objects.first()
     circuit_type = CircuitType.objects.first()
@@ -1150,6 +1152,24 @@ class RackGroupTestCase(FilterTestCases.FilterTestCase):
             name="Rack Group 4",
             location=cls.loc1,
         )
+        RackGroup.objects.create(
+            name="Rack Group 5",
+            location=cls.loc2,
+            description="C",
+        )
+        RackGroup.objects.create(
+            name="Rack Group 6",
+            location=cls.loc2,
+        )
+        RackGroup.objects.create(
+            name="Rack Group 7",
+            location=cls.loc3,
+            description="C",
+        )
+        RackGroup.objects.create(
+            name="Rack Group 8",
+            location=cls.loc3,
+        )
 
     def test_children(self):
         child_groups = RackGroup.objects.filter(name__startswith="Child").filter(parent__isnull=False)[:2]
@@ -1161,6 +1181,24 @@ class RackGroupTestCase(FilterTestCases.FilterTestCase):
             params = {"children": [rack_group_4.pk, rack_group_4.pk]}
             self.assertFalse(self.filterset(params, self.queryset).qs.exists())
 
+    def test_ancestors(self):
+        with self.subTest():
+            pk_list = []
+            parent_locations = self.loc3.ancestors(include_self=True)
+            pk_list.extend([v.pk for v in parent_locations])
+            params = Q(location__pk__in=pk_list)
+            expected_queryset = RackGroup.objects.filter(params)
+            params = {"ancestors": [self.loc3.pk]}
+            self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, expected_queryset)
+        with self.subTest():
+            pk_list = []
+            parent_locations = self.loc2.ancestors(include_self=True)
+            pk_list.extend([v.pk for v in parent_locations])
+            params = Q(location__pk__in=pk_list)
+            expected_queryset = RackGroup.objects.filter(params)
+            params = {"ancestors": [self.loc2.pk]}
+            self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, expected_queryset)
+
 
 class RackTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = Rack.objects.all()
@@ -4188,12 +4226,13 @@ class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
 
     @classmethod
     def setUpTestData(cls):
-        device = Device.objects.first()
+        device_1 = Device.objects.first()
+        device_2 = Device.objects.last()
         vdc_status = Status.objects.get_for_model(VirtualDeviceContext)[0]
         interface_status = Status.objects.get_for_model(Interface)[0]
         interfaces = [
             Interface.objects.create(
-                device=device,
+                device=device_1,
                 type=InterfaceTypeChoices.TYPE_1GE_FIXED,
                 name=f"Interface 00{idx}",
                 status=interface_status,
@@ -4202,7 +4241,7 @@ class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
         ]
         vdcs = [
             VirtualDeviceContext.objects.create(
-                device=device,
+                device=device_1,
                 status=vdc_status,
                 identifier=200 + idx,
                 name=f"Test VDC {idx}",
@@ -4213,3 +4252,17 @@ class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
         InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[0])
         InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[1])
         InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[2], interface=interfaces[2])
+        InterfaceVDCAssignment.objects.create(
+            virtual_device_context=VirtualDeviceContext.objects.create(
+                device=device_2,
+                status=vdc_status,
+                identifier=200,
+                name="Test VDC 0",
+            ),
+            interface=Interface.objects.create(
+                device=device_2,
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                name="Interface 000",
+                status=interface_status,
+            ),
+        )

nautobot/dcim/tests/test_models.py

@@ -1166,6 +1166,19 @@ class LocationTypeTestCase(TestCase):
         child_loc.delete()
         child.validated_save()
 
+    def test_removing_content_type(self):
+        """Validation check to prevent removing an in-use content type from a LocationType."""
+
+        location_type = LocationType.objects.get(name="Campus")
+        device_ct = ContentType.objects.get_for_model(Device)
+
+        with self.assertRaises(ValidationError) as cm:
+            location_type.content_types.remove(device_ct)
+        self.assertIn(
+            f"Cannot remove the content type {device_ct} as currently at least one device is associated to a location",
+            str(cm.exception),
+        )
+
 
 class LocationTestCase(ModelTestCases.BaseModelTestCase):
     model = Location
@@ -1895,6 +1908,33 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         parent_device.rack = rack
         parent_device.save()
 
+        # Test assigning a rack in the child location of the parent device location
+        location_status = Status.objects.get_for_model(Location).first()
+        child_location = Location.objects.create(
+            name="Child Location 1",
+            location_type=self.location_type_3,
+            status=location_status,
+            parent=parent_device.location,
+        )
+        child_rack = Rack.objects.create(name="Rack 2", location=child_location, status=self.device_status)
+        parent_device.rack = child_rack
+        parent_device.validated_save()
+
+        # Test assigning a rack outside the child locations of the parent device location
+        new_location = Location.objects.create(
+            name="New Location 1",
+            status=location_status,
+            location_type=self.location_type_3,
+        )
+        invalid_rack = Rack.objects.create(name="Rack 3", location=new_location, status=self.device_status)
+        parent_device.rack = invalid_rack
+        with self.assertRaises(ValidationError) as cm:
+            parent_device.validated_save()
+        self.assertIn(
+            f'Rack "{invalid_rack}" does not belong to location "{parent_device.location}" and its descendants.',
+            str(cm.exception),
+        )
+
         child_mtime_after_parent_rack_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
 
         self.assertNotEqual(child_mtime_after_parent_noop_save, child_mtime_after_parent_rack_update_save)

nautobot/dcim/views.py

@@ -61,7 +61,7 @@ from nautobot.dcim.utils import get_all_network_driver_mappings, get_network_dri
 from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Team
 from nautobot.extras.views import ObjectChangeLogView, ObjectConfigContextView, ObjectDynamicGroupsView
 from nautobot.ipam.models import IPAddress, Prefix, Service, VLAN
-from nautobot.ipam.tables import InterfaceIPAddressTable, InterfaceVLANTable, VRFDeviceAssignmentTable
+from nautobot.ipam.tables import InterfaceIPAddressTable, InterfaceVLANTable, VRFDeviceAssignmentTable, VRFTable
 from nautobot.virtualization.models import VirtualMachine
 from nautobot.wireless.forms import ControllerManagedDeviceGroupWirelessNetworkFormSet
 from nautobot.wireless.models import (
@@ -1922,7 +1922,7 @@ class DeviceView(generic.ObjectView):
 
         # VRF assignments
         vrf_assignments = instance.vrf_assignments.restrict(request.user, "view")
-        vrf_table = VRFDeviceAssignmentTable(vrf_assignments, exclude=("virtual_machine", "device"))
+        vrf_table = VRFDeviceAssignmentTable(vrf_assignments)
 
         # Software images
         if instance.software_version is not None:
@@ -4513,15 +4513,25 @@ class VirtualDeviceContextUIViewSet(NautobotUIViewSet):
     queryset = VirtualDeviceContext.objects.all()
     serializer_class = serializers.VirtualDeviceContextSerializer
     table_class = tables.VirtualDeviceContextTable
-
-    def get_extra_context(self, request, instance):
-        if self.action == "retrieve":
-            interfaces_table = tables.InterfaceTable(
-                instance.interfaces.restrict(request.user, "view"), orderable=False, exclude=("device",)
-            )
-
-            return {
-                "interfaces_table": interfaces_table,
-                **super().get_extra_context(request, instance),
-            }
-        return super().get_extra_context(request, instance)
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            object_detail.ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+            ),
+            object_detail.ObjectsTablePanel(
+                weight=200,
+                table_class=tables.InterfaceTable,
+                table_attribute="interfaces",
+                section=SectionChoices.FULL_WIDTH,
+                exclude_columns=["device"],
+            ),
+            object_detail.ObjectsTablePanel(
+                weight=300,
+                table_class=VRFTable,
+                table_attribute="vrfs",
+                section=SectionChoices.FULL_WIDTH,
+            ),
+        ),
+    )

nautobot/extras/api/mixins.py

@@ -37,7 +37,7 @@ class TaggedModelSerializerMixin(BaseModelSerializer):
 
     def _save_tags(self, instance, tags):
         if tags:
-            instance.tags.set([t.name for t in tags])
+            instance.tags.set(tags)
         else:
             instance.tags.clear()
 

nautobot/extras/api/views.py

@@ -642,7 +642,7 @@ class JobViewSetBase(
             ):
                 raise ValidationError(
                     {
-                        "_task_queue": "_task_queue and _job_queue are both specified. Please specifiy only one or another."
+                        "_task_queue": "_task_queue and _job_queue are both specified. Please specify only one or another."
                     }
                 )
 
@@ -685,7 +685,7 @@ class JobViewSetBase(
                 "job_queue", None
             ):
                 raise ValidationError(
-                    {"task_queue": "task_queue and job_queue are both specified. Please specifiy only one or another."}
+                    {"task_queue": "task_queue and job_queue are both specified. Please specify only one or another."}
                 )
             schedule_data = input_serializer.validated_data.get("schedule", None)
 

nautobot/extras/filters/__init__.py

@@ -854,6 +854,10 @@ class JobFilterSet(BaseFilterSet, CustomFieldModelFilterSetMixin):
             "description": "icontains",
         },
     )
+    job_queues = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=JobQueue.objects.all(),
+        label="Job Queue (name or ID)",
+    )
 
     class Meta:
         model = Job

nautobot/extras/models/datasources.py

@@ -131,16 +131,20 @@ class GitRepository(PrimaryModel):
 
     def get_latest_sync(self):
         """
-        Return a `JobResult` for the latest sync operation.
+        Return a `JobResult` for the latest sync operation if one has occurred.
 
         Returns:
-            JobResult
+            Returns a `JobResult` if the repo has been synced before, otherwise returns None.
         """
         from nautobot.extras.models import JobResult
 
         # This will match all "GitRepository" jobs (pull/refresh, dry-run, etc.)
         prefix = "nautobot.core.jobs.GitRepository"
-        return JobResult.objects.filter(task_name__startswith=prefix, task_kwargs__repository=self.pk).latest()
+
+        if JobResult.objects.filter(task_name__startswith=prefix, task_kwargs__repository=self.pk).exists():
+            return JobResult.objects.filter(task_name__startswith=prefix, task_kwargs__repository=self.pk).latest()
+        else:
+            return None
 
     def to_csv(self):
         return (

nautobot/extras/plugins/__init__.py

@@ -728,6 +728,31 @@ def register_plugin_menu_items(section_name, menu_items):
 #
 
 
+class CustomValidatorContext(dict):
+    def __init__(self, obj):
+        """
+        If there is an active change context, meaning we are in a web request context,
+        we have access to the current user object. Otherwise, we are likely running inside
+        a management command or other non-web or non-Job context, and we should use an AnonymousUser.
+        This ensures people's custom validators don't outright break when running in non-web
+        contexts, and should generally provide a sane default, given validation based on the
+        user is commonly going to be least-privelege based, and thus the AnonymousUser will
+        cause such validation logic to fail closed.
+        """
+        from django.contrib.auth.models import AnonymousUser
+
+        from nautobot.extras.signals import change_context_state
+
+        change_context = change_context_state.get()
+        user = None
+        if change_context:
+            user = change_context.get_user()
+        if user is None:
+            user = AnonymousUser()
+
+        super().__init__(object=obj, user=user)
+
+
 class CustomValidator:
     """
     This class is used to register plugin custom model validators which act on specified models. It contains the clean
@@ -742,7 +767,7 @@ class CustomValidator:
     model = None
 
     def __init__(self, obj):
-        self.context = {"object": obj}
+        self.context = CustomValidatorContext(obj)
 
     def validation_error(self, message):
         """

nautobot/extras/templates/extras/inc/jobresult.html

@@ -12,45 +12,43 @@
         <strong>Summary of Results</strong>
     </div>
     <table class="table table-hover panel-body">
-        {% if result.job_model is not None %}
             <tr>
                 <td>Job Description</td>
-                <td>{{ result.job_model.description | render_markdown }}</td>
+                <td>{{ result.job_model.description | render_markdown | placeholder }}</td>
             </tr>
-        {% endif %}
         <tr>
             <td>Status</td>
             <td><span id="pending-result-label">{% include 'extras/inc/job_label.html' with result=result %}</span></td>
         </tr>
         <tr>
             <td>Started at</td>
-            <td>{{ result.date_created }}</td>
+            <td>{{ result.date_created | placeholder }}</td>
         </tr>
         <tr>
             <td>User</td>
-            <td>{{ result.user }}</td>
+            <td>{{ result.user | placeholder }}</td>
         </tr>
         <tr>
             <td>Duration</td>
             <td>
-            {% if result.date_done %}
-                {{ result.duration }}
-            {% else %}
+            {% if result.date_created and not result.date_done %}
                 <img src="{% static 'img/ajax-loader.gif' %}">
+            {% else %}
+                {{ result.duration | placeholder}}
             {% endif %}
             </td>
         </tr>
         <tr>
             <td>Return Value</td>
             <td>
-            {% if result.date_done %}
+            {% if result.date_created and not result.date_done %}
+                <img src="{% static 'img/ajax-loader.gif' %}">
+            {% else %}
                 {% if result.result %}
                     <pre>{{ result.result | render_json }}</pre>
                 {% else %}
                     {{ result.result | placeholder }}
                 {% endif %}
-            {% else %}
-                <img src="{% static 'img/ajax-loader.gif' %}">
             {% endif %}
             </td>
         </tr>
@@ -89,6 +87,7 @@
             <input class="form-control" id="log-filter" type="text" placeholder="Filter log level or message" title="Filter log level or message" style="height: 23px" />
         </div>
     </div>
-    {% ajax_table "log_table" "extras:jobresult_log-table" pk=result.pk %}
+    {% if result and result.pk %}
+        {% ajax_table "log_table" "extras:jobresult_log-table" pk=result.pk %}
+    {% endif %}
 </div>
-