nautobot 2.3.16__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/core/tests/test_templatetags_helpers.py

@@ -57,6 +57,11 @@ class NautobotTemplatetagsHelperTest(TestCase):
         self.assertEqual(helpers.placeholder([]), '<span class="text-muted">&mdash;</span>')
         self.assertEqual(helpers.placeholder("something"), "something")
 
+    def test_pre_tag(self):
+        self.assertEqual(helpers.pre_tag(None), "<pre>None</pre>")
+        self.assertEqual(helpers.pre_tag([]), "<pre>[]</pre>")
+        self.assertEqual(helpers.pre_tag("something"), "<pre>something</pre>")
+
     def test_add_html_id(self):
         # Case where what we have isn't actually a HTML element but just a bare string
         self.assertEqual(helpers.add_html_id("hello", "my-id"), "hello")
@@ -322,3 +327,14 @@ class NautobotTemplatetagsHelperTest(TestCase):
             helpers.hyperlinked_object_target_new_tab(location, "foo"),
             f'<a href="/dcim/locations/{location.pk}/" title="An important location" target="_blank" rel="noreferrer">{location!s}</a>',
         )
+
+    def test_dbm(self):
+        self.assertEqual(
+            helpers.dbm(12),
+            "12 dBm",
+        )
+        self.assertEqual(
+            helpers.dbm(-85),
+            "-85 dBm",
+        )
+        self.assertEqual(helpers.dbm(None), helpers.placeholder(None))

nautobot/core/tests/test_ui.py

@@ -0,0 +1,150 @@
+"""Test cases for nautobot.core.ui module."""
+
+from unittest.mock import patch
+
+from django.template import Context
+
+from nautobot.core.templatetags.helpers import HTML_NONE
+from nautobot.core.testing import TestCase
+from nautobot.core.ui.object_detail import BaseTextPanel, DataTablePanel, Panel
+
+
+class DataTablePanelTest(TestCase):
+    def test_init(self):
+        # Minimal arguments
+        DataTablePanel(context_data_key="data", weight=100)
+
+        # Conflicting arguments
+        with self.assertRaises(ValueError):
+            DataTablePanel(context_data_key="data", weight=100, columns=[1, 2, 3], context_columns_key="columns")
+        with self.assertRaises(ValueError):
+            DataTablePanel(
+                context_data_key="data",
+                weight=100,
+                column_headers=[1, 2, 3],
+                context_column_headers_key="column_headers",
+            )
+
+        # Maximal arguments
+        DataTablePanel(context_data_key="data", weight=100, columns=[1, 2, 3], column_headers=["One", "Two", "Three"])
+        DataTablePanel(context_data_key="data", weight=100, context_columns_key="c", context_column_headers_key="ch")
+
+    def test_get_columns(self):
+        context = Context({"data": [{1: 1, 2: 2, 3: 3}, {1: 10, 2: 20, 3: 30}], "columns": [1, 3]})
+
+        self.assertEqual(DataTablePanel(context_data_key="data", weight=100).get_columns(context), [1, 2, 3])
+        self.assertEqual(
+            DataTablePanel(context_data_key="data", weight=100, columns=[1, 2]).get_columns(context), [1, 2]
+        )
+        self.assertEqual(
+            DataTablePanel(context_data_key="data", weight=100, context_columns_key="columns").get_columns(context),
+            [1, 3],
+        )
+
+    def test_get_column_headers(self):
+        context = Context(
+            {
+                "data": [{1: 1, 2: 2, 3: 3}, {1: 10, 2: 20, 3: 30}],
+                "columns": [1, 3],
+                "column_headers": ["One", "Three"],
+            }
+        )
+
+        self.assertEqual(DataTablePanel(context_data_key="data", weight=100).get_column_headers(context), [])
+        self.assertEqual(
+            DataTablePanel(context_data_key="data", weight=100, column_headers=["one", "two"]).get_column_headers(
+                context
+            ),
+            ["one", "two"],
+        )
+        self.assertEqual(
+            DataTablePanel(
+                context_data_key="data", weight=100, context_column_headers_key="column_headers"
+            ).get_column_headers(context),
+            ["One", "Three"],
+        )
+
+
+class BaseTextPanelTest(TestCase):
+    def test_init_set_object_params(self):
+        # Test default settings
+        panel = BaseTextPanel(weight=100)
+        self.assertEqual(panel.render_as, BaseTextPanel.RenderOptions.MARKDOWN)
+        self.assertTrue(panel.render_placeholder)
+
+        # Test initialization with custom arguments
+        panel = BaseTextPanel(weight=100, render_as=BaseTextPanel.RenderOptions.JSON, render_placeholder=False)
+        self.assertEqual(panel.render_as, BaseTextPanel.RenderOptions.JSON)
+        self.assertFalse(panel.render_placeholder)
+
+    @patch.object(Panel, "__init__")
+    def test_init_passes_args_and_kwargs(self, panel_init_mock):
+        custom_template_path = "custom_template_path.html"
+
+        BaseTextPanel(weight=100, body_content_template_path=custom_template_path)
+
+        panel_init_mock.assert_called_once_with(weight=100, body_content_template_path=custom_template_path)
+
+    @patch.object(BaseTextPanel, "get_value")
+    def test_render_body_content(self, get_value_mock):
+        test_cases = [
+            {
+                "render_as": BaseTextPanel.RenderOptions.JSON,
+                "value": {"key": "value"},
+                "expected_output": '<pre><code class="language-json">{    &quot;key&quot;: &quot;value&quot; }</code></pre>',
+            },
+            {
+                "render_as": BaseTextPanel.RenderOptions.YAML,
+                "value": {"key": "value"},
+                "expected_output": '<pre><code class="language-yaml">key: value</code></pre>',
+            },
+            {
+                "render_as": BaseTextPanel.RenderOptions.MARKDOWN,
+                "value": "# Header",
+                "expected_output": "<h1>Header</h1>",
+            },
+            {
+                "render_as": BaseTextPanel.RenderOptions.CODE,
+                "value": "print('Hello, world!')",
+                "expected_output": "<pre>print(&#x27;Hello, world!&#x27;)</pre>",
+            },
+            {
+                "render_as": BaseTextPanel.RenderOptions.PLAINTEXT,
+                "value": "Simple text",
+                "expected_output": "Simple text",
+            },
+        ]
+
+        for case in test_cases:
+            with self.subTest(render_as=case["render_as"]):
+                panel = BaseTextPanel(weight=100, render_as=case["render_as"])
+
+                get_value_mock.return_value = case["value"]
+                context = Context()
+
+                result = panel.render_body_content(context)
+
+                self.assertHTMLEqual(result, case["expected_output"])
+
+    @patch.object(BaseTextPanel, "get_value")
+    def test_render_body_content_render_placeholder(self, get_value_mock):
+        get_value_mock.return_value = ""
+        context = Context()
+
+        panel = BaseTextPanel(weight=100, render_as=BaseTextPanel.RenderOptions.PLAINTEXT)
+
+        self.assertHTMLEqual(panel.render_body_content(context), HTML_NONE)
+
+    @patch.object(BaseTextPanel, "get_value")
+    def test_render_body_content_not_render_placeholder(self, get_value_mock):
+        get_value_mock.return_value = ""
+        context = Context()
+
+        panel = BaseTextPanel(weight=100, render_as=BaseTextPanel.RenderOptions.PLAINTEXT, render_placeholder=False)
+
+        self.assertHTMLEqual(panel.render_body_content(context), "")
+
+    def test_get_value(self):
+        panel = BaseTextPanel(weight=100)
+        with self.assertRaises(NotImplementedError):
+            panel.get_value({})

nautobot/core/tests/test_utils.py

@@ -20,7 +20,6 @@ from nautobot.dcim import filters as dcim_filters, forms as dcim_forms, models a
 from nautobot.extras import models as extras_models, utils as extras_utils
 from nautobot.extras.choices import ObjectChangeActionChoices, RelationshipTypeChoices
 from nautobot.extras.models import ObjectChange
-from nautobot.extras.registry import registry
 from nautobot.ipam import models as ipam_models
 
 from example_app.models import ExampleModel
@@ -268,14 +267,6 @@ class GetFooForModelTest(TestCase):
                 lookup.get_model_for_view_name("unknown:plugins:example_app:examplemodel_list")
             self.assertEqual(str(err.exception), "Unexpected View Name: unknown:plugins:example_app:examplemodel_list")
 
-    def test_get_table_class_string_from_view_name(self):
-        # Testing UIViewSet
-        self.assertEqual(lookup.get_table_class_string_from_view_name("circuits:circuit_list"), "CircuitTable")
-        # Testing Legacy View
-        self.assertEqual(lookup.get_table_class_string_from_view_name("dcim:location_list"), "LocationTable")
-        # Testing unconventional table name
-        self.assertEqual(lookup.get_table_class_string_from_view_name("ipam:prefix_list"), "PrefixDetailTable")
-
 
 class IsTaggableTest(TestCase):
     def test_is_taggable_true(self):
@@ -882,22 +873,6 @@ class MergeDictsWithoutCollisionTest(TestCase):
         self.assertEqual(str(err.exception), 'Conflicting values for key "a": (1, 2)')
 
 
-class NavigationRelatedUtils(TestCase):
-    def get_all_new_ui_ready_route(self):
-        ui_ready_routes = [
-            "^\\Z",
-            "^dcim/device\\-types/(?P<pk>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/\\Z",
-            "^dcim/device\\-types/\\Z",
-            "^dcim/devices/(?P<pk>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/\\Z",
-            "^dcim/devices/\\Z",
-            "^dcim/locations/(?P<pk>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/\\Z",
-            "^dcim/locations/\\Z",
-            "^ipam/ip\\-addresses/(?P<pk>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/\\Z",
-            "^ipam/ip\\-addresses/\\Z",
-        ]
-        self.assertEqual(sorted(ui_ready_routes), sorted(list(registry["new_ui_ready_routes"])))
-
-
 class TestMigrationUtils(TestCase):
     def test_update_object_change_ct_for_replaced_models(self):
         """Assert update and update reverse of ObjectChange"""

nautobot/core/tests/test_views.py

@@ -1,3 +1,4 @@
+import json
 import re
 from unittest import mock, skipIf
 import urllib.parse
@@ -11,19 +12,22 @@ from django.test.utils import override_script_prefix
 from django.urls import get_script_prefix, reverse
 from prometheus_client.parser import text_string_to_metric_families
 
+from nautobot.circuits.models import Circuit, CircuitType, Provider
 from nautobot.core.constants import GLOBAL_SEARCH_EXCLUDE_LIST
 from nautobot.core.testing import TestCase
 from nautobot.core.testing.api import APITestCase
+from nautobot.core.testing.context import load_event_broker_override_settings
 from nautobot.core.testing.utils import extract_page_body
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.views import NautobotMetricsView
 from nautobot.core.views.mixins import GetReturnURLMixin
 from nautobot.dcim.models.locations import Location
 from nautobot.extras.choices import CustomFieldTypeChoices
-from nautobot.extras.models import FileProxy
+from nautobot.extras.models import FileProxy, Status
 from nautobot.extras.models.customfields import CustomField, CustomFieldChoice
 from nautobot.extras.registry import registry
 from nautobot.users.models import ObjectPermission
+from nautobot.users.utils import serialize_user_without_config_and_views
 
 
 class GetReturnURLMixinTestCase(TestCase):
@@ -318,8 +322,29 @@ class NavAppsUITestCase(TestCase):
     def setUp(self):
         super().setUp()
 
-        self.url = reverse("apps:apps_list")
-        self.item_weight = 100  # TODO: not easy to introspect from the nav menu struct, so hard-code it here for now
+        self.apps_marketplace_url = reverse("apps:apps_marketplace")
+        self.apps_marketplace_item_weight = (
+            100  # TODO: not easy to introspect from the nav menu struct, so hard-code it here for now
+        )
+
+        self.apps_list_url = reverse("apps:apps_list")
+        self.apps_list_item_weight = (
+            200  # TODO: not easy to introspect from the nav menu struct, so hard-code it here for now
+        )
+
+    def test_apps_marketplace_visible(self):
+        """The "Apps Marketplace" menu item should be available to an authenticated user regardless of permissions."""
+        response = self.client.get(reverse("home"))
+        self.assertContains(
+            response,
+            f"""
+            <a href="{self.apps_marketplace_url}"
+                data-item-weight="{self.apps_marketplace_item_weight}">
+                Apps Marketplace
+            </a>
+            """,
+            html=True,
+        )
 
     def test_installed_apps_visible(self):
         """The "Installed Apps" menu item should be available to an authenticated user regardless of permissions."""
@@ -327,8 +352,8 @@ class NavAppsUITestCase(TestCase):
         self.assertContains(
             response,
             f"""
-            <a href="{self.url}"
-                data-item-weight="{self.item_weight}">
+            <a href="{self.apps_list_url}"
+                data-item-weight="{self.apps_list_item_weight}">
                 Installed Apps
             </a>
             """,
@@ -398,6 +423,52 @@ class LoginUITestCase(TestCase):
             response = self.client.get(url)
             self.assertHttpStatus(response, 403)
 
+    @load_event_broker_override_settings(
+        EVENT_BROKERS={
+            "SyslogEventBroker": {
+                "CLASS": "nautobot.core.events.SyslogEventBroker",
+                "TOPICS": {
+                    "INCLUDE": ["*"],
+                },
+            }
+        }
+    )
+    def test_login_logout(self):
+        self.client.logout()
+        self.user.set_password("pass")
+        self.user.save()
+
+        with self.assertLogs("nautobot.events") as cm:
+            self.client.post(
+                reverse("login"),
+                data={
+                    "username": self.user.username,
+                    "password": "pass",
+                },
+            )
+        self.user.refresh_from_db()
+        payload = serialize_user_without_config_and_views(self.user)
+        self.assertEqual(
+            cm.output,
+            [f"INFO:nautobot.events.nautobot.users.user.login:{json.dumps(payload, indent=4)}"],
+        )
+        self.assertTrue(self.user.is_authenticated)
+        self.assertNotIn("password", cm.output)
+        self.assertNotIn("pass", cm.output)
+
+        with self.assertLogs("nautobot.events") as cm:
+            self.client.get(
+                reverse("logout"),
+            )
+        self.user.refresh_from_db()
+        payload = serialize_user_without_config_and_views(self.user)
+        self.assertEqual(
+            cm.output,
+            [f"INFO:nautobot.events.nautobot.users.user.logout:{json.dumps(payload, indent=4)}"],
+        )
+        self.assertNotIn("password", cm.output)
+        self.assertNotIn("pass", cm.output)
+
 
 class MetricsViewTestCase(TestCase):
     def query_and_parse_metrics(self):
@@ -593,33 +664,54 @@ class ExampleViewWithCustomPermissionsTest(TestCase):
         self.user.is_staff = True
         self.user.save()
         response = self.client.get(url)
-        self.assertBodyContains(response, "You are viewing a table of example models")
-
-
-class SearchRobotsTestCase(TestCase):
-    def test_robots_disallowed(self):
-        """
-        Test that the robots.txt file is accessible to all users and defaults to disallowing all bots.
-        """
-        url = reverse("robots_txt")
-        response = self.client.get(url)
         self.assertHttpStatus(response, 200)
-        self.assertBodyContains(response, "User-Agent: *")
-        self.assertBodyContains(response, "Disallow: /")
+        response_body = response.content.decode(response.charset)
+        self.assertIn("You are viewing a table of example models", response_body)
 
-        url = reverse("home")
-        response = self.client.get(url)
-        self.assertContains(response, '<meta name="robots" content="noindex, nofollow">', html=True)
 
-    @override_settings(PUBLISH_ROBOTS_TXT=False)
-    def test_robots_allowed(self):
-        """
-        Test that the robots.txt file is not published if PUBLISH_ROBOTS_TXT is set to False.
-        """
-        url = reverse("robots_txt")
-        response = self.client.get(url)
-        self.assertHttpStatus(response, 404)
+class TestObjectDetailView(TestCase):
+    @override_settings(PAGINATE_COUNT=5)
+    def test_object_table_panel(self):
+        provider = Provider.objects.create(name="A Test Provider 1")
+        circuit_type = CircuitType.objects.create(
+            name="A Test Circuit Type",
+        )
+        circuit_status = Status.objects.get_for_model(Circuit).first()
+
+        circuits = [
+            Circuit(
+                provider=provider,
+                cid=f"00121{x}",
+                circuit_type=circuit_type,
+                status=circuit_status,
+            )
+            for x in range(10)
+        ]
+        Circuit.objects.bulk_create(circuits)
 
-        url = reverse("home")
-        response = self.client.get(url)
-        self.assertNotContains(response, '<meta name="robots" content="noindex, nofollow">', html=True)
+        self.add_permissions("circuits.view_provider", "circuits.view_circuit")
+        url = reverse("circuits:provider", args=(provider.pk,))
+        response = self.client.get(f"{url}?tab=main")
+        self.assertHttpStatus(response, 200)
+        response_data = response.content.decode(response.charset)
+        view_move_url = reverse("circuits:circuit_list") + f"?provider={provider.id}"
+
+        # Assert Badge Count in table panel header
+        panel_header = f"""<div class="panel-heading"><strong>Circuits</strong> <a href="{view_move_url}" class="badge badge-primary">10</a></div>"""
+        self.assertInHTML(panel_header, response_data)
+
+        # Assert view X more btn
+        view_more_btn = f"""<a href="{view_move_url}"><span class="mdi mdi-dots-horizontal" aria-hidden="true"></span>View 5 more circuits</a>"""
+        self.assertInHTML(view_more_btn, response_data)
+
+        # Validate Copy btn on all rows excluding empty rows
+        name_copy = f"""
+        <span class="hover_copy">
+            <span id="_value_name">{provider.name}</span>
+            <button class="btn btn-inline btn-default hover_copy_button" data-clipboard-target="#_value_name">
+                <span class="mdi mdi-content-copy"></span>
+            </button>
+        </span>"""
+        self.assertInHTML(name_copy, response_data)
+        # ASN do not have a value, therefore no copy btn
+        self.assertNotIn("#asn_copy", response_data)

nautobot/core/ui/base.py

@@ -0,0 +1,11 @@
+"""Common base classes and utilities for defining the Nautobot UI."""
+
+
+class PermissionsMixin:
+    """Ensure permissions through init."""
+
+    def __init__(self, permissions=None):
+        """Ensure permissions."""
+        if permissions is not None and not isinstance(permissions, (list, tuple)):
+            raise TypeError("Permissions must be passed as a tuple or list.")
+        self.permissions = set(permissions) if permissions else None

nautobot/core/ui/choices.py

@@ -0,0 +1,44 @@
+"""ChoiceSets for Nautobot UI Framework."""
+
+from nautobot.core.choices import ChoiceSet
+
+
+class LayoutChoices(ChoiceSet):
+    """Page (or more properly tab) column layout choices.
+
+    Attributes:
+        TWO_OVER_ONE (str): Half-width panels will be above full-width panels (value: 2-over-1)
+        ONE_OVER_TWO (str): Full-width panels will be above half-width panels (value: 1-over-2)
+
+        DEFAULT (str): Two columns of half-width panels on top; full-width panels below. (value of TWO_OVER_ONE)
+    """
+
+    TWO_OVER_ONE = "2-over-1"
+    ONE_OVER_TWO = "1-over-2"
+
+    DEFAULT = TWO_OVER_ONE
+
+    CHOICES = (
+        (TWO_OVER_ONE, "Two Columns over One Column"),
+        (ONE_OVER_TWO, "One Column over Two Columns"),
+    )
+
+
+class SectionChoices(ChoiceSet):
+    """Sections of a Layout to assign panels to. Placement of panels is determined by [`LayoutChoices`](./ui.md#nautobot.apps.ui.LayoutChoices) set on `Tab.layout`
+
+    Attributes:
+        LEFT_HALF (str): Left side, half-width (value: left-half)
+        RIGHT_HALF (str): Right side, half-width (value: right-half)
+        FULL_WIDTH (str): Full width (value: full-width)
+    """
+
+    LEFT_HALF = "left-half"
+    RIGHT_HALF = "right-half"
+    FULL_WIDTH = "full-width"
+
+    CHOICES = (
+        (LEFT_HALF, "Left half of page"),
+        (RIGHT_HALF, "Right half of page"),
+        (FULL_WIDTH, "Full width of page"),
+    )

nautobot/core/ui/homepage.py

@@ -0,0 +1,167 @@
+"""Base classes and utilities for defining the Nautobot home page."""
+
+from abc import ABC, abstractmethod
+
+from .base import PermissionsMixin
+
+
+class HomePageBase(ABC):
+    """Base class for homepage layout classes."""
+
+    @property
+    @abstractmethod
+    def initial_dict(self):  # to be implemented by each subclass
+        return {}
+
+    @property
+    @abstractmethod
+    def fixed_fields(self):  # to be implemented by subclass
+        return ()
+
+
+class HomePagePanel(HomePageBase, PermissionsMixin):
+    """Defines properties that can be used for a panel."""
+
+    items = None
+    template_path = None
+
+    @property
+    def initial_dict(self):
+        return {
+            "custom_template": self.custom_template,
+            "custom_data": self.custom_data,
+            "weight": self.weight,
+            "items": {},
+            "permissions": self.permissions,
+            "template_path": self.template_path,
+        }
+
+    @property
+    def fixed_fields(self):
+        return ()
+
+    def __init__(self, name, permissions=None, custom_data=None, custom_template=None, items=None, weight=1000):
+        """
+        Ensure panel properties.
+
+        Args:
+            name (str): The name of the panel.
+            permissions (list): The permissions required to view this panel.
+            custom_data (dict): Custom data to be passed to the custom template.
+            custom_template (str): Name of custom template.
+            items (list): List of items to be rendered in this panel.
+            weight (int): The weight of this panel.
+        """
+        super().__init__(permissions)
+        self.custom_data = custom_data
+        self.custom_template = custom_template
+        self.name = name
+        self.weight = weight
+
+        if items is not None and custom_template is not None:
+            raise ValueError("Cannot specify items and custom_template at the same time.")
+        if items is not None:
+            if not isinstance(items, (list, tuple)):
+                raise TypeError("Items must be passed as a tuple or list.")
+            elif not all(isinstance(item, (HomePageGroup, HomePageItem)) for item in items):
+                raise TypeError("All items defined in a panel must be an instance of HomePageGroup or HomePageItem")
+            self.items = items
+        else:
+            self.items = []
+
+
+class HomePageGroup(HomePageBase, PermissionsMixin):
+    """Defines properties that can be used for a panel group."""
+
+    items = []
+
+    @property
+    def initial_dict(self):
+        return {
+            "items": {},
+            "permissions": self.permissions,
+            "weight": self.weight,
+        }
+
+    @property
+    def fixed_fields(self):
+        return ()
+
+    def __init__(self, name, permissions=None, items=None, weight=1000):
+        """
+        Ensure group properties.
+
+        Args:
+            name (str): The name of the group.
+            permissions (list): The permissions required to view this group.
+            items (list): List of items to be rendered in this group.
+            weight (int): The weight of this group.
+        """
+        super().__init__(permissions)
+        self.name = name
+        self.weight = weight
+
+        if items is not None:
+            if not isinstance(items, (list, tuple)):
+                raise TypeError("Items must be passed as a tuple or list.")
+            elif not all(isinstance(item, HomePageItem) for item in items):
+                raise TypeError("All items defined in a group must be an instance of HomePageItem")
+            self.items = items
+
+
+class HomePageItem(HomePageBase, PermissionsMixin):
+    """Defines properties that can be used for a panel item."""
+
+    items = []
+    template_path = None
+
+    @property
+    def initial_dict(self):
+        return {
+            "custom_template": self.custom_template,
+            "custom_data": self.custom_data,
+            "description": self.description,
+            "link": self.link,
+            "model": self.model,
+            "permissions": self.permissions,
+            "template_path": self.template_path,
+            "weight": self.weight,
+        }
+
+    @property
+    def fixed_fields(self):
+        return ()
+
+    def __init__(
+        self,
+        name,
+        link=None,
+        model=None,
+        custom_template=None,
+        custom_data=None,
+        description=None,
+        permissions=None,
+        weight=1000,
+    ):
+        """
+        Ensure item properties.
+
+        Args:
+            name (str): The name of the item.
+            link (str): The link to be used for this item.
+            model (str): The model to being used for this item to calculate the total count of objects.
+            custom_template (str): Name of custom template.
+            custom_data (dict): Custom data to be passed to the custom template.
+        """
+        super().__init__(permissions)
+
+        self.name = name
+        self.custom_template = custom_template
+        self.custom_data = custom_data
+        self.description = description
+        self.link = link
+        self.model = model
+        self.weight = weight
+
+        if model is not None and custom_template is not None:
+            raise ValueError("Cannot specify model and custom_template at the same time.")