nautobot 2.3.0__py3-none-any.whl → 2.3.1__py3-none-any.whl

nautobot/cloud/forms.py

@@ -26,7 +26,7 @@ class CloudAccountForm(NautobotModelForm):
         queryset=Manufacturer.objects.all(),
         help_text="The Manufacturer instance which represents the Cloud Provider",
     )
-    secrets_group = DynamicModelChoiceField(queryset=SecretsGroup.objects.all())
+    secrets_group = DynamicModelChoiceField(queryset=SecretsGroup.objects.all(), required=False)
 
     class Meta:
         model = CloudAccount

nautobot/cloud/tests/test_views.py

@@ -2,6 +2,7 @@ from django.contrib.contenttypes.models import ContentType
 
 from nautobot.cloud.models import CloudAccount, CloudNetwork, CloudResourceType, CloudService
 from nautobot.core.testing import ViewTestCases
+from nautobot.core.testing.utils import post_data
 from nautobot.dcim.models import Manufacturer
 from nautobot.extras.models import SecretsGroup, Tag
 
@@ -36,6 +37,22 @@ class CloudAccountTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "comments": "New comments",
         }
 
+    def test_post_without_secrets_group(self):
+        """Assert Secrets Group form field is not required: Fix for https://github.com/nautobot/nautobot/issues/6096"""
+        self.add_permissions("cloud.add_cloudaccount", "dcim.view_manufacturer")
+        form_data = {
+            "name": "New Cloud Account 2",
+            "account_number": "8928371982311",
+            "provider": Manufacturer.objects.first().pk,
+            "description": "A new cloud account",
+        }
+        request = {
+            "path": self._get_url("add"),
+            "data": post_data(form_data),
+        }
+        self.assertHttpStatus(self.client.post(**request), 302)
+        self.assertTrue(CloudAccount.objects.filter(name="New Cloud Account 2").exists())
+
 
 class CloudNetworkTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = CloudNetwork

nautobot/cloud/views.py

@@ -59,7 +59,7 @@ class CloudNetworkUIViewSet(NautobotUIViewSet):
         context = super().get_extra_context(request, instance)
         if self.action == "retrieve":
             prefixes = instance.prefixes.restrict(request.user, "view")
-            prefixes_table = PrefixTable(prefixes.select_related("namespace"))
+            prefixes_table = PrefixTable(prefixes.select_related("namespace"), hide_hierarchy_ui=True)
             prefixes_table.columns.hide("location_count")
             prefixes_table.columns.hide("vlan")
 

nautobot/core/celery/__init__.py

@@ -8,7 +8,7 @@ from celery import Celery, shared_task, signals
 from celery.app.log import TaskFormatter
 from celery.utils.log import get_logger
 from django.conf import settings
-from django.db.utils import ProgrammingError
+from django.db.utils import OperationalError, ProgrammingError
 from django.utils.functional import SimpleLazyObject
 from django.utils.module_loading import import_string
 from kombu.serialization import register
@@ -55,7 +55,10 @@ def import_jobs(sender=None, **kwargs):
 
     try:
         _import_jobs_from_git_repositories()
-    except ProgrammingError:  # Database not ready yet, as may be the case on initial startup and migration
+    except (
+        OperationalError,  # Database not present, as may be the case when running pylint-nautobot
+        ProgrammingError,  # Database not ready yet, as may be the case on initial startup and migration
+    ):
         pass
 
 

nautobot/core/templates/generic/object_retrieve.html

@@ -134,7 +134,7 @@
             <div class="row">
                 <div class="col-md-6">
                     {% block content_left_page %}{% endblock content_left_page %}
-                    {% include 'inc/custom_fields/panel.html' with custom_fields=object.get_custom_field_groupings_basic computed_fields_advanced_ui=False %}
+                    {% include 'inc/custom_fields/panel.html' with custom_fields=object.get_custom_field_groupings_basic computed_fields=object.get_computed_fields_grouping_basic computed_fields_advanced_ui=False %}
                     {% include 'inc/relationships_panel.html' %}
                     {% include 'extras/inc/tags_panel.html' %}
                     {% plugin_left_page object %}

nautobot/core/templates/inc/computed_fields/panel_data.html

@@ -1,25 +1,37 @@
-{% if not advanced_ui %}
-    {% if object.has_computed_fields_basic %}
-        {% load computed_fields %}
-        <div class="panel panel-default">
-            <div class="panel-heading">
-                <strong>Computed Fields</strong>
-            </div>
-            <table class="table table-hover panel-body attr-table">
-                {% computed_fields object advanced_ui %}
-            </table>
+{% load helpers %}
+{% if computed_fields %}
+<style>
+    .accordion-toggle {
+        font-size: 14px;
+    }
+</style>
+    <div class="panel panel-default">
+        <div class="panel-heading">
+            <strong>Computed Fields</strong>
+            <button type="button" class="btn-xs btn-primary pull-right" id="accordion-toggle-all">Collapse All</button>
         </div>
-    {% endif %}
-{% else %}
-    {% if object.has_computed_fields_advanced %}
-        {% load computed_fields %}
-        <div class="panel panel-default">
-            <div class="panel-heading">
-                <strong>Computed Fields</strong>
-            </div>
-            <table class="table table-hover panel-body attr-table">
-                {% computed_fields object advanced_ui %}
-            </table>
-        </div>
-    {% endif %}
-{% endif %}
+        <table id="accordion" class="table table-hover panel-body attr-table">
+            {% for grouping, fields in computed_fields.items %}
+            {% with forloop.counter0 as count %}
+                {% if grouping != "" %}
+                    <tr>
+                        <td colspan="2"><strong>
+                            <button type="button" class="accordion-toggle mdi mdi-chevron-down"
+                                    name="grouping.{{ grouping }}" data-toggle="collapse"
+                                    data-target=".collapseme-computed-{{ count }}">
+                                {{ grouping }}
+                            </button></strong>
+                        </td>
+                    </tr>
+                {% endif %}
+                    {% for field, value in fields %}
+                        <tr class="collapseme-computed-{{ count }} collapse in" data-parent="#accordion">
+                            <td><span title="{{ field.description }}">{{ field }}</span></td>
+                            <td>{{ value }}</td>
+                        </tr>
+                    {% endfor %}
+                {% endwith %}
+                {% endfor %}
+        </table>
+    </div>
+{% endif %}

nautobot/core/templates/inc/object_details_advanced_panel.html

@@ -88,6 +88,6 @@
             </tbody>
         </table>
     </div>
-    {% include 'inc/custom_fields/panel.html' with custom_fields=object.get_custom_field_groupings_advanced computed_fields_advanced_ui=True %}
+    {% include 'inc/custom_fields/panel.html' with custom_fields=object.get_custom_field_groupings_advanced computed_fields=object.get_computed_fields_grouping_advanced computed_fields_advanced_ui=True %}
     {% include 'inc/relationships/panel_override.html' with relationships_fields_override=object.get_relationships_data_advanced_fields %}
 {% endif %}

nautobot/core/views/__init__.py

@@ -299,7 +299,7 @@ class SearchView(AccessMixin, View):
 
                     # Construct the results table for this object type
                     filtered_queryset = filterset({"q": form.cleaned_data["q"]}, queryset=queryset).qs
-                    table = table(filtered_queryset, orderable=False)
+                    table = table(filtered_queryset, hide_hierarchy_ui=True, orderable=False)
                     table.paginate(per_page=SEARCH_MAX_RESULTS)
 
                     if table.page:

nautobot/dcim/forms.py

@@ -2064,6 +2064,25 @@ class DeviceForm(LocatableModelFormMixin, NautobotModelForm, TenancyForm, LocalC
         if position:
             self.fields["position"].widget.choices = [(position, f"U{position}")]
 
+    def clean(self):
+        super().clean()
+
+        device_type = self.cleaned_data["device_type"]
+        software_image_files = self.cleaned_data["software_image_files"]
+
+        # If any software image file is specified, validate that
+        # each of the software image files belongs to the device's device type or is a default image
+        for image_file in software_image_files:
+            if not image_file.default_image and device_type not in image_file.device_types.all():
+                raise ValidationError(
+                    {
+                        "software_image_files": (
+                            f"Software image file {image_file} for version '{image_file.software_version}' is not "
+                            f"valid for device type {device_type}."
+                        )
+                    }
+                )
+
     def save(self, *args, **kwargs):
         instance = super().save(*args, **kwargs)
         instance.vrfs.set(self.cleaned_data["vrfs"])

nautobot/dcim/models/devices.py

@@ -818,21 +818,18 @@ class Device(PrimaryModel, ConfigContextModel):
                 }
             )
 
-        # Validate device software version has a software image file that matches the device's device type or is a default image
-        if self.software_version is not None and not any(
-            (
-                self.software_version.software_image_files.filter(device_types=self.device_type).exists(),
-                self.software_version.software_image_files.filter(default_image=True).exists(),
-            )
-        ):
-            raise ValidationError(
-                {
-                    "software_version": (
-                        f"No software image files for version '{self.software_version}' are "
-                        f"valid for device type {self.device_type}."
-                    )
-                }
-            )
+        # If any software image file is specified, validate that
+        # each of the software image files belongs to the device's device type or is a default image
+        for image_file in self.software_image_files.all():
+            if not image_file.default_image and self.device_type not in image_file.device_types.all():
+                raise ValidationError(
+                    {
+                        "software_image_files": (
+                            f"Software image file {image_file} for version '{image_file.software_version}' is not "
+                            f"valid for device type {self.device_type}."
+                        )
+                    }
+                )
 
     def save(self, *args, **kwargs):
         is_new = not self.present_in_database

nautobot/dcim/templates/dcim/device.html

@@ -233,7 +233,7 @@
                                     {% include 'dcim/inc/detail_softwareversion_softwareimagefile_rows.html' %}
                                 </table>
                             </div>
-                            {% include 'inc/custom_fields/panel.html' with custom_fields=object.get_custom_field_groupings_basic computed_fields_advanced_ui=False %}
+                            {% include 'inc/custom_fields/panel.html' with custom_fields=object.get_custom_field_groupings_basic computed_fields=object.get_computed_fields_grouping_basic computed_fields_advanced_ui=False %}
                             {% include 'inc/relationships/panel_override.html' with relationships_fields_override=object.get_relationships_data_basic_fields %}
                             {% include 'extras/inc/tags_panel.html' with tags=object.tags.all url='dcim:device_list' %}
                             <div class="panel panel-default">

nautobot/dcim/templates/dcim/softwareimagefile_retrieve.html

@@ -144,7 +144,7 @@
             </div>
             <div class="row">
                 <div class="col-md-6">
-                    {% include 'inc/custom_fields/panel.html' with custom_fields=object.get_custom_field_groupings_basic computed_fields_advanced_ui=False %}
+                    {% include 'inc/custom_fields/panel.html' with custom_fields=object.get_custom_field_groupings_basic computed_fields=object.get_computed_fields_grouping_basic computed_fields_advanced_ui=False %}
                     {% include 'inc/relationships_panel.html' %}
                     {% include 'extras/inc/tags_panel.html' %}
                     {% plugin_left_page object %}

nautobot/dcim/tests/test_forms.py

@@ -12,6 +12,8 @@ from nautobot.dcim.models import (
     Manufacturer,
     Platform,
     Rack,
+    SoftwareImageFile,
+    SoftwareVersion,
 )
 from nautobot.extras.models import Role, SecretsGroup, Status
 from nautobot.ipam.models import VLAN
@@ -43,6 +45,15 @@ class DeviceTestCase(FormTestCases.BaseFormTestCase):
         cls.manufacturer = cls.device_type.manufacturer
         cls.platform = Platform.objects.filter(manufacturer=cls.device_type.manufacturer).first()
         cls.device_role = Role.objects.get_for_model(Device).first()
+        cls.software_version_contains_no_valid_image_for_device_type = SoftwareVersion.objects.create(
+            platform=cls.platform,
+            version="New version 1.0.0",
+            status=Status.objects.get_for_model(SoftwareVersion).first(),
+        )
+        cls.software_version = SoftwareVersion.objects.first()
+        cls.software_image_files = SoftwareImageFile.objects.exclude(software_version=cls.software_version).exclude(
+            default_image=True
+        )
 
         Device.objects.create(
             name="Device 1",
@@ -134,6 +145,49 @@ class DeviceTestCase(FormTestCases.BaseFormTestCase):
         self.assertFalse(form.is_valid())
         self.assertIn("face", form.errors)
 
+    def test_no_software_image_file_specified_is_valid(self):
+        form = DeviceForm(
+            data={
+                "name": "New Device",
+                "role": self.device_role.pk,
+                "tenant": None,
+                "manufacturer": self.manufacturer.pk,
+                "device_type": self.device_type.pk,
+                "location": self.location.pk,
+                "rack": None,
+                "face": None,
+                "position": None,
+                "platform": self.platform.pk,
+                "status": self.device_status.pk,
+                "secrets_group": SecretsGroup.objects.first().pk,
+                "software_version": self.software_version_contains_no_valid_image_for_device_type.pk,
+                "software_image_files": [],
+            }
+        )
+        self.assertTrue(form.is_valid())
+
+    def test_invalid_software_image_file_specified(self):
+        form = DeviceForm(
+            data={
+                "name": "New Device",
+                "role": self.device_role.pk,
+                "tenant": None,
+                "manufacturer": self.manufacturer.pk,
+                "device_type": self.device_type.pk,
+                "location": self.location.pk,
+                "rack": None,
+                "face": None,
+                "position": None,
+                "platform": self.platform.pk,
+                "status": self.device_status.pk,
+                "secrets_group": SecretsGroup.objects.first().pk,
+                "software_version": self.software_version.pk,
+                "software_image_files": list(self.software_image_files.values_list("pk", flat=True)),
+            }
+        )
+        self.assertFalse(form.is_valid())
+        self.assertIn("software_image_files", form.errors)
+
     def test_non_racked_device_with_position(self):
         form = DeviceForm(
             data={

nautobot/dcim/tests/test_models.py

@@ -1723,11 +1723,19 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         software_version.software_image_files.all().update(default_image=False)
         self.device_type.software_image_files.set([])
         self.device.software_version = software_version
+        invalid_software_image_file = SoftwareImageFile.objects.filter(default_image=False).first()
+        invalid_software_image_file.device_types.set([])
+        self.device.software_image_files.set([invalid_software_image_file])
 
-        # No device type or default image match
+        # There is an invalid non-default software_image_file specified for the software version
+        # It is not a default image and it does not match any device type
         with self.assertRaises(ValidationError):
             self.device.validated_save()
 
+        # user should be able to specify any software version without specifying software_image_files
+        self.device.software_image_files.set([])
+        self.device.validated_save()
+
         # Default image matches
         software_image_file = software_version.software_image_files.first()
         software_image_file.default_image = True

nautobot/dcim/tests/test_views.py

@@ -2084,7 +2084,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         status_active = statuses[0]
 
         # We want unique sets of software image files for each device type
-        software_image_files = list(SoftwareImageFile.objects.all()[:4])
+        software_image_files = list(SoftwareImageFile.objects.filter(default_image=False)[:4])
         software_versions = list(SoftwareVersion.objects.filter(software_image_files__isnull=False)[:2])
         software_image_files[0].software_version = software_versions[0]
         software_image_files[1].software_version = software_versions[0]
@@ -2094,6 +2094,10 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             software_image_file.save()
         devicetypes[0].software_image_files.set(software_image_files[:2])
         devicetypes[1].software_image_files.set(software_image_files[2:])
+        # Only valid software image files are those that belong to the device type or default images
+        valid_software_image_files = software_image_files[2:] + [
+            SoftwareImageFile.objects.filter(default_image=True).first()
+        ]
 
         cls.custom_fields = (
             CustomField.objects.create(
@@ -2205,7 +2209,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "cf_crash_counter": -1,
             "cr_router-id": None,
             "software_version": software_versions[1].pk,
-            "software_image_files": [f.pk for f in software_versions[0].software_image_files.all()],
+            "software_image_files": [f.pk for f in valid_software_image_files],
         }
 
         cls.bulk_edit_data = {

nautobot/extras/api/serializers.py

@@ -228,7 +228,6 @@ class ContactAssociationSerializer(NautobotModelSerializer):
         fields = "__all__"
         validators = []
         extra_kwargs = {
-            "role": {"required": False},
             "contact": {"required": False},
             "team": {"required": False},
         }

nautobot/extras/filters/__init__.py

@@ -181,6 +181,7 @@ class ComputedFieldFilterSet(BaseFilterSet):
             "description": "icontains",
             "content_type__app_label": "icontains",
             "content_type__model": "icontains",
+            "grouping": "icontains",
             "template": "icontains",
             "fallback_value": "icontains",
         },
@@ -192,6 +193,7 @@ class ComputedFieldFilterSet(BaseFilterSet):
         fields = (
             "content_type",
             "key",
+            "grouping",
             "template",
             "fallback_value",
             "weight",
@@ -422,6 +424,7 @@ class CustomFieldFilterSet(BaseFilterSet):
         filter_predicates={
             "label": "icontains",
             "description": "icontains",
+            "grouping": "icontains",
         },
     )
     content_types = ContentTypeMultipleChoiceFilter(
@@ -430,7 +433,7 @@ class CustomFieldFilterSet(BaseFilterSet):
 
     class Meta:
         model = CustomField
-        fields = ["id", "content_types", "label", "required", "filter_logic", "weight"]
+        fields = ["id", "content_types", "label", "grouping", "required", "filter_logic", "weight"]
 
 
 class CustomFieldChoiceFilterSet(BaseFilterSet):

nautobot/extras/forms/forms.py

@@ -219,6 +219,7 @@ class ComputedFieldForm(BootstrapMixin, forms.ModelForm):
         fields = (
             "content_type",
             "label",
+            "grouping",
             "key",
             "description",
             "template",

nautobot/extras/migrations/0114_computedfield_grouping.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.15 on 2024-08-09 14:28
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0113_saved_views"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="computedfield",
+            name="grouping",
+            field=models.CharField(blank=True, max_length=255),
+        ),
+    ]

nautobot/extras/models/customfields.py

@@ -88,6 +88,11 @@ class ComputedField(
         help_text="Internal field name. Please use underscores rather than dashes in this key.",
         slugify_function=slugify_dashes_to_underscores,
     )
+    grouping = models.CharField(
+        max_length=CHARFIELD_MAX_LENGTH,
+        blank=True,
+        help_text="Human-readable grouping that this computed field belongs to.",
+    )
     label = models.CharField(max_length=CHARFIELD_MAX_LENGTH, help_text="Name of the field as displayed to users")
     description = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True)
     template = models.TextField(max_length=500, help_text="Jinja2 template code for field value")
@@ -295,6 +300,55 @@ class CustomFieldModel(models.Model):
             return computed_field.render(context={"obj": self})
         return computed_field.template
 
+    def get_computed_fields_grouping_basic(self):
+        """
+        This method exists to help call get_computed_field_groupings() in templates where a function argument (advanced_ui) cannot be specified.
+        Return a dictonary of computed fields grouped by the same grouping in the form
+        {
+            <grouping_1>: [(cf1, <value for cf1>), (cf2, <value for cf2>), ...],
+            ...
+            <grouping_5>: [(cf8, <value for cf8>), (cf9, <value for cf9>), ...],
+            ...
+        }
+        which have advanced_ui set to False
+        """
+        return self.get_computed_fields_grouping(advanced_ui=False)
+
+    def get_computed_fields_grouping_advanced(self):
+        """
+        This method exists to help call get_computed_field_groupings() in templates where a function argument (advanced_ui) cannot be specified.
+        Return a dictonary of computed fields grouped by the same grouping in the form
+        {
+            <grouping_1>: [(cf1, <value for cf1>), (cf2, <value for cf2>), ...],
+            ...
+            <grouping_5>: [(cf8, <value for cf8>), (cf9, <value for cf9>), ...],
+            ...
+        }
+        which have advanced_ui set to True
+        """
+        return self.get_computed_fields_grouping(advanced_ui=True)
+
+    def get_computed_fields_grouping(self, advanced_ui=None):
+        """
+        Return a dictonary of computed fields grouped by the same grouping in the form
+        {
+            <grouping_1>: [(cf1, <value for cf1>), (cf2, <value for cf2>), ...],
+            ...
+            <grouping_5>: [(cf8, <value for cf8>), (cf9, <value for cf9>), ...],
+            ...
+        }
+        """
+        record = {}
+        computed_fields = ComputedField.objects.get_for_model(self)
+        if advanced_ui is not None:
+            computed_fields = computed_fields.filter(advanced_ui=advanced_ui)
+
+        for field in computed_fields:
+            data = (field, field.render(context={"obj": self}))
+            record.setdefault(field.grouping, []).append(data)
+        record = dict(sorted(record.items()))
+        return record
+
     def get_computed_fields(self, label_as_key=False, advanced_ui=None):
         """
         Return a dictionary of all computed fields and their rendered values for this model.

nautobot/extras/templates/extras/computedfield.html

@@ -20,6 +20,10 @@
                         <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>

nautobot/extras/views.py

@@ -2421,7 +2421,7 @@ class RoleUIViewSet(viewsets.NautobotUIViewSet):
 
             if ContentType.objects.get_for_model(Prefix) in context["content_types"]:
                 prefixes = instance.prefixes.restrict(request.user, "view")
-                prefix_table = PrefixTable(prefixes)
+                prefix_table = PrefixTable(prefixes, hide_hierarchy_ui=True)
                 prefix_table.columns.hide("role")
                 RequestConfig(request, paginate).configure(prefix_table)
                 context["prefix_table"] = prefix_table

nautobot/ipam/querysets.py

@@ -1,6 +1,7 @@
 import re
 
 from django.core.exceptions import ValidationError
+from django.core.validators import validate_ipv46_address
 from django.db.models import ProtectedError, Q
 import netaddr
 
@@ -397,6 +398,31 @@ class IPAddressQuerySet(BaseNetworkQuerySet):
         """
         return super().order_by("host")
 
+    def get_or_create(self, **kwargs):
+        from nautobot.ipam.models import get_default_namespace, Prefix
+
+        parent = kwargs.get("parent")
+        namespace = kwargs.pop("namespace", None)
+        host = kwargs.get("host")
+        mask_length = kwargs.get("mask_length")
+        # If `host` or `mask_length` is None skip; then there is no way of getting the closest parent;
+        if parent is None and host is not None and mask_length is not None:
+            if namespace is None:
+                namespace = get_default_namespace()
+            cidr = f"{host}/{mask_length}"
+
+            try:
+                validate_ipv46_address(host)
+            except ValidationError as err:
+                raise ValidationError({"host": err.error_list}) from err
+            try:
+                netaddr.IPNetwork(cidr)
+            except netaddr.AddrFormatError as err:
+                raise ValidationError(f"{cidr} does not appear to be an IPv4 or IPv6 network.") from err
+            parent = Prefix.objects.filter(namespace=namespace).get_closest_parent(cidr=cidr, include_self=True)
+            kwargs["parent"] = parent
+        return super().get_or_create(**kwargs)
+
     def string_search(self, search):
         """
         Interpret a search string and return useful results.