nautobot 2.4.8__py3-none-any.whl → 2.4.9__py3-none-any.whl

nautobot/dcim/views.py

@@ -686,6 +686,45 @@ class RackReservationUIViewSet(NautobotUIViewSet):
     table_class = tables.RackReservationTable
     queryset = RackReservation.objects.all()
 
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            object_detail.KeyValueTablePanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                label="Rack",
+                context_data_key="rack_data",
+            ),
+            object_detail.ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                label="Reservation Details",
+                fields=["unit_list", "tenant", "user", "description"],
+            ),
+            object_detail.Panel(
+                section=SectionChoices.RIGHT_HALF,
+                weight=100,
+                template_path="dcim/rack_elevation.html",
+            ),
+        ),
+    )
+
+    def get_extra_context(self, request, instance):
+        context = super().get_extra_context(request, instance)
+        if self.action == "retrieve":
+            context["rack_data"] = self.get_rack_context(instance)
+        return context
+
+    def get_rack_context(self, instance):
+        rack = getattr(instance, "rack", None)
+        if not rack:
+            return {}
+
+        return {
+            "location": rack.location,
+            "rack_group": rack.rack_group,
+            "rack": rack,
+        }
+
     def get_object(self):
         obj = super().get_object()
 
@@ -743,20 +782,18 @@ class ManufacturerUIViewSet(NautobotUIViewSet):
 #
 # Device types
 #
-
-
-class DeviceTypeListView(generic.ObjectListView):
-    queryset = DeviceType.objects.all()
-    filterset = filters.DeviceTypeFilterSet
-    filterset_form = forms.DeviceTypeFilterForm
-    table = tables.DeviceTypeTable
-    template_name = "dcim/devicetype_list.html"
-
-
-class DeviceTypeView(generic.ObjectView):
+class DeviceTypeUIViewSet(NautobotUIViewSet):
+    bulk_update_form_class = forms.DeviceTypeBulkEditForm
+    filterset_class = filters.DeviceTypeFilterSet
+    filterset_form_class = forms.DeviceTypeFilterForm
+    form_class = forms.DeviceTypeForm
+    serializer_class = serializers.DeviceTypeSerializer
+    table_class = tables.DeviceTypeTable
     queryset = DeviceType.objects.select_related("manufacturer").prefetch_related("software_image_files")
 
     def get_extra_context(self, request, instance):
+        if self.action != "retrieve":
+            return {}
         instance_count = Device.objects.restrict(request.user).filter(device_type=instance).count()
 
         # Component tables
@@ -831,16 +868,6 @@ class DeviceTypeView(generic.ObjectView):
         }
 
 
-class DeviceTypeEditView(generic.ObjectEditView):
-    queryset = DeviceType.objects.all()
-    model_form = forms.DeviceTypeForm
-    template_name = "dcim/devicetype_edit.html"
-
-
-class DeviceTypeDeleteView(generic.ObjectDeleteView):
-    queryset = DeviceType.objects.all()
-
-
 class DeviceTypeImportView(generic.ObjectImportView):
     additional_permissions = [
         "dcim.add_devicetype",
@@ -871,19 +898,6 @@ class DeviceTypeImportView(generic.ObjectImportView):
     )
 
 
-class DeviceTypeBulkEditView(generic.BulkEditView):
-    queryset = DeviceType.objects.all()
-    filterset = filters.DeviceTypeFilterSet
-    table = tables.DeviceTypeTable
-    form = forms.DeviceTypeBulkEditForm
-
-
-class DeviceTypeBulkDeleteView(generic.BulkDeleteView):
-    queryset = DeviceType.objects.all()
-    filterset = filters.DeviceTypeFilterSet
-    table = tables.DeviceTypeTable
-
-
 #
 # Module types
 #
@@ -3381,13 +3395,42 @@ class ModuleBayUIViewSet(ModuleBayCommonViewSetMixin, NautobotUIViewSet):
     table_class = tables.ModuleBayTable
     create_template_name = "dcim/device_component_add.html"
 
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            object_detail.ObjectFieldsPanel(
+                weight=100,
+                section=SectionChoices.LEFT_HALF,
+                fields="__all__",
+                hide_if_unset=("parent_device", "parent_module"),
+            ),
+            object_detail.ObjectFieldsPanel(
+                weight=100,
+                section=SectionChoices.RIGHT_HALF,
+                context_object_key="installed_module_data",
+                label="Installed Module",
+            ),
+        )
+    )
+
     def get_extra_context(self, request, instance):
+        context = super().get_extra_context(request, instance)
+
         if instance:
-            return {
-                "device_breadcrumb_url": "dcim:device_modulebays",
-                "module_breadcrumb_url": "dcim:module_modulebays",
-            }
-        return {}
+            # Set breadcrumbs always
+            context.update(
+                {
+                    "device_breadcrumb_url": "dcim:device_modulebays",
+                    "module_breadcrumb_url": "dcim:module_modulebays",
+                }
+            )
+
+            # Add installed module context
+            context["installed_module_data"] = self._get_installed_module_context(instance)
+
+        return context
+
+    def _get_installed_module_context(self, instance):
+        return getattr(instance, "installed_module", None)
 
     def get_selected_objects_parents_name(self, selected_objects):
         selected_object = selected_objects.first()
@@ -4135,18 +4178,32 @@ class DeviceRedundancyGroupUIViewSet(NautobotUIViewSet):
     serializer_class = serializers.DeviceRedundancyGroupSerializer
     table_class = tables.DeviceRedundancyGroupTable
 
-    def get_extra_context(self, request, instance):
-        context = super().get_extra_context(request, instance)
-
-        if self.action == "retrieve" and instance:
-            devices = instance.devices_sorted.restrict(request.user)
-            devices_table = tables.DeviceTable(devices)
-            devices_table.columns.show("device_redundancy_group_priority")
-            context["devices_table"] = devices_table
-            controllers = instance.controllers_sorted.restrict(request.user)
-            controllers_table = tables.ControllerTable(controllers)
-            context["controllers_table"] = controllers_table
-        return context
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            object_detail.ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+            ),
+            object_detail.ObjectsTablePanel(
+                section=SectionChoices.FULL_WIDTH,
+                weight=100,
+                table_class=tables.ControllerTable,
+                table_attribute="controllers_sorted",
+                related_field_name="controller_device_redundancy_group",
+            ),
+            object_detail.ObjectsTablePanel(
+                section=SectionChoices.FULL_WIDTH,
+                weight=200,
+                table_class=tables.DeviceTable,
+                table_attribute="devices_sorted",
+                related_field_name="device_redundancy_group",
+                include_columns=[
+                    "device_redundancy_group_priority",
+                ],
+            ),
+        )
+    )
 
 
 class InterfaceRedundancyGroupUIViewSet(NautobotUIViewSet):
@@ -4211,36 +4268,31 @@ class DeviceFamilyUIViewSet(NautobotUIViewSet):
     serializer_class = serializers.DeviceFamilySerializer
     table_class = tables.DeviceFamilyTable
     lookup_field = "pk"
-
-    def get_extra_context(self, request, instance):
-        # Related device types table
-        context = super().get_extra_context(request, instance)
-        if self.action == "retrieve":
-            device_types = (
-                DeviceType.objects.restrict(request.user, "view")
-                .filter(device_family=instance)
-                .select_related("manufacturer")
-                .annotate(device_count=count_related(Device, "device_type"))
-            )
-            device_type_table = tables.DeviceTypeTable(device_types, orderable=False)
-
-            paginate = {
-                "paginator_class": EnhancedPaginator,
-                "per_page": get_paginate_count(request),
-            }
-            RequestConfig(request, paginate).configure(device_type_table)
-
-            context["device_type_table"] = device_type_table
-
-            total_devices = 0
-            device_type_count = 0
-            for device_type in device_types:
-                total_devices += device_type.device_count
-                device_type_count += 1
-            context["total_devices"] = total_devices
-            context["device_type_count"] = device_type_count
-
-        return context
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            object_detail.ObjectFieldsPanel(
+                weight=100,
+                section=SectionChoices.LEFT_HALF,
+                fields="__all__",
+            ),
+            object_detail.ObjectsTablePanel(
+                weight=100,
+                section=SectionChoices.FULL_WIDTH,
+                table_class=tables.DeviceTypeTable,
+                table_filter="device_family",
+                select_related_fields=["manufacturer"],
+                exclude_columns=["device_family"],
+            ),
+            object_detail.ObjectsTablePanel(
+                weight=200,
+                section=SectionChoices.FULL_WIDTH,
+                table_class=tables.DeviceTable,
+                table_filter="device_type__device_family",
+                related_field_name="device_family",
+                exclude_columns=["device_family"],
+            ),
+        )
+    )
 
 
 #

nautobot/extras/api/views.py

@@ -703,10 +703,8 @@ class JobViewSetBase(
             # of errors under messages
             return Response({"errors": e.message_dict if hasattr(e, "error_dict") else e.messages}, status=400)
 
-        queue = get_job_queue(task_queue)
-        if queue is None:
-            queue = job_model.default_job_queue
-        if queue.queue_type == JobQueueTypeChoices.TYPE_CELERY and not get_worker_count(queue=task_queue):
+        job_queue = get_job_queue(task_queue) or job_model.default_job_queue
+        if job_queue.queue_type == JobQueueTypeChoices.TYPE_CELERY and not get_worker_count(queue=task_queue):
             raise CeleryWorkerNotRunningException(queue=task_queue)
 
         # Default to a null JobResult.
@@ -737,7 +735,7 @@ class JobViewSetBase(
                 interval=schedule_data.get("interval"),
                 crontab=schedule_data.get("crontab", ""),
                 approval_required=approval_required,
-                task_queue=task_queue,
+                job_queue=job_queue,
                 **job_class.serialize_data(cleaned_data),
             )
         else:
@@ -748,7 +746,7 @@ class JobViewSetBase(
             job_result = JobResult.enqueue_job(
                 job_model,
                 request.user,
-                task_queue=task_queue,
+                job_queue=job_queue,
                 **job_class.serialize_data(cleaned_data),
             )
 

nautobot/extras/migrations/0024_job_data_migration.py

@@ -52,7 +52,7 @@ def migrate_job_data(apps, schema_editor):
 
     # Shouldn't be needed but I've seen cases where it happens - not sure exactly why
     for job_jobresult in JobResult.objects.filter(obj_type__model="jobmodel"):
-        print("Fixing up content type on {job_jobresult}")
+        print(f"Fixing up content type on {job_jobresult}")
         job_jobresult.obj_type = job_ct
         job_jobresult.save()
 

nautobot/extras/models/jobs.py

@@ -1,10 +1,11 @@
 # Data models relating to Jobs
 
 import contextlib
-from datetime import timedelta
+from datetime import datetime, timedelta
 import json
 import logging
 import signal
+from typing import Optional, TYPE_CHECKING, Union
 
 from billiard.exceptions import SoftTimeLimitExceeded
 from celery.exceptions import NotRegistered
@@ -58,6 +59,11 @@ from nautobot.extras.utils import (
 
 from .customfields import CustomFieldModel
 
+if TYPE_CHECKING:
+    from django.contrib.auth import get_user_model
+
+    User = get_user_model()
+
 logger = logging.getLogger(__name__)
 
 
@@ -329,12 +335,12 @@ class Job(PrimaryModel):
             raise NotRegistered from err
 
     @property
-    def task_queues(self):
+    def task_queues(self) -> list[str]:
         """Deprecated backward-compatibility property for the list of queue names for this Job."""
         return self.job_queues.values_list("name", flat=True)
 
     @task_queues.setter
-    def task_queues(self, value):
+    def task_queues(self, value: Union[str, list[str]]):
         job_queues = []
         # value is going to be a comma separated list of queue names
         if isinstance(value, str):
@@ -748,49 +754,34 @@ class JobResult(BaseModel, CustomFieldModel):
                 )
 
     @classmethod
-    def execute_job(cls, job_model, user, *job_args, celery_kwargs=None, profile=False, job_result=None, **job_kwargs):
+    def execute_job(cls, *args, **kwargs):
         """
         Create a JobResult instance and run a job in the current process, blocking until the job finishes.
 
         Running tasks synchronously in celery is *NOT* supported and if possible `enqueue_job` with synchronous=False
         should be used instead.
 
-        Args:
-            job_model (Job): The Job to be enqueued for execution
-            user (User): User object to link to the JobResult instance
-            celery_kwargs (dict, optional): Dictionary of kwargs to pass as **kwargs to Celery when job is run
-            profile (bool, optional): Whether to run cProfile on the job execution
-            job_result (JobResult, optional): Existing JobResult with status PENDING, used in kubernetes job execution
-            *job_args: positional args passed to the job task
-            **job_kwargs: keyword args passed to the job task
+        Args: see `enqueue_job()`
 
         Returns:
             JobResult instance
         """
-        return cls.enqueue_job(
-            job_model,
-            user,
-            *job_args,
-            celery_kwargs=celery_kwargs,
-            profile=profile,
-            job_result=job_result,
-            synchronous=True,
-            **job_kwargs,
-        )
+        return cls.enqueue_job(*args, **kwargs, synchronous=True)
 
     @classmethod
     def enqueue_job(
         cls,
-        job_model,
-        user,
+        job_model: Job,
+        user: "User",
         *job_args,
-        celery_kwargs=None,
-        profile=False,
-        schedule=None,
-        task_queue=None,
-        job_result=None,
-        synchronous=False,
-        ignore_singleton_lock=False,
+        celery_kwargs: Optional[dict] = None,
+        profile: bool = False,
+        schedule: Optional["ScheduledJob"] = None,
+        job_queue: Optional["JobQueue"] = None,
+        task_queue: Optional[str] = None,  # deprecated!
+        job_result: Optional["JobResult"] = None,
+        synchronous: bool = False,
+        ignore_singleton_lock: bool = False,
         **job_kwargs,
     ):
         """Create/Modify a JobResult instance and enqueue a job to be executed asynchronously by a Celery worker.
@@ -798,13 +789,16 @@ class JobResult(BaseModel, CustomFieldModel):
         Args:
             job_model (Job): The Job to be enqueued for execution.
             user (User): User object to link to the JobResult instance.
-            celery_kwargs (dict, optional): Dictionary of kwargs to pass as **kwargs to `apply_async()`/`apply()` when job is run.
-            profile (bool, optional): If True, dump cProfile stats on the job execution.
-            schedule (ScheduledJob, optional): ScheduledJob instance to link to the JobResult. Cannot be used with synchronous=True.
-            task_queue (str, optional): The celery queue to send the job to. If not set, use the default celery queue.
-            job_result (JobResult, optional): Existing JobResult with status PENDING, to be modified and to be used in kubernetes job execution.
-            synchronous (bool, optional): If True, run the job in the current process, blocking until the job completes.
-            ignore_singleton_lock (bool, optional): If True, invalidate the singleton lock before running the job.
+            celery_kwargs (dict): Dictionary of kwargs to pass as **kwargs to `apply_async()`/`apply()` when job is run.
+            profile (bool): If True, dump cProfile stats on the job execution.
+            schedule (ScheduledJob): ScheduledJob instance to link to the JobResult.
+                Cannot be used with synchronous=True.
+            job_queue (JobQueue): Job queue to send the job to. If not set, use the default queue for the given Job.
+            task_queue (str): The celery queue name to send the job to. **Deprecated, prefer `job_queue` instead.**
+            job_result (JobResult): Existing JobResult with status PENDING, to be modified and to be used
+                in kubernetes job execution.
+            synchronous (bool): If True, run the job in the current process, blocking until the job completes.
+            ignore_singleton_lock (bool): If True, invalidate the singleton lock before running the job.
               This allows singleton jobs to run twice, or makes it possible to remove the lock when the first instance
               of the job failed to remove it for any reason.
             *job_args: positional args passed to the job task (UNUSED)
@@ -818,6 +812,20 @@ class JobResult(BaseModel, CustomFieldModel):
         if schedule is not None and synchronous:
             raise ValueError("Scheduled jobs cannot be run synchronously")
 
+        if job_queue is not None and task_queue is not None and job_queue.name != task_queue:
+            raise ValueError("task_queue and job_queue are mutually exclusive")
+        if job_queue is not None and task_queue is None:
+            task_queue = job_queue.name
+        elif task_queue is not None and job_queue is None:
+            job_queue = JobQueue.objects.get(name=task_queue)
+        else:  # both none
+            if celery_kwargs is not None and "queue" in celery_kwargs:
+                task_queue = celery_kwargs["queue"]
+                job_queue = JobQueue.objects.get(name=task_queue)
+            else:
+                job_queue = job_model.default_job_queue
+                task_queue = job_queue.name
+
         if job_result is None:
             job_result = cls.objects.create(
                 name=job_model.name,
@@ -835,10 +843,6 @@ class JobResult(BaseModel, CustomFieldModel):
                     f"There is a mismatch between the job specified {job_model} and the job associated with the job result {job_result.job_model}"
                 )
 
-        if task_queue is None:
-            task_queue = job_model.default_job_queue.name
-
-        job_queue = JobQueue.objects.get(name=task_queue)
         # Kubernetes Job Queue logic
         # As we execute Kubernetes jobs, we want to execute `run_kubernetes_job_and_return_job_result`
         # the first time the kubernetes job is enqueued to spin up the kubernetes pod.
@@ -863,6 +867,7 @@ class JobResult(BaseModel, CustomFieldModel):
             job_celery_kwargs["time_limit"] = job_model.time_limit
 
         if celery_kwargs is not None:
+            # TODO: this lets celery_kwargs override keys like `queue` and `nautobot_job_user_id`; is that desirable?
             job_celery_kwargs.update(celery_kwargs)
 
         if synchronous:
@@ -1208,7 +1213,6 @@ class ScheduledJob(BaseModel):
         ordering = ["name"]
 
     def save(self, *args, **kwargs):
-        self.queue = self.queue or ""
         # make sure non-valid crontab doesn't get saved
         if self.interval == JobExecutionType.TYPE_CUSTOM:
             try:
@@ -1253,12 +1257,12 @@ class ScheduledJob(BaseModel):
         return self.to_cron()
 
     @property
-    def queue(self):
+    def queue(self) -> str:
         """Deprecated backward-compatibility property for the queue name this job is scheduled for."""
         return self.job_queue.name if self.job_queue else ""
 
     @queue.setter
-    def queue(self, value):
+    def queue(self, value: str):
         if value:
             try:
                 self.job_queue = JobQueue.objects.get(name=value)
@@ -1301,14 +1305,15 @@ class ScheduledJob(BaseModel):
         cls,
         job_model,
         user,
-        name=None,
-        start_time=None,
-        interval=JobExecutionType.TYPE_IMMEDIATELY,
-        crontab="",
-        profile=False,
-        approval_required=False,
-        task_queue=None,
-        ignore_singleton_lock=False,
+        name: Optional[str] = None,
+        start_time: Optional[datetime] = None,
+        interval: str = JobExecutionType.TYPE_IMMEDIATELY,
+        crontab: str = "",
+        profile: bool = False,
+        approval_required: bool = False,
+        job_queue: Optional[JobQueue] = None,
+        task_queue: Optional[str] = None,  # deprecated!
+        ignore_singleton_lock: bool = False,
         **job_kwargs,
     ):
         """
@@ -1321,21 +1326,32 @@ class ScheduledJob(BaseModel):
         Parameters:
             job_model (JobModel): The job model instance.
             user (User): The user who is scheduling the job.
-            name (str, optional): The name of the scheduled job. Defaults to None.
-            start_time (datetime, optional): The start time for the job. Defaults to None.
-            interval (JobExecutionType, optional): The interval type for the job execution.
+            name (str): The name of the scheduled job. Automatically derived from the job_model and start_time if unset.
+            start_time (datetime): The start time for the job. Defaults to the current time if unset.
+            interval (JobExecutionType): The interval type for the job execution.
                 Defaults to JobExecutionType.TYPE_IMMEDIATELY.
-            crontab (str, optional): The crontab string for the schedule. Defaults to "".
-            profile (bool, optional): Flag indicating whether to profile the job. Defaults to False.
-            approval_required (bool, optional): Flag indicating if approval is required. Defaults to False.
-            task_queue (str, optional): The task queue for the job. Defaults to None, which will use the configured default celery queue.
-            ignore_singleton_lock (bool, optional): Flag indicating whether to ignore singleton locks. Defaults to False.
+            crontab (str): The crontab string for the schedule. Defaults to "".
+            profile (bool): Flag indicating whether to profile the job. Defaults to False.
+            approval_required (bool): Flag indicating if approval is required. Defaults to False.
+            job_queue (JobQueue): The Job queue to use. If unset, use the configured default celery queue.
+            task_queue (str): The queue name to use. **Deprecated, prefer `job_queue`.**
+            ignore_singleton_lock (bool): Whether to ignore singleton locks. Defaults to False.
             **job_kwargs: Additional keyword arguments to pass to the job.
 
         Returns:
             ScheduledJob instance
         """
 
+        if job_queue is not None and task_queue is not None and job_queue.name != task_queue:
+            raise ValueError("task_queue and job_queue are mutually exclusive")
+        if job_queue is not None and task_queue is None:
+            task_queue = job_queue.name
+        elif task_queue is not None and job_queue is None:
+            job_queue = JobQueue.objects.get(name=task_queue)
+        else:  # both None
+            job_queue = job_model.default_job_queue
+            task_queue = job_queue.name
+
         if interval == JobExecutionType.TYPE_IMMEDIATELY:
             start_time = timezone.localtime()
             name = name or f"{job_model.name} - {start_time}"
@@ -1376,7 +1392,7 @@ class ScheduledJob(BaseModel):
             user=user,
             approval_required=approval_required,
             crontab=crontab,
-            queue=task_queue,
+            job_queue=job_queue,
         )
         scheduled_job.validated_save()
         return scheduled_job

nautobot/extras/tables.py

@@ -40,6 +40,7 @@ from .models import (
     JobLogEntry,
     JobQueue,
     JobResult,
+    MetadataChoice,
     MetadataType,
     Note,
     ObjectChange,
@@ -730,7 +731,7 @@ class JobTable(BaseTable):
         accessor="latest_result",
         template_code="""
             {% if value %}
-                {{ value.created }} by {{ value.user }}
+                {{ value.date_created|date:settings.SHORT_DATETIME_FORMAT }} by {{ value.user }}
             {% else %}
                 <span class="text-muted">Never</span>
             {% endif %}
@@ -1008,6 +1009,15 @@ class MetadataTypeTable(BaseTable):
         )
 
 
+class MetadataChoiceTable(BaseTable):
+    value = tables.Column()
+    weight = tables.Column()
+
+    class Meta(BaseTable.Meta):
+        model = MetadataChoice
+        fields = ("value", "weight")
+
+
 class ObjectMetadataTable(BaseTable):
     pk = ToggleColumn()
     # NOTE: there is no identity column in this table; this is intentional as we have no detail view for ObjectMetadata

nautobot/extras/templates/extras/computedfield_retrieve.html

@@ -1,56 +1,2 @@
 {% extends 'generic/object_retrieve.html' %}
-{% load helpers %}
-
-{% block content_left_page %}
-            <div class="panel panel-default">
-                <div class="panel-heading">
-                    <strong>Computed Field</strong>
-                </div>
-
-                <table class="table table-hover panel-body attr-table">
-                    <tr>
-                        <td>Content Type</td>
-                        <td><span>{{ object.content_type }}</span></td>
-                    </tr>
-                    <tr>
-                        <td>Label</td>
-                        <td><span>{{ object.label }}</span></td>
-                    </tr>
-                    <tr>
-                        <td>Key</td>
-                        <td><span>{{ object.key }}</span></td>
-                    </tr>
-                    <tr>
-                        <td>Grouping</td>
-                        <td>{{ object.grouping | placeholder }}</td>
-                    </tr>
-                    <tr>
-                        <td>Description</td>
-                        <td><span>{{ object.description|placeholder }}</span></td>
-                    </tr>
-                    <tr>
-                        <td>Fallback Value</td>
-                        <td><span>{{ object.fallback_value }}</span></td>
-                    </tr>
-                    <tr>
-                        <td>Weight</td>
-                        <td><span>{{ object.weight }}</span></td>
-                    </tr>
-                    <tr>
-                        <td>Move to Advanced Tab</td>
-                        <td><span>{{ object.advanced_ui | render_boolean }}</span></td>
-                    </tr>
-                </table>
-            </div>
-{% endblock content_left_page %}
-
-{% block content_full_width_page %}
-            <div class="panel panel-default">
-                <div class="panel-heading">
-                    <strong>Template</strong>
-                </div>
-                <div class="panel-body">
-                    <pre>{{ object.template }}</pre>
-                </div>
-            </div>
-{% endblock content_full_width_page %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}