nautobot 2.3.9__py3-none-any.whl → 2.3.11__py3-none-any.whl

nautobot/apps/utils.py

@@ -30,6 +30,7 @@ from nautobot.core.utils.lookup import (
     get_form_for_model,
     get_model_from_name,
     get_related_class_for_model,
+    get_related_field_for_models,
     get_route_for_model,
     get_table_for_model,
     get_url_for_url_pattern,
@@ -111,6 +112,7 @@ __all__ = (
     "get_only_new_ui_ready_routes",
     "get_permission_for_model",
     "get_related_class_for_model",
+    "get_related_field_for_models",
     "get_route_for_model",
     "get_settings_or_config",
     "get_table_for_model",

nautobot/cloud/tables.py

@@ -55,6 +55,7 @@ class CloudNetworkTable(BaseTable):
     circuit_count = LinkedCountColumn(
         viewname="circuits:circuit_list",
         url_params={"cloud_network": "name"},
+        # lookup="circuit_terminations__circuit",  # TODO: not currently supported
         verbose_name="Circuits",
         reverse_lookup="circuit_terminations__cloud_network",
     )

nautobot/core/forms/forms.py

@@ -113,7 +113,7 @@ class BulkEditForm(forms.Form):
     a more powerful subclass and should be used instead of directly inheriting from this class.
     """
 
-    def __init__(self, model, *args, **kwargs):
+    def __init__(self, model, *args, edit_all=False, **kwargs):
         super().__init__(*args, **kwargs)
         self.model = model
         self.nullable_fields = []
@@ -122,6 +122,10 @@ class BulkEditForm(forms.Form):
         if hasattr(self.Meta, "nullable_fields"):
             self.nullable_fields = self.Meta.nullable_fields
 
+        if edit_all:
+            self.fields["pk"].required = False
+            self.fields["_all"] = forms.BooleanField(widget=forms.HiddenInput(), required=True, initial=True)
+
 
 class BulkRenameForm(forms.Form):
     """

nautobot/core/models/query_functions.py

@@ -1,5 +1,7 @@
 from django.db import NotSupportedError
-from django.db.models import Aggregate, Func, JSONField
+from django.db.models import Aggregate, Func, JSONField, Value
+from django.db.models.fields.json import compile_json_path
+from django.db.models.functions import Cast
 
 
 class CollateAsChar(Func):
@@ -26,6 +28,150 @@ class CollateAsChar(Func):
         return super().as_sql(compiler, connection, function, template, arg_joiner, **extra_context)
 
 
+class JSONSet(Func):
+    """
+    Set or create the value of a single key in a JSONField.
+
+    Example:
+        model.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "cf_key", "new_value"))
+
+    Limitations:
+        - Postgres and MySQL only.
+        - Does *not* support nested lookups (`key1__key2`), only a single top-level key.
+        - Unlike the referenced Django PR, supports only a single key/value rather than an arbitrary number of them.
+
+    References:
+        - https://code.djangoproject.com/ticket/32519
+        - https://github.com/django/django/pull/18489/files
+    """
+
+    function = None
+
+    def __init__(self, expression, path, value, output_field=None):
+        self.path = path
+        self.value = value
+        super().__init__(expression, output_field=output_field)
+
+    def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
+        """
+        Based on https://github.com/django/django/pull/18489/files.
+
+        Transforms and inserts self.path and self.value appropriately into the expression fields.
+        """
+        c = super().resolve_expression(query, allow_joins, reuse, summarize, for_save)
+        # Resolve expressions in the JSON update values.
+        c.fields = {
+            self.path: (
+                self.value.resolve_expression(query, allow_joins, reuse, summarize, for_save)
+                if hasattr(self.value, "resolve_expression")
+                else self.value
+            )
+        }
+        return c
+
+    def as_sql(self, compiler, connection, function=None, **extra_context):
+        """
+        MySQL implementation based on https://github.com/django/django/pull/18489/files.
+
+        Creates a copy of this object with the appropriately transformed self.path and self.value for MySQL JSON_SET().
+        """
+        if connection.vendor != "mysql":
+            raise NotSupportedError(f"JSONSet is not implemented for database {connection.vendor}")
+
+        copy = self.copy()
+        new_source_expressions = copy.get_source_expressions()
+
+        path = compile_json_path([self.path])
+        value = self.value
+        if not hasattr(value, "resolve_expression"):
+            # Use Value to serialize the value to a string, then Cast to ensure it's treated as JSON.
+            value = Cast(Value(value, output_field=self.output_field), output_field=self.output_field)
+
+        new_source_expressions.extend((Value(path), value))
+        copy.set_source_expressions(new_source_expressions)
+        return super(JSONSet, copy).as_sql(compiler, connection, function="JSON_SET", **extra_context)
+
+    def as_postgresql(self, compiler, connection, function=None, **extra_context):
+        """
+        PostgreSQL implementation based on https://github.com/django/django/pull/18489/files.
+
+        Creates a copy of this object with appropriately transformed self.path and self.value for Postgres JSONB_SET().
+        """
+        copy = self.copy()
+        new_source_expressions = copy.get_source_expressions()
+
+        path = self.path
+        value = self.value
+        if not hasattr(value, "resolve_expression"):
+            # We don't need Cast() here because Value with a JSONFIeld is correctly handled as JSONB by Postgres
+            value = Value(value, output_field=self.output_field)
+        else:
+
+            class ToJSONB(Func):
+                function = "TO_JSONB"
+
+            value = ToJSONB(value, output_field=self.output_field)
+
+        new_source_expressions.extend((Value(f"{{{path}}}"), value))
+        copy.set_source_expressions(new_source_expressions)
+        return super(JSONSet, copy).as_sql(compiler, connection, function="JSONB_SET", **extra_context)
+
+
+class JSONRemove(Func):
+    """
+    Unset and remove a single key in a JSONField.
+
+    Example:
+        model.objects.all().update(_custom_field_data=JSONRemove("_custom_field_data", "cf_key"))
+
+    Limitations:
+        - Postgres and MySQL only.
+        - Does *not* support nested lookups (`key1__key2`), only a single top-level key.
+        - Unlike the referenced Django PR, supports only a single key, not N keys.
+
+    References:
+        - https://code.djangoproject.com/ticket/32519
+        - https://github.com/django/django/pull/18489/files
+    """
+
+    def __init__(self, expression, path):
+        self.path = path
+        super().__init__(expression)
+
+    def as_sql(self, compiler, connection, function=None, **extra_context):
+        """
+        MySQL implementation based on https://github.com/django/django/pull/18489/files.
+
+        Creates a copy of this object with appropriately transformed self.path for MySQL JSON_REMOVE().
+        """
+        if connection.vendor != "mysql":
+            raise NotSupportedError(f"JSONSet is not implemented for database {connection.vendor}")
+
+        copy = self.copy()
+        new_source_expressions = copy.get_source_expressions()
+
+        new_source_expressions.append(Value(compile_json_path([self.path])))
+
+        copy.set_source_expressions(new_source_expressions)
+        return super(JSONRemove, copy).as_sql(compiler, connection, function="JSON_REMOVE", **extra_context)
+
+    def as_postgresql(self, compiler, connection, function=None, **extra_context):
+        """
+        PostgreSQL implementation based on https://github.com/django/django/pull/18489/files.
+
+        Creates a copy of this object with appropriately transformed self.path for Postgres `#-` operator.
+        """
+        copy = self.copy()
+        new_source_expressions = copy.get_source_expressions()
+
+        new_source_expressions.append(Value(f"{{{self.path}}}"))
+
+        copy.set_source_expressions(new_source_expressions)
+        return super(JSONRemove, copy).as_sql(
+            compiler, connection, template="%(expressions)s", arg_joiner="#- ", **extra_context
+        )
+
+
 class JSONBAgg(Aggregate):
     """
     Like django.contrib.postgres.aggregates.JSONBAgg, but different.

nautobot/core/tables.py

@@ -5,10 +5,12 @@ from django.contrib.auth.models import AnonymousUser
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.core.exceptions import FieldDoesNotExist, FieldError
 from django.db import NotSupportedError
+from django.db.models import Prefetch
 from django.db.models.fields.related import ForeignKey, RelatedField
 from django.db.models.fields.reverse_related import ManyToOneRel
 from django.urls import reverse
 from django.utils.html import escape, format_html, format_html_join
+from django.utils.http import urlencode
 from django.utils.safestring import mark_safe
 from django.utils.text import Truncator
 import django_tables2
@@ -18,7 +20,7 @@ from tree_queries.models import TreeNode
 
 from nautobot.core.models.querysets import count_related
 from nautobot.core.templatetags import helpers
-from nautobot.core.utils import lookup
+from nautobot.core.utils.lookup import get_model_for_view_name, get_related_field_for_models, get_route_for_model
 from nautobot.extras import choices, models
 
 logger = logging.getLogger(__name__)
@@ -154,12 +156,25 @@ class BaseTable(django_tables2.Table):
                 if not column.visible:
                     continue
                 if isinstance(column.column, LinkedCountColumn):
-                    column_model = lookup.get_model_for_view_name(column.column.viewname)
+                    column_model = get_model_for_view_name(column.column.viewname)
                     if column_model is None:
                         logger.error("Couldn't find model for %s", column.column.viewname)
                         continue
                     reverse_lookup = column.column.reverse_lookup or next(iter(column.column.url_params.keys()))
                     count_fields.append((column.name, column_model, reverse_lookup))
+                    try:
+                        lookup = column.column.lookup or get_related_field_for_models(model, column_model).name
+                        # For some reason get_related_field_for_models(Tag, DynamicGroup) gives a M2M with the name
+                        # `dynamicgroup`, which isn't actually a field on Tag. May be a django-taggit issue?
+                        # Workaround for now: make sure the field actually exists on the model under this name:
+                        getattr(model, lookup)
+                    except AttributeError:
+                        lookup = None
+                    if lookup is not None:
+                        # Also attempt to prefetch the first matching record for display - see LinkedCountColumn
+                        prefetch_fields.append(
+                            Prefetch(lookup, column_model.objects.all()[:1], to_attr=f"{lookup}_list")
+                        )
                     continue
 
                 column_model = model
@@ -233,7 +248,7 @@ class BaseTable(django_tables2.Table):
                     # Belt and suspenders - we should have avoided any error cases above, but be safe anyway:
                     try:
                         queryset = queryset.prefetch_related(*prefetch_fields)
-                    except (TypeError, ValueError, NotSupportedError) as exc:
+                    except (AttributeError, TypeError, ValueError, NotSupportedError) as exc:
                         logger.warning(
                             "Unexpected error when trying to .prefetch_related() on %s QuerySet: %s",
                             model.__name__,
@@ -395,9 +410,9 @@ class ButtonsColumn(django_tables2.TemplateColumn):
             self.template_code = prepend_template + self.template_code
 
         app_label = model._meta.app_label
-        changelog_route = lookup.get_route_for_model(model, "changelog")
-        edit_route = lookup.get_route_for_model(model, "edit")
-        delete_route = lookup.get_route_for_model(model, "delete")
+        changelog_route = get_route_for_model(model, "changelog")
+        edit_route = get_route_for_model(model, "edit")
+        delete_route = get_route_for_model(model, "delete")
 
         template_code = self.template_code.format(
             app_label=app_label,
@@ -462,29 +477,80 @@ class ColoredLabelColumn(django_tables2.TemplateColumn):
 
 class LinkedCountColumn(django_tables2.Column):
     """
-    Render a count of related objects linked to a filtered URL.
-
-    :param viewname: The view name to use for URL resolution
-    :param view_kwargs: Additional kwargs to pass for URL resolution (optional)
-    :param url_params: A dict of query parameters to append to the URL (e.g. ?foo=bar) (optional)
-    :param reverse_lookup: The reverse lookup parameter to use to derive the count. If not specified, the first key
-        in `url_params` will be implicitly used as the `reverse_lookup` value.
+    Render a count of related objects linked to a filtered URL, or if a single related object is present, the object.
+
+    Args:
+        viewname (str): The list view name to use for URL resolution, for example `"dcim:location_list"`
+        url_params (dict, optional): Query parameters to apply to filter the list URL (e.g. `{"vlans": "pk"}` will add
+            `?vlans=<record.pk>` to the linked list URL)
+        view_kwargs (dict, optional): Additional kwargs to pass to `reverse()` for list URL resolution. Rarely used.
+        lookup (str, optional): The field name on the base record that can be used to query the related objects.
+            If not specified, `nautobot.core.utils.lookup.get_related_field_for_models()` will be called at render time
+            to attempt to intelligently find the appropriate field.
+            TODO: this currently does *not* support nested lookups via `__`. That may be solvable in the future.
+        reverse_lookup (str, optional): The reverse lookup parameter to use to derive the count.
+            If not specified, the first key in `url_params` will be implicitly used as the `reverse_lookup` value.
+        **kwargs (dict, optional): As the parent Column class.
+
+    Examples:
+        ```py
+        class VLANTable(..., BaseTable):
+            ...
+            location_count = LinkedCountColumn(
+                # Link for N related locations will be reverse("dcim:location_list") + "?vlans=<record.pk>"
+                viewname="dcim:location_list",
+                url_params={"vlans": "pk"},
+                verbose_name="Locations",
+            )
+        ```
+
+        ```py
+        class CloudNetworkTable(BaseTable):
+            ...
+            circuit_count = LinkedCountColumn(
+                # Link for N related circuits will be reverse("circuits:circuit_list") + "?cloud_network=<record.name>"
+                viewname="circuits:circuit_list",
+                url_params={"cloud_network": "name"},
+                # We'd like to do the below but this module isn't currently smart enough to build the right Prefetch()
+                # for a nested lookup:
+                # lookup="circuit_terminations__circuit",
+                # For the count, .annotate(circuit_count=count_related(Circuit, "circuit_terminations__cloud_network"))
+                reverse_lookup="circuit_terminations__cloud_network",
+                verbose_name="Circuits",
+            )
+        ```
     """
 
-    def __init__(self, viewname, *args, view_kwargs=None, url_params=None, reverse_lookup=None, default=0, **kwargs):
+    def __init__(
+        self, viewname, *args, view_kwargs=None, url_params=None, lookup=None, reverse_lookup=None, default=0, **kwargs
+    ):
         self.viewname = viewname
+        self.lookup = lookup
         self.view_kwargs = view_kwargs or {}
         self.url_params = url_params
-        self.reverse_lookup = reverse_lookup
+        self.reverse_lookup = reverse_lookup or next(iter(url_params.keys()))
+        self.model = get_model_for_view_name(self.viewname)
         super().__init__(*args, default=default, **kwargs)
 
-    def render(self, record, value):  # pylint: disable=arguments-differ
-        if value:
-            url = reverse(self.viewname, kwargs=self.view_kwargs)
-            if self.url_params:
-                url += "?" + "&".join([f"{k}={getattr(record, v)}" for k, v in self.url_params.items()])
-            return format_html('<a href="{}">{}</a>', url, value)
-        return value
+    def render(self, bound_column, record, value):  # pylint: disable=arguments-differ
+        related_record = None
+        try:
+            lookup = self.lookup or get_related_field_for_models(bound_column._table._meta.model, self.model).name
+        except AttributeError:
+            lookup = None
+        if lookup:
+            if related_records := getattr(record, f"{lookup}_list", None):
+                related_record = related_records[0]
+        url = reverse(self.viewname, kwargs=self.view_kwargs)
+        if self.url_params:
+            url += "?" + urlencode({k: getattr(record, v) for k, v in self.url_params.items()})
+        if value > 1:
+            return format_html('<a href="{}" class="badge">{}</a>', url, value)
+        if related_record is not None:
+            return helpers.hyperlinked_object(related_record)
+        if value == 1:
+            return format_html('<a href="{}" class="badge">{}</a>', url, value)
+        return helpers.placeholder(value)
 
 
 class TagColumn(django_tables2.TemplateColumn):

nautobot/core/templates/generic/object_bulk_destroy.html

@@ -2,7 +2,7 @@
 {% load helpers %}
 {% load render_table from django_tables2 %}
 
-{% block title %}Delete {{ table.rows|length }} {{ obj_type_plural|bettertitle }}?{% endblock %}
+{% block title %}Delete {{ total_objs_to_delete }} {{ obj_type_plural|bettertitle }}?{% endblock %}
 
 {% block content %}
     <div class="row">
@@ -10,12 +10,14 @@
             <div class="panel panel-danger">
                 <div class="panel-heading"><strong>Confirm Bulk Deletion</strong></div>
                 <div class="panel-body">
-                    <p><strong>Warning:</strong> The following operation will delete {{ table.rows|length }} {{ obj_type_plural }}. Please carefully review the {{ obj_type_plural }} to be deleted and confirm below.</p>
+                    <p><strong>Warning:</strong> The following operation will delete {{ total_objs_to_delete }} {{ obj_type_plural }}. {% if not delete_all %}Please carefully review the {{ obj_type_plural }} to be deleted and confirm below.{% endif %}</p>
                     {% block message_extra %}{% endblock %}
                 </div>
             </div>
         </div>
     </div>
+
+    {% if table %}
     <div class="row">
         <div class="col-md-8 col-md-offset-2">
             <div class="panel panel-default">
@@ -25,15 +27,22 @@
             </div>
         </div>
     </div>
+    {% endif %}
+
     <div class="row">
         <div class="col-md-6 col-md-offset-3">
             <form action="" method="post" class="form">
+
                 {% csrf_token %}
+                {% if delete_all %}
+                    <input type="hidden" name="_all" value="true"  />
+                {% endif %}
                 {% for field in form.hidden_fields %}
                     {{ field }}
                 {% endfor %}
+
                 <div class="text-center">
-                    <button type="submit" name="_confirm" class="btn btn-danger">Delete these {{ table.rows|length }} {{ obj_type_plural }}</button>
+                    <button type="submit" name="_confirm" class="btn btn-danger">Delete these {{ total_objs_to_delete }} {{ obj_type_plural }}</button>
                     <a href="{{ return_url }}" class="btn btn-default">Cancel</a>
                 </div>
             </form>

nautobot/core/templates/generic/object_bulk_update.html

@@ -4,7 +4,7 @@
 {% load render_table from django_tables2 %}
 
 {% block content %}
-<h1>{% block title %}Editing {{ table.rows|length }} {{ obj_type_plural|bettertitle }}{% endblock %}</h1>
+<h1>{% block title %}Editing {{ objs_count }} {{ obj_type_plural|bettertitle }}{% endblock %}</h1>
 {% if form.errors %}
     <div class="panel panel-danger">
         <div class="panel-heading"><strong>Errors</strong></div>
@@ -27,6 +27,7 @@
         {{ field }}
     {% endfor %}
     <div class="row">
+        {% if table %}
         <div class="col-md-8">
             <div class="panel panel-default">
                 <div class="table-responsive">
@@ -34,7 +35,8 @@
                 </div>
             </div>
         </div>
-        <div class="col-md-4">
+        {% endif %}
+        <div class="{% if table %} col-md-4 {% else %} col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1 {% endif %}">
             <div class="panel panel-default">
                 <div class="panel-heading"><strong>{% block form_title %}Attributes{% endblock %}</strong></div>
                 <div class="panel-body">

nautobot/core/templates/generic/object_create.html

@@ -50,7 +50,7 @@
             </div>
         </div>
         <div class="row">
-            <div class="col-md-6 col-md-offset-3 text-right">
+            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1 text-right">
                 {% block buttons %}
                     {% if editing %}
                         <button type="submit" name="_update" class="btn btn-primary">Update</button>

nautobot/core/templates/rest_framework/api.html

@@ -20,6 +20,9 @@
         #main-content {
             min-height: calc(100vh - 70px);
         }
+        .request-info {
+            clear: both;  /* Fix description floating issue */
+        }
     </style>
 {% endblock body %}
 

nautobot/core/testing/api.py

@@ -699,13 +699,15 @@ class APIViewTestCases:
             serializer_class = get_serializer_for_model(self.model)
             old_serializer = serializer_class(instance, context={"request": None})
             old_data = old_serializer.data
+            # save the pk because .delete() will clear it, making the test below always pass
+            orig_pk = instance.pk
             instance.delete()
 
             response = self.client.post(self._get_list_url(), csv_data, content_type="text/csv", **self.header)
             self.assertHttpStatus(response, status.HTTP_201_CREATED, csv_data)
             # Note that create via CSV is always treated as a bulk-create, and so the response is always a list of dicts
             new_instance = self._get_queryset().get(pk=response.data[0]["id"])
-            self.assertNotEqual(new_instance.pk, instance.pk)
+            self.assertNotEqual(new_instance.pk, orig_pk)
 
             new_serializer = serializer_class(new_instance, context={"request": None})
             new_data = new_serializer.data

nautobot/core/testing/integration.py

@@ -5,6 +5,7 @@ from django.contrib.staticfiles.testing import StaticLiveServerTestCase
 from django.test import override_settings, tag
 from django.urls import reverse
 from django.utils.functional import classproperty
+from selenium.webdriver.common.keys import Keys
 from splinter.browser import Browser
 
 from nautobot.core import testing
@@ -74,3 +75,66 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
 
     def logout(self):
         self.browser.visit(f"{self.live_server_url}/logout")
+
+    def click_navbar_entry(self, parent_menu_name, child_menu_name):
+        """
+        Helper function to click on a parent menu and child menu in the navigation bar.
+        """
+
+        parent_menu_xpath = f"//*[@id='navbar']//a[@class='dropdown-toggle' and normalize-space()='{parent_menu_name}']"
+        parent_menu = self.browser.find_by_xpath(parent_menu_xpath, wait_time=5)
+        if not parent_menu["aria-expanded"] == "true":
+            parent_menu.click()
+        child_menu_xpath = f"{parent_menu_xpath}/following-sibling::ul//li[.//a[normalize-space()='{child_menu_name}']]"
+        child_menu = self.browser.find_by_xpath(child_menu_xpath, wait_time=5)
+        child_menu.click()
+
+        # Wait for body element to appear
+        self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=5), "Page failed to load")
+
+    def click_list_view_add_button(self):
+        """
+        Helper function to click the "Add" button on a list view.
+        """
+        add_button = self.browser.find_by_xpath("//a[@id='add-button']", wait_time=5)
+        add_button.click()
+
+        # Wait for body element to appear
+        self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=5), "Page failed to load")
+
+    def click_edit_form_create_button(self):
+        """
+        Helper function to click the "Create" button on a form.
+        """
+        add_button = self.browser.find_by_xpath("//button[@name='_create']", wait_time=5)
+        add_button.click()
+
+        # Wait for body element to appear
+        self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=5), "Page failed to load")
+
+    def fill_select2_field(self, field_name, value):
+        """
+        Helper function to fill a Select2 single selection field.
+        """
+        self.browser.find_by_xpath(f"//select[@id='id_{field_name}']//following-sibling::span").click()
+        search_box = self.browser.find_by_xpath(
+            "//*[@class='select2-search select2-search--dropdown']//input", wait_time=5
+        )
+        for _ in search_box.first.type(value, slowly=True):
+            pass
+
+        # wait for "searching" to disappear
+        self.browser.is_element_not_present_by_css(".loading-results", wait_time=5)
+        search_box.first.type(Keys.ENTER)
+
+    def fill_select2_multiselect_field(self, field_name, value):
+        """
+        Helper function to fill a Select2 multi-selection field.
+        """
+        search_box = self.browser.find_by_xpath(f"//select[@id='id_{field_name}']//following-sibling::span//input")
+        for _ in search_box.first.type(value, slowly=True):
+            pass
+
+        # wait for "searching" to disappear
+        self.browser.is_element_not_present_by_css(".loading-results", wait_time=5)
+        search_box.first.type(Keys.ENTER)