nautobot 2.2.9__py3-none-any.whl → 2.3.0b1__py3-none-any.whl

nautobot/dcim/views.py

@@ -1,12 +1,14 @@
 from collections import OrderedDict
+from copy import deepcopy
 import logging
+import re
 import uuid
 
 from django.contrib import messages
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist, PermissionDenied
 from django.core.paginator import EmptyPage, PageNotAnInteger
-from django.db import transaction
+from django.db import IntegrityError, transaction
 from django.db.models import F, Prefetch
 from django.forms import (
     modelformset_factory,
@@ -20,18 +22,31 @@ from django.utils.html import format_html
 from django.utils.http import url_has_allowed_host_and_scheme
 from django.views.generic import View
 from django_tables2 import RequestConfig
+from rest_framework.decorators import action
+from rest_framework.exceptions import MethodNotAllowed
+from rest_framework.response import Response
 
 from nautobot.circuits.models import Circuit
-from nautobot.core.forms import ConfirmationForm, restrict_form_fields
+from nautobot.cloud.models import CloudAccount
+from nautobot.cloud.tables import CloudAccountTable
+from nautobot.core.exceptions import AbortTransaction
+from nautobot.core.forms import BulkRenameForm, ConfirmationForm, ImportForm, restrict_form_fields
 from nautobot.core.models.querysets import count_related
 from nautobot.core.templatetags.helpers import has_perms
+from nautobot.core.utils.lookup import get_form_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.utils.requests import normalize_querydict
 from nautobot.core.views import generic
 from nautobot.core.views.mixins import (
     GetReturnURLMixin,
+    ObjectBulkDestroyViewMixin,
+    ObjectBulkUpdateViewMixin,
+    ObjectChangeLogViewMixin,
     ObjectDestroyViewMixin,
+    ObjectDetailViewMixin,
     ObjectEditViewMixin,
+    ObjectListViewMixin,
+    ObjectNotesViewMixin,
     ObjectPermissionRequiredMixin,
 )
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
@@ -74,6 +89,10 @@ from .models import (
     Location,
     LocationType,
     Manufacturer,
+    Module,
+    ModuleBay,
+    ModuleBayTemplate,
+    ModuleType,
     PathEndpoint,
     Platform,
     PowerFeed,
@@ -158,7 +177,19 @@ class BaseDeviceComponentsBulkRenameView(generic.BulkRenameView):
     def get_selected_objects_parents_name(self, selected_objects):
         selected_object = selected_objects.first()
         if selected_object and selected_object.device:
-            return selected_object.device.name
+            return selected_object.device.display
+        if selected_object and selected_object.module:
+            return selected_object.module.display
+        return ""
+
+
+class BaseDeviceComponentTemplatesBulkRenameView(generic.BulkRenameView):
+    def get_selected_objects_parents_name(self, selected_objects):
+        selected_object = selected_objects.first()
+        if selected_object and selected_object.device_type:
+            return selected_object.device_type.display
+        if selected_object and selected_object.module_type:
+            return selected_object.module_type.display
         return ""
 
 
@@ -168,7 +199,7 @@ class BaseDeviceComponentsBulkRenameView(generic.BulkRenameView):
 
 
 class LocationTypeListView(generic.ObjectListView):
-    queryset = LocationType.objects.with_tree_fields()
+    queryset = LocationType.objects.all()
     filterset = filters.LocationTypeFilterSet
     filterset_form = forms.LocationTypeFilterForm
     table = tables.LocationTypeTable
@@ -370,7 +401,7 @@ class MigrateLocationDataToContactView(generic.ObjectEditView):
 
         associated_object_id = obj.pk
         associated_object_content_type = ContentType.objects.get_for_model(Location)
-        action = request.POST.get("action")
+        migrate_action = request.POST.get("action")
         try:
             with transaction.atomic():
                 if not has_perms(request.user, ["extras.add_contactassociation"]):
@@ -379,7 +410,7 @@ class MigrateLocationDataToContactView(generic.ObjectEditView):
                     )
                 contact = None
                 team = None
-                if action == LocationDataToContactActionChoices.CREATE_AND_ASSIGN_NEW_CONTACT:
+                if migrate_action == LocationDataToContactActionChoices.CREATE_AND_ASSIGN_NEW_CONTACT:
                     if not has_perms(request.user, ["extras.add_contact"]):
                         raise PermissionDenied("ObjectPermission extras.add_contact is needed to perform this action")
                     contact = Contact(
@@ -390,7 +421,7 @@ class MigrateLocationDataToContactView(generic.ObjectEditView):
                     contact.validated_save()
                     # Trigger permission check
                     Contact.objects.restrict(request.user, "view").get(pk=contact.pk)
-                elif action == LocationDataToContactActionChoices.CREATE_AND_ASSIGN_NEW_TEAM:
+                elif migrate_action == LocationDataToContactActionChoices.CREATE_AND_ASSIGN_NEW_TEAM:
                     if not has_perms(request.user, ["extras.add_team"]):
                         raise PermissionDenied("ObjectPermission extras.add_team is needed to perform this action")
                     team = Team(
@@ -401,12 +432,12 @@ class MigrateLocationDataToContactView(generic.ObjectEditView):
                     team.validated_save()
                     # Trigger permission check
                     Team.objects.restrict(request.user, "view").get(pk=team.pk)
-                elif action == LocationDataToContactActionChoices.ASSOCIATE_EXISTING_CONTACT:
+                elif migrate_action == LocationDataToContactActionChoices.ASSOCIATE_EXISTING_CONTACT:
                     contact = Contact.objects.restrict(request.user, "view").get(pk=request.POST.get("contact"))
-                elif action == LocationDataToContactActionChoices.ASSOCIATE_EXISTING_TEAM:
+                elif migrate_action == LocationDataToContactActionChoices.ASSOCIATE_EXISTING_TEAM:
                     team = Team.objects.restrict(request.user, "view").get(pk=request.POST.get("team"))
                 else:
-                    raise ValueError(f"Invalid action {action} passed from the form")
+                    raise ValueError(f"Invalid action {migrate_action} passed from the form")
 
                 association = ContactAssociation(
                     contact=contact,
@@ -470,7 +501,7 @@ class MigrateLocationDataToContactView(generic.ObjectEditView):
 
 
 class RackGroupListView(generic.ObjectListView):
-    queryset = RackGroup.objects.annotate(rack_count=count_related(Rack, "rack_group"))
+    queryset = RackGroup.objects.all()
     filterset = filters.RackGroupFilterSet
     filterset_form = forms.RackGroupFilterForm
     table = tables.RackGroupTable
@@ -514,7 +545,7 @@ class RackGroupBulkImportView(generic.BulkImportView):  # 3.0 TODO: remove, unus
 
 
 class RackGroupBulkDeleteView(generic.BulkDeleteView):
-    queryset = RackGroup.objects.annotate(rack_count=count_related(Rack, "rack_group")).select_related("location")
+    queryset = RackGroup.objects.all()
     filterset = filters.RackGroupFilterSet
     table = tables.RackGroupTable
 
@@ -525,7 +556,7 @@ class RackGroupBulkDeleteView(generic.BulkDeleteView):
 
 
 class RackListView(generic.ObjectListView):
-    queryset = Rack.objects.annotate(device_count=count_related(Device, "rack"))
+    queryset = Rack.objects.all()
     filterset = filters.RackFilterSet
     filterset_form = forms.RackFilterForm
     table = tables.RackDetailTable
@@ -635,14 +666,14 @@ class RackBulkImportView(generic.BulkImportView):  # 3.0 TODO: remove, unused
 
 
 class RackBulkEditView(generic.BulkEditView):
-    queryset = Rack.objects.select_related("location", "rack_group", "tenant", "role")
+    queryset = Rack.objects.all()
     filterset = filters.RackFilterSet
     table = tables.RackTable
     form = forms.RackBulkEditForm
 
 
 class RackBulkDeleteView(generic.BulkDeleteView):
-    queryset = Rack.objects.select_related("location", "rack_group", "tenant", "role")
+    queryset = Rack.objects.all()
     filterset = filters.RackFilterSet
     table = tables.RackTable
 
@@ -704,11 +735,7 @@ class RackReservationBulkDeleteView(generic.BulkDeleteView):
 
 
 class ManufacturerListView(generic.ObjectListView):
-    queryset = Manufacturer.objects.annotate(
-        device_type_count=count_related(DeviceType, "manufacturer"),
-        inventory_item_count=count_related(InventoryItem, "manufacturer"),
-        platform_count=count_related(Platform, "manufacturer"),
-    )
+    queryset = Manufacturer.objects.all()
     filterset = filters.ManufacturerFilterSet
     filterset_form = forms.ManufacturerFilterForm
     table = tables.ManufacturerTable
@@ -733,7 +760,25 @@ class ManufacturerView(generic.ObjectView):
         }
         RequestConfig(request, paginate).configure(device_table)
 
-        return {"device_table": device_table, **super().get_extra_context(request, instance)}
+        # Cloud Accounts
+        cloud_accounts = (
+            CloudAccount.objects.restrict(request.user, "view")
+            .filter(provider=instance)
+            .select_related("secrets_group")
+        )
+
+        cloud_account_table = CloudAccountTable(cloud_accounts)
+        paginate = {
+            "paginator_class": EnhancedPaginator,
+            "per_page": get_paginate_count(request),
+        }
+        RequestConfig(request, paginate).configure(cloud_account_table)
+
+        return {
+            "device_table": device_table,
+            "cloud_account_table": cloud_account_table,
+            **super().get_extra_context(request, instance),
+        }
 
 
 class ManufacturerEditView(generic.ObjectEditView):
@@ -751,7 +796,7 @@ class ManufacturerBulkImportView(generic.BulkImportView):  # 3.0 TODO: remove, u
 
 
 class ManufacturerBulkDeleteView(generic.BulkDeleteView):
-    queryset = Manufacturer.objects.annotate(device_type_count=count_related(DeviceType, "manufacturer"))
+    queryset = Manufacturer.objects.all()
     table = tables.ManufacturerTable
     filterset = filters.ManufacturerFilterSet
 
@@ -762,7 +807,7 @@ class ManufacturerBulkDeleteView(generic.BulkDeleteView):
 
 
 class DeviceTypeListView(generic.ObjectListView):
-    queryset = DeviceType.objects.annotate(device_count=count_related(Device, "device_type"))
+    queryset = DeviceType.objects.all()
     filterset = filters.DeviceTypeFilterSet
     filterset_form = forms.DeviceTypeFilterForm
     table = tables.DeviceTypeTable
@@ -810,6 +855,10 @@ class DeviceTypeView(generic.ObjectView):
             DeviceBayTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
             orderable=False,
         )
+        modulebay_table = tables.ModuleBayTemplateTable(
+            ModuleBayTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
+            orderable=False,
+        )
         if request.user.has_perm("dcim.change_devicetype"):
             consoleport_table.columns.show("pk")
             consoleserverport_table.columns.show("pk")
@@ -819,6 +868,7 @@ class DeviceTypeView(generic.ObjectView):
             front_port_table.columns.show("pk")
             rear_port_table.columns.show("pk")
             devicebay_table.columns.show("pk")
+            modulebay_table.columns.show("pk")
 
         software_image_files_table = tables.SoftwareImageFileTable(
             instance.software_image_files.restrict(request.user, "view").annotate(
@@ -838,6 +888,7 @@ class DeviceTypeView(generic.ObjectView):
             "front_port_table": front_port_table,
             "rear_port_table": rear_port_table,
             "devicebay_table": devicebay_table,
+            "modulebay_table": modulebay_table,
             "software_image_files_table": software_image_files_table,
             **super().get_extra_context(request, instance),
         }
@@ -864,6 +915,7 @@ class DeviceTypeImportView(generic.ObjectImportView):
         "dcim.add_frontporttemplate",
         "dcim.add_rearporttemplate",
         "dcim.add_devicebaytemplate",
+        "dcim.add_modulebaytemplate",
     ]
     queryset = DeviceType.objects.all()
     model_form = forms.DeviceTypeImportForm
@@ -877,31 +929,255 @@ class DeviceTypeImportView(generic.ObjectImportView):
             ("rear-ports", forms.RearPortTemplateImportForm),
             ("front-ports", forms.FrontPortTemplateImportForm),
             ("device-bays", forms.DeviceBayTemplateImportForm),
+            ("module-bays", forms.ModuleBayTemplateImportForm),
         )
     )
 
 
 class DeviceTypeBulkEditView(generic.BulkEditView):
-    queryset = (
-        DeviceType.objects.select_related("manufacturer")
-        .prefetch_related("software_image_files")
-        .annotate(device_count=count_related(Device, "device_type"))
-    )
+    queryset = DeviceType.objects.all()
     filterset = filters.DeviceTypeFilterSet
     table = tables.DeviceTypeTable
     form = forms.DeviceTypeBulkEditForm
 
 
 class DeviceTypeBulkDeleteView(generic.BulkDeleteView):
-    queryset = (
-        DeviceType.objects.select_related("manufacturer")
-        .prefetch_related("software_image_files")
-        .annotate(device_count=count_related(Device, "device_type"))
-    )
+    queryset = DeviceType.objects.all()
     filterset = filters.DeviceTypeFilterSet
     table = tables.DeviceTypeTable
 
 
+#
+# Module types
+#
+
+
+class ModuleTypeUIViewSet(
+    ObjectDetailViewMixin,
+    ObjectListViewMixin,
+    ObjectEditViewMixin,
+    ObjectDestroyViewMixin,
+    ObjectBulkDestroyViewMixin,
+    ObjectBulkUpdateViewMixin,
+    ObjectChangeLogViewMixin,
+    ObjectNotesViewMixin,
+):
+    queryset = ModuleType.objects.all()
+    filterset_class = filters.ModuleTypeFilterSet
+    filterset_form_class = forms.ModuleTypeFilterForm
+    form_class = forms.ModuleTypeForm
+    import_model_form = forms.ModuleTypeImportForm
+    bulk_update_form_class = forms.ModuleTypeBulkEditForm
+    serializer_class = serializers.ModuleTypeSerializer
+    table_class = tables.ModuleTypeTable
+    related_object_forms = {
+        "console-ports": forms.ConsolePortTemplateImportForm,
+        "console-server-ports": forms.ConsoleServerPortTemplateImportForm,
+        "power-ports": forms.PowerPortTemplateImportForm,
+        "power-outlets": forms.PowerOutletTemplateImportForm,
+        "interfaces": forms.InterfaceTemplateImportForm,
+        "rear-ports": forms.RearPortTemplateImportForm,
+        "front-ports": forms.FrontPortTemplateImportForm,
+        "module-bays": forms.ModuleBayTemplateImportForm,
+    }
+
+    def get_required_permission(self):
+        view_action = self.get_action()
+        if view_action == "import_view":
+            return [
+                *self.get_permissions_for_model(ModuleType, ["add"]),
+                *self.get_permissions_for_model(ConsolePortTemplate, ["add"]),
+                *self.get_permissions_for_model(ConsoleServerPortTemplate, ["add"]),
+                *self.get_permissions_for_model(PowerPortTemplate, ["add"]),
+                *self.get_permissions_for_model(PowerOutletTemplate, ["add"]),
+                *self.get_permissions_for_model(InterfaceTemplate, ["add"]),
+                *self.get_permissions_for_model(FrontPortTemplate, ["add"]),
+                *self.get_permissions_for_model(RearPortTemplate, ["add"]),
+                *self.get_permissions_for_model(ModuleBayTemplate, ["add"]),
+            ]
+
+        return super().get_required_permission()
+
+    def get_extra_context(self, request, instance):
+        if not instance:
+            return {}
+
+        instance_count = Module.objects.restrict(request.user).filter(module_type=instance).count()
+
+        # Component tables
+        consoleport_table = tables.ConsolePortTemplateTable(
+            ConsolePortTemplate.objects.restrict(request.user, "view").filter(module_type=instance),
+            orderable=False,
+        )
+        consoleserverport_table = tables.ConsoleServerPortTemplateTable(
+            ConsoleServerPortTemplate.objects.restrict(request.user, "view").filter(module_type=instance),
+            orderable=False,
+        )
+        powerport_table = tables.PowerPortTemplateTable(
+            PowerPortTemplate.objects.restrict(request.user, "view").filter(module_type=instance),
+            orderable=False,
+        )
+        poweroutlet_table = tables.PowerOutletTemplateTable(
+            PowerOutletTemplate.objects.restrict(request.user, "view").filter(module_type=instance),
+            orderable=False,
+        )
+        interface_table = tables.InterfaceTemplateTable(
+            list(InterfaceTemplate.objects.restrict(request.user, "view").filter(module_type=instance)),
+            orderable=False,
+        )
+        front_port_table = tables.FrontPortTemplateTable(
+            FrontPortTemplate.objects.restrict(request.user, "view").filter(module_type=instance),
+            orderable=False,
+        )
+        rear_port_table = tables.RearPortTemplateTable(
+            RearPortTemplate.objects.restrict(request.user, "view").filter(module_type=instance),
+            orderable=False,
+        )
+        modulebay_table = tables.ModuleBayTemplateTable(
+            ModuleBayTemplate.objects.restrict(request.user, "view").filter(module_type=instance),
+            orderable=False,
+        )
+        if request.user.has_perm("dcim.change_moduletype"):
+            consoleport_table.columns.show("pk")
+            consoleserverport_table.columns.show("pk")
+            powerport_table.columns.show("pk")
+            poweroutlet_table.columns.show("pk")
+            interface_table.columns.show("pk")
+            front_port_table.columns.show("pk")
+            rear_port_table.columns.show("pk")
+            modulebay_table.columns.show("pk")
+
+        return {
+            "instance_count": instance_count,
+            "consoleport_table": consoleport_table,
+            "consoleserverport_table": consoleserverport_table,
+            "powerport_table": powerport_table,
+            "poweroutlet_table": poweroutlet_table,
+            "interface_table": interface_table,
+            "front_port_table": front_port_table,
+            "rear_port_table": rear_port_table,
+            "modulebay_table": modulebay_table,
+        }
+
+    @action(
+        detail=False,
+        methods=["GET", "POST"],
+        url_name="import",
+        url_path="import",
+    )
+    def import_view(self, request, *args, **kwargs):
+        if request.method == "POST":
+            form = ImportForm(request.POST)
+
+            if form.is_valid():
+                self.logger.debug("Import form validation was successful")
+
+                # Initialize model form
+                data = form.cleaned_data["data"]
+                model_form = self.import_model_form(data)
+                restrict_form_fields(model_form, request.user)
+
+                # Assign default values for any fields which were not specified. We have to do this manually because passing
+                # 'initial=' to the form on initialization merely sets default values for the widgets. Since widgets are not
+                # used for YAML/JSON import, we first bind the imported data normally, then update the form's data with the
+                # applicable field defaults as needed prior to form validation.
+                for field_name, field in model_form.fields.items():
+                    if field_name not in data and hasattr(field, "initial"):
+                        model_form.data[field_name] = field.initial
+
+                if model_form.is_valid():
+                    try:
+                        with transaction.atomic():
+                            # Save the primary object
+                            obj = model_form.save()
+
+                            # Enforce object-level permissions
+                            self.queryset.get(pk=obj.pk)
+
+                            self.logger.debug(f"Created {obj} (PK: {obj.pk})")
+
+                            # Iterate through the related object forms (if any), validating and saving each instance.
+                            for (
+                                field_name,
+                                related_object_form,
+                            ) in self.related_object_forms.items():
+                                self.logger.debug(f"Processing form for related objects: {related_object_form}")
+
+                                related_obj_pks = []
+                                for i, rel_obj_data in enumerate(data.get(field_name, [])):
+                                    # add parent object key to related object data
+                                    rel_obj_data[obj._meta.verbose_name.replace(" ", "_")] = str(obj.pk)
+                                    f = related_object_form(rel_obj_data)
+
+                                    for subfield_name, field in f.fields.items():
+                                        if subfield_name not in rel_obj_data and hasattr(field, "initial"):
+                                            f.data[subfield_name] = field.initial
+
+                                    if f.is_valid():
+                                        related_obj = f.save()
+                                        related_obj_pks.append(related_obj.pk)
+                                    else:
+                                        # Replicate errors on the related object form to the primary form for display
+                                        for subfield_name, errors in f.errors.items():
+                                            for err in errors:
+                                                err_msg = f"{field_name}[{i}] {subfield_name}: {err}"
+                                                model_form.add_error(None, err_msg)
+                                        raise AbortTransaction()
+
+                                # Enforce object-level permissions on related objects
+                                model = related_object_form.Meta.model
+                                if model.objects.filter(pk__in=related_obj_pks).count() != len(related_obj_pks):
+                                    raise ObjectDoesNotExist
+
+                    except AbortTransaction:
+                        pass
+
+                    except ObjectDoesNotExist:
+                        msg = "Object creation failed due to object-level permissions violation"
+                        self.logger.debug(msg)
+                        model_form.add_error(None, msg)
+
+                if not model_form.errors:
+                    self.logger.info(f"Import object {obj} (PK: {obj.pk})")
+                    messages.success(
+                        request,
+                        format_html('Imported object: <a href="{}">{}</a>', obj.get_absolute_url(), obj),
+                    )
+
+                    if "_addanother" in request.POST:
+                        return redirect(request.get_full_path())
+
+                    return_url = form.cleaned_data.get("return_url")
+                    if url_has_allowed_host_and_scheme(url=return_url, allowed_hosts=request.get_host()):
+                        return redirect(iri_to_uri(return_url))
+                    else:
+                        return redirect(self.get_return_url(request, obj))
+
+                else:
+                    self.logger.debug("Model form validation failed")
+
+                    # Replicate model form errors for display
+                    for field, errors in model_form.errors.items():
+                        for err in errors:
+                            if field == "__all__":
+                                form.add_error(None, err)
+                            else:
+                                form.add_error(None, f"{field}: {err}")
+
+            else:
+                self.logger.debug("Import form validation failed")
+
+        else:
+            form = ImportForm()
+
+        return Response(
+            {
+                "template": "generic/object_import.html",
+                "form": form,
+            }
+        )
+
+
 #
 # Console port templates
 #
@@ -930,7 +1206,7 @@ class ConsolePortTemplateBulkEditView(generic.BulkEditView):
     filterset = filters.ConsolePortTemplateFilterSet
 
 
-class ConsolePortTemplateBulkRenameView(generic.BulkRenameView):
+class ConsolePortTemplateBulkRenameView(BaseDeviceComponentTemplatesBulkRenameView):
     queryset = ConsolePortTemplate.objects.all()
 
 
@@ -968,7 +1244,7 @@ class ConsoleServerPortTemplateBulkEditView(generic.BulkEditView):
     filterset = filters.ConsoleServerPortTemplateFilterSet
 
 
-class ConsoleServerPortTemplateBulkRenameView(generic.BulkRenameView):
+class ConsoleServerPortTemplateBulkRenameView(BaseDeviceComponentTemplatesBulkRenameView):
     queryset = ConsoleServerPortTemplate.objects.all()
 
 
@@ -1006,7 +1282,7 @@ class PowerPortTemplateBulkEditView(generic.BulkEditView):
     filterset = filters.PowerPortTemplateFilterSet
 
 
-class PowerPortTemplateBulkRenameView(generic.BulkRenameView):
+class PowerPortTemplateBulkRenameView(BaseDeviceComponentTemplatesBulkRenameView):
     queryset = PowerPortTemplate.objects.all()
 
 
@@ -1044,7 +1320,7 @@ class PowerOutletTemplateBulkEditView(generic.BulkEditView):
     filterset = filters.PowerOutletTemplateFilterSet
 
 
-class PowerOutletTemplateBulkRenameView(generic.BulkRenameView):
+class PowerOutletTemplateBulkRenameView(BaseDeviceComponentTemplatesBulkRenameView):
     queryset = PowerOutletTemplate.objects.all()
 
 
@@ -1081,7 +1357,7 @@ class InterfaceTemplateBulkEditView(generic.BulkEditView):
     filterset = filters.InterfaceTemplateFilterSet
 
 
-class InterfaceTemplateBulkRenameView(generic.BulkRenameView):
+class InterfaceTemplateBulkRenameView(BaseDeviceComponentTemplatesBulkRenameView):
     queryset = InterfaceTemplate.objects.all()
 
 
@@ -1118,7 +1394,7 @@ class FrontPortTemplateBulkEditView(generic.BulkEditView):
     filterset = filters.FrontPortTemplateFilterSet
 
 
-class FrontPortTemplateBulkRenameView(generic.BulkRenameView):
+class FrontPortTemplateBulkRenameView(BaseDeviceComponentTemplatesBulkRenameView):
     queryset = FrontPortTemplate.objects.all()
 
 
@@ -1155,7 +1431,7 @@ class RearPortTemplateBulkEditView(generic.BulkEditView):
     filterset = filters.RearPortTemplateFilterSet
 
 
-class RearPortTemplateBulkRenameView(generic.BulkRenameView):
+class RearPortTemplateBulkRenameView(BaseDeviceComponentTemplatesBulkRenameView):
     queryset = RearPortTemplate.objects.all()
 
 
@@ -1192,7 +1468,7 @@ class DeviceBayTemplateBulkEditView(generic.BulkEditView):
     filterset = filters.DeviceBayTemplateFilterSet
 
 
-class DeviceBayTemplateBulkRenameView(generic.BulkRenameView):
+class DeviceBayTemplateBulkRenameView(BaseDeviceComponentTemplatesBulkRenameView):
     queryset = DeviceBayTemplate.objects.all()
 
 
@@ -1202,16 +1478,212 @@ class DeviceBayTemplateBulkDeleteView(generic.BulkDeleteView):
     filterset = filters.DeviceBayTemplateFilterSet
 
 
+#
+# Module bay templates
+#
+
+
+class ModuleBayCommonViewSetMixin:
+    """NautobotUIViewSet for ModuleBay views to handle templated create and bulk rename views."""
+
+    def create(self, request, *args, **kwargs):
+        if request.method == "POST":
+            return self.perform_create(request, *args, **kwargs)
+
+        form = self.create_form_class(initial=request.GET)
+        model_form = self.model_form_class(request.GET)
+
+        return Response(
+            {
+                "template": self.create_template_name,
+                "component_type": self.queryset.model._meta.verbose_name,
+                "model_form": model_form,
+                "form": form,
+                "return_url": self.get_return_url(request),
+            },
+        )
+
+    def perform_create(self, request, *args, **kwargs):
+        form = self.create_form_class(
+            request.POST,
+            initial=normalize_querydict(request.GET, form_class=self.create_form_class),
+        )
+        model_form = self.model_form_class(
+            request.POST,
+            initial=normalize_querydict(request.GET, form_class=self.model_form_class),
+        )
+
+        if form.is_valid():
+            new_components = []
+            data = deepcopy(request.POST)
+
+            names = form.cleaned_data["name_pattern"]
+            labels = form.cleaned_data.get("label_pattern")
+            positions = form.cleaned_data.get("position_pattern")
+            for i, name in enumerate(names):
+                label = labels[i] if labels else None
+                position = positions[i] if positions else None
+                # Initialize the individual component form
+                data["name"] = name
+                data["label"] = label
+                data["position"] = position
+                component_form = self.model_form_class(
+                    data,
+                    initial=normalize_querydict(request.GET, form_class=self.model_form_class),
+                )
+                if component_form.is_valid():
+                    new_components.append(component_form)
+                else:
+                    for field, errors in component_form.errors.as_data().items():
+                        # Assign errors on the child form's name/position/label field to *_pattern fields on the parent form
+                        if field.endswith("_pattern"):
+                            field = field[:-8]
+                        for e in errors:
+                            err_str = ", ".join(e)
+                            form.add_error(field, f"{name}: {err_str}")
+
+            if not form.errors:
+                try:
+                    with transaction.atomic():
+                        # Create the new components
+                        new_objs = []
+                        for component_form in new_components:
+                            obj = component_form.save()
+                            new_objs.append(obj)
+
+                        # Enforce object-level permissions
+                        if self.get_queryset().filter(pk__in=[obj.pk for obj in new_objs]).count() != len(new_objs):
+                            raise ObjectDoesNotExist
+
+                    messages.success(
+                        request,
+                        f"Added {len(new_components)} {self.queryset.model._meta.verbose_name_plural}",
+                    )
+                    if "_addanother" in request.POST:
+                        return redirect(request.get_full_path())
+                    else:
+                        return redirect(self.get_return_url(request))
+
+                except ObjectDoesNotExist:
+                    msg = "Component creation failed due to object-level permissions violation"
+                    form.add_error(None, msg)
+
+        return Response(
+            {
+                "template": self.create_template_name,
+                "component_type": self.queryset.model._meta.verbose_name,
+                "form": form,
+                "model_form": model_form,
+                "return_url": self.get_return_url(request),
+            },
+        )
+
+    def _bulk_rename(self, request, *args, **kwargs):
+        # TODO: This shouldn't be needed but default behavior of custom actions that don't support "GET" is broken
+        if request.method != "POST":
+            raise MethodNotAllowed(request.method)
+
+        query_pks = request.POST.getlist("pk")
+        selected_objects = self.get_queryset().filter(pk__in=query_pks) if query_pks else None
+
+        # Create a new Form class from BulkRenameForm
+        class _Form(BulkRenameForm):
+            pk = ModelMultipleChoiceField(queryset=self.get_queryset(), widget=MultipleHiddenInput())
+
+        # selected_objects would return False; if no query_pks or invalid query_pks
+        if not selected_objects:
+            messages.warning(request, f"No valid {self.queryset.model._meta.verbose_name_plural} were selected.")
+            return redirect(self.get_return_url(request))
+
+        if "_preview" in request.POST or "_apply" in request.POST:
+            form = _Form(request.POST, initial={"pk": query_pks})
+            if form.is_valid():
+                try:
+                    with transaction.atomic():
+                        renamed_pks = []
+                        for obj in selected_objects:
+                            find = form.cleaned_data["find"]
+                            replace = form.cleaned_data["replace"]
+                            if form.cleaned_data["use_regex"]:
+                                try:
+                                    obj.new_name = re.sub(find, replace, obj.name)
+                                # Catch regex group reference errors
+                                except re.error:
+                                    obj.new_name = obj.name
+                            else:
+                                obj.new_name = obj.name.replace(find, replace)
+                            renamed_pks.append(obj.pk)
+
+                        if "_apply" in request.POST:
+                            for obj in selected_objects:
+                                obj.name = obj.new_name
+                                obj.save()
+
+                            # Enforce constrained permissions
+                            if self.get_queryset().filter(pk__in=renamed_pks).count() != len(selected_objects):
+                                raise ObjectDoesNotExist
+
+                            messages.success(
+                                request,
+                                f"Renamed {len(selected_objects)} {self.queryset.model._meta.verbose_name_plural}",
+                            )
+                            return redirect(self.get_return_url(request))
+
+                except ObjectDoesNotExist:
+                    msg = "Object update failed due to object-level permissions violation"
+                    form.add_error(None, msg)
+
+        else:
+            form = _Form(initial={"pk": query_pks})
+
+        return Response(
+            {
+                "template": "generic/object_bulk_rename.html",
+                "form": form,
+                "obj_type_plural": self.queryset.model._meta.verbose_name_plural,
+                "selected_objects": selected_objects,
+                "return_url": self.get_return_url(request),
+                "parent_name": self.get_selected_objects_parents_name(selected_objects),
+            }
+        )
+
+
+class ModuleBayTemplateUIViewSet(
+    ModuleBayCommonViewSetMixin,
+    ObjectEditViewMixin,
+    ObjectDestroyViewMixin,
+    ObjectBulkDestroyViewMixin,
+    ObjectBulkUpdateViewMixin,
+):
+    queryset = ModuleBayTemplate.objects.all()
+    filterset_class = filters.ModuleBayTemplateFilterSet
+    bulk_update_form_class = forms.ModuleBayTemplateBulkEditForm
+    create_form_class = forms.ModuleBayTemplateCreateForm
+    form_class = forms.ModuleBayTemplateForm
+    model_form_class = forms.ModuleBayTemplateForm
+    serializer_class = serializers.ModuleBayTemplateSerializer
+    table_class = tables.ModuleBayTemplateTable
+    create_template_name = "dcim/device_component_add.html"
+
+    def get_selected_objects_parents_name(self, selected_objects):
+        selected_object = selected_objects.first()
+        if selected_object:
+            parent = selected_object.device_type or selected_object.module_type
+            return parent.display
+        return ""
+
+    @action(detail=False, methods=["GET", "POST"], url_path="rename", url_name="bulk_rename")
+    def bulk_rename(self, request, *args, **kwargs):
+        return self._bulk_rename(request, *args, **kwargs)
+
+
 #
 # Platforms
 #
 
 
 class PlatformListView(generic.ObjectListView):
-    queryset = Platform.objects.annotate(
-        device_count=count_related(Device, "platform"),
-        virtual_machine_count=count_related(VirtualMachine, "platform"),
-    )
+    queryset = Platform.objects.all()
     filterset = filters.PlatformFilterSet
     filterset_form = forms.PlatformFilterForm
     table = tables.PlatformTable
@@ -1330,48 +1802,65 @@ class DeviceView(generic.ObjectView):
         else:
             software_version_images = []
 
+        modulebay_count = instance.module_bays.count()
+        module_count = instance.module_bays.filter(installed_module__isnull=False).count()
+
         return {
             "services": services,
             "software_version_images": software_version_images,
             "vc_members": vc_members,
             "vrf_table": vrf_table,
             "active_tab": "device",
+            "modulebay_count": modulebay_count,
+            "module_count": f"{module_count}/{modulebay_count}",
+        }
+
+
+class DeviceComponentTabView(generic.ObjectView):
+    queryset = Device.objects.all()
+
+    def get_extra_context(self, request, instance):
+        modulebay_count = instance.module_bays.count()
+        module_count = instance.module_bays.filter(installed_module__isnull=False).count()
+
+        return {
+            "modulebay_count": modulebay_count,
+            "module_count": f"{module_count}/{modulebay_count}",
         }
 
 
-class DeviceConsolePortsView(generic.ObjectView):
+class DeviceConsolePortsView(DeviceComponentTabView):
     queryset = Device.objects.all()
     template_name = "dcim/device/consoleports.html"
 
     def get_extra_context(self, request, instance):
         consoleports = (
-            ConsolePort.objects.restrict(request.user, "view")
-            .filter(device=instance)
+            instance.all_console_ports.restrict(request.user, "view")
             .select_related("cable")
             .prefetch_related("_path__destination")
         )
-        consoleport_table = tables.DeviceConsolePortTable(data=consoleports, user=request.user, orderable=False)
+        consoleport_table = tables.DeviceModuleConsolePortTable(data=consoleports, user=request.user, orderable=False)
         if request.user.has_perm("dcim.change_consoleport") or request.user.has_perm("dcim.delete_consoleport"):
             consoleport_table.columns.show("pk")
 
         return {
+            **super().get_extra_context(request, instance),
             "consoleport_table": consoleport_table,
             "active_tab": "console-ports",
         }
 
 
-class DeviceConsoleServerPortsView(generic.ObjectView):
+class DeviceConsoleServerPortsView(DeviceComponentTabView):
     queryset = Device.objects.all()
     template_name = "dcim/device/consoleserverports.html"
 
     def get_extra_context(self, request, instance):
         consoleserverports = (
-            ConsoleServerPort.objects.restrict(request.user, "view")
-            .filter(device=instance)
+            instance.all_console_server_ports.restrict(request.user, "view")
             .select_related("cable")
             .prefetch_related("_path__destination")
         )
-        consoleserverport_table = tables.DeviceConsoleServerPortTable(
+        consoleserverport_table = tables.DeviceModuleConsoleServerPortTable(
             data=consoleserverports, user=request.user, orderable=False
         )
         if request.user.has_perm("dcim.change_consoleserverport") or request.user.has_perm(
@@ -1380,60 +1869,61 @@ class DeviceConsoleServerPortsView(generic.ObjectView):
             consoleserverport_table.columns.show("pk")
 
         return {
+            **super().get_extra_context(request, instance),
             "consoleserverport_table": consoleserverport_table,
             "active_tab": "console-server-ports",
         }
 
 
-class DevicePowerPortsView(generic.ObjectView):
+class DevicePowerPortsView(DeviceComponentTabView):
     queryset = Device.objects.all()
     template_name = "dcim/device/powerports.html"
 
     def get_extra_context(self, request, instance):
         powerports = (
-            PowerPort.objects.restrict(request.user, "view")
-            .filter(device=instance)
+            instance.all_power_ports.restrict(request.user, "view")
             .select_related("cable")
             .prefetch_related("_path__destination")
         )
-        powerport_table = tables.DevicePowerPortTable(data=powerports, user=request.user, orderable=False)
+        powerport_table = tables.DeviceModulePowerPortTable(data=powerports, user=request.user, orderable=False)
         if request.user.has_perm("dcim.change_powerport") or request.user.has_perm("dcim.delete_powerport"):
             powerport_table.columns.show("pk")
 
         return {
+            **super().get_extra_context(request, instance),
             "powerport_table": powerport_table,
             "active_tab": "power-ports",
         }
 
 
-class DevicePowerOutletsView(generic.ObjectView):
+class DevicePowerOutletsView(DeviceComponentTabView):
     queryset = Device.objects.all()
     template_name = "dcim/device/poweroutlets.html"
 
     def get_extra_context(self, request, instance):
         poweroutlets = (
-            PowerOutlet.objects.restrict(request.user, "view")
-            .filter(device=instance)
+            instance.all_power_outlets.restrict(request.user, "view")
             .select_related("cable", "power_port")
             .prefetch_related("_path__destination")
         )
-        poweroutlet_table = tables.DevicePowerOutletTable(data=poweroutlets, user=request.user, orderable=False)
+        poweroutlet_table = tables.DeviceModulePowerOutletTable(data=poweroutlets, user=request.user, orderable=False)
         if request.user.has_perm("dcim.change_poweroutlet") or request.user.has_perm("dcim.delete_poweroutlet"):
             poweroutlet_table.columns.show("pk")
 
         return {
+            **super().get_extra_context(request, instance),
             "poweroutlet_table": poweroutlet_table,
             "active_tab": "power-outlets",
         }
 
 
-class DeviceInterfacesView(generic.ObjectView):
+class DeviceInterfacesView(DeviceComponentTabView):
     queryset = Device.objects.all()
     template_name = "dcim/device/interfaces.html"
 
     def get_extra_context(self, request, instance):
         interfaces = (
-            instance.vc_interfaces.restrict(request.user, "view")
+            instance.all_interfaces.restrict(request.user, "view")
             .prefetch_related(
                 Prefetch("ip_addresses", queryset=IPAddress.objects.restrict(request.user)),
                 Prefetch("member_interfaces", queryset=Interface.objects.restrict(request.user)),
@@ -1441,56 +1931,56 @@ class DeviceInterfacesView(generic.ObjectView):
                 "tags",
             )
             .select_related("lag", "cable")
+            .order_by("_name")
         )
-        interface_table = tables.DeviceInterfaceTable(data=interfaces, user=request.user, orderable=False)
+        interface_table = tables.DeviceModuleInterfaceTable(data=interfaces, user=request.user, orderable=False)
         if VirtualChassis.objects.filter(master=instance).exists():
             interface_table.columns.show("device")
         if request.user.has_perm("dcim.change_interface") or request.user.has_perm("dcim.delete_interface"):
             interface_table.columns.show("pk")
 
         return {
+            **super().get_extra_context(request, instance),
             "interface_table": interface_table,
             "active_tab": "interfaces",
         }
 
 
-class DeviceFrontPortsView(generic.ObjectView):
+class DeviceFrontPortsView(DeviceComponentTabView):
     queryset = Device.objects.all()
     template_name = "dcim/device/frontports.html"
 
     def get_extra_context(self, request, instance):
-        frontports = (
-            FrontPort.objects.restrict(request.user, "view")
-            .filter(device=instance)
-            .select_related("cable", "rear_port")
-        )
-        frontport_table = tables.DeviceFrontPortTable(data=frontports, user=request.user, orderable=False)
+        frontports = instance.all_front_ports.restrict(request.user, "view").select_related("cable", "rear_port")
+        frontport_table = tables.DeviceModuleFrontPortTable(data=frontports, user=request.user, orderable=False)
         if request.user.has_perm("dcim.change_frontport") or request.user.has_perm("dcim.delete_frontport"):
             frontport_table.columns.show("pk")
 
         return {
+            **super().get_extra_context(request, instance),
             "frontport_table": frontport_table,
             "active_tab": "front-ports",
         }
 
 
-class DeviceRearPortsView(generic.ObjectView):
+class DeviceRearPortsView(DeviceComponentTabView):
     queryset = Device.objects.all()
     template_name = "dcim/device/rearports.html"
 
     def get_extra_context(self, request, instance):
-        rearports = RearPort.objects.restrict(request.user, "view").filter(device=instance).select_related("cable")
-        rearport_table = tables.DeviceRearPortTable(data=rearports, user=request.user, orderable=False)
+        rearports = instance.all_rear_ports.restrict(request.user, "view").select_related("cable")
+        rearport_table = tables.DeviceModuleRearPortTable(data=rearports, user=request.user, orderable=False)
         if request.user.has_perm("dcim.change_rearport") or request.user.has_perm("dcim.delete_rearport"):
             rearport_table.columns.show("pk")
 
         return {
+            **super().get_extra_context(request, instance),
             "rearport_table": rearport_table,
             "active_tab": "rear-ports",
         }
 
 
-class DeviceDeviceBaysView(generic.ObjectView):
+class DeviceDeviceBaysView(DeviceComponentTabView):
     queryset = Device.objects.all()
     template_name = "dcim/device/devicebays.html"
 
@@ -1507,11 +1997,34 @@ class DeviceDeviceBaysView(generic.ObjectView):
             devicebay_table.columns.show("pk")
 
         return {
+            **super().get_extra_context(request, instance),
             "devicebay_table": devicebay_table,
             "active_tab": "device-bays",
         }
 
 
+class DeviceModuleBaysView(DeviceComponentTabView):
+    queryset = Device.objects.all()
+    template_name = "dcim/device/modulebays.html"
+
+    def get_extra_context(self, request, instance):
+        # note: Device modules tab shouldn't show descendant modules until a proper tree view is implemented
+        modulebays = (
+            ModuleBay.objects.restrict(request.user, "view")
+            .filter(parent_device=instance)
+            .prefetch_related("installed_module__status", "installed_module")
+        )
+        modulebay_table = tables.DeviceModuleBayTable(data=modulebays, user=request.user, orderable=False)
+        if request.user.has_perm("dcim.change_modulebay") or request.user.has_perm("dcim.delete_modulebay"):
+            modulebay_table.columns.show("pk")
+
+        return {
+            **super().get_extra_context(request, instance),
+            "modulebay_table": modulebay_table,
+            "active_tab": "module-bays",
+        }
+
+
 class DeviceInventoryView(generic.ObjectView):
     queryset = Device.objects.all()
     template_name = "dcim/device/inventory.html"
@@ -1548,7 +2061,7 @@ class DeviceLLDPNeighborsView(generic.ObjectView):
 
     def get_extra_context(self, request, instance):
         interfaces = (
-            instance.vc_interfaces.restrict(request.user, "view")
+            instance.all_interfaces.restrict(request.user, "view")
             .prefetch_related("_path__destination")
             .exclude(type__in=NONCONNECTABLE_IFACE_TYPES)
         )
@@ -1585,7 +2098,7 @@ class DeviceChangeLogView(ObjectChangeLogView):
     base_template = "dcim/device/base.html"
 
 
-class DeviceDynamicGroupsView(ObjectDynamicGroupsView):
+class DeviceDynamicGroupsView(ObjectDynamicGroupsView):  # 3.0 TODO: remove, deprecated in 2.3
     base_template = "dcim/device/base.html"
 
 
@@ -1626,6 +2139,432 @@ class DeviceBulkDeleteView(generic.BulkDeleteView):
     table = tables.DeviceTable
 
 
+#
+# Modules
+#
+
+
+class BulkComponentCreateUIViewSetMixin:
+    def _bulk_component_create(self, request, component_queryset, bulk_component_form, parent_field=None):
+        parent_model_name = self.queryset.model._meta.verbose_name_plural
+        if parent_field is None:
+            parent_field = self.queryset.model._meta.model_name
+        model_name = component_queryset.model._meta.verbose_name_plural
+        model = component_queryset.model
+        component_create_form = get_form_for_model(model)
+
+        # Are we editing *all* objects in the queryset or just a selected subset?
+        if request.POST.get("_all") and self.filterset is not None:
+            pk_list = [obj.pk for obj in self.filterset(request.GET, self.get_queryset().only("pk")).qs]
+        else:
+            pk_list = request.POST.getlist("pk")
+
+        selected_objects = self.get_queryset().filter(pk__in=pk_list)
+        if not selected_objects:
+            messages.warning(
+                request,
+                f"No {parent_model_name} were selected.",
+            )
+            return redirect(self.get_return_url(request))
+        table = self.table_class(selected_objects)
+
+        if "_create" in request.POST:
+            form = bulk_component_form(model, request.POST)
+
+            if form.is_valid():
+                new_components = []
+                data = deepcopy(form.cleaned_data)
+
+                try:
+                    with transaction.atomic():
+                        for obj in data["pk"]:
+                            names = data["name_pattern"]
+                            labels = data["label_pattern"] if "label_pattern" in data else None
+                            for i, name in enumerate(names):
+                                label = labels[i] if labels else None
+
+                                component_data = {
+                                    parent_field: obj.pk,
+                                    "name": name,
+                                    "label": label,
+                                }
+                                component_data.update(data)
+                                component_form = component_create_form(component_data)
+                                if component_form.is_valid():
+                                    instance = component_form.save()
+                                    new_components.append(instance)
+                                else:
+                                    for (
+                                        field,
+                                        errors,
+                                    ) in component_form.errors.as_data().items():
+                                        for e in errors:
+                                            err_str = ", ".join(e)
+                                            form.add_error(
+                                                field,
+                                                f"{obj} {name}: {err_str}",
+                                            )
+
+                        # Enforce object-level permissions
+                        if component_queryset.filter(pk__in=[obj.pk for obj in new_components]).count() != len(
+                            new_components
+                        ):
+                            raise ObjectDoesNotExist
+
+                except IntegrityError:
+                    pass
+
+                except ObjectDoesNotExist:
+                    msg = "Component creation failed due to object-level permissions violation"
+                    form.add_error(None, msg)
+
+                if not form.errors:
+                    msg = f"Added {len(new_components)} {model_name} to {len(form.cleaned_data['pk'])} {parent_model_name}."
+                    messages.success(request, msg)
+
+                    return redirect(self.get_return_url(request))
+
+        else:
+            form = bulk_component_form(model, initial={"pk": pk_list})
+
+        return Response(
+            {
+                "template": "generic/object_bulk_add_component.html",
+                "form": form,
+                "parent_model_name": parent_model_name,
+                "model_name": model_name,
+                "table": table,
+                "return_url": self.get_return_url(request),
+            },
+        )
+
+
+class ModuleUIViewSet(BulkComponentCreateUIViewSetMixin, NautobotUIViewSet):
+    queryset = Module.objects.all()
+    filterset_class = filters.ModuleFilterSet
+    filterset_form_class = forms.ModuleFilterForm
+    form_class = forms.ModuleForm
+    bulk_update_form_class = forms.ModuleBulkEditForm
+    serializer_class = serializers.ModuleSerializer
+    table_class = tables.ModuleTable
+    component_model = None
+
+    def get_action(self):
+        if self.component_model:
+            method = self.request.method.lower()
+            if method == "get":
+                return "view"
+            else:
+                return "change"
+
+        return super().get_action()
+
+    def get_required_permission(self):
+        # TODO: standardize a pattern for permissions enforcement on custom actions
+        if self.component_model:
+            model = self.component_model
+            method = self.request.method.lower()
+            if method == "get":
+                component_action = "view"
+                permissions = [*self.get_permissions_for_model(model, [component_action]), "dcim.view_module"]
+            elif self.action.startswith("bulk_add"):
+                component_action = "add"
+                permissions = [*self.get_permissions_for_model(model, [component_action]), "dcim.change_module"]
+            else:
+                component_action = "change"
+                permissions = [*self.get_permissions_for_model(model, [component_action]), "dcim.change_module"]
+
+            return permissions
+
+        return super().get_required_permission()
+
+    def get_extra_context(self, request, instance):
+        context = super().get_extra_context(request, instance)
+        if instance:
+            context["modulebay_count"] = instance.module_bays.count()
+            populated_module_count = instance.module_bays.filter(installed_module__isnull=False).count()
+            context["module_count"] = f"{populated_module_count}/{context['modulebay_count']}"
+        if self.action in ["create", "update"]:
+            context["active_parent_tab"] = self._get_edit_view_active_parent_tab(request)
+        return context
+
+    def _get_edit_view_active_parent_tab(self, request):
+        active_parent_tab = "device"
+        form_class = self.get_form_class()
+        form = form_class(
+            data=request.POST,
+            files=request.FILES,
+            initial=normalize_querydict(request.GET, form_class=form_class),
+            instance=self.get_object(),
+        )
+        if form["parent_module_bay_module"].initial:
+            active_parent_tab = "module"
+        elif form["location"].initial:
+            active_parent_tab = "location"
+
+        return active_parent_tab
+
+    @action(detail=True, url_path="console-ports", component_model=ConsolePort)
+    def consoleports(self, request, *args, **kwargs):
+        instance = self.get_object()
+        consoleports = (
+            instance.console_ports.restrict(request.user, "view")
+            .select_related("cable")
+            .prefetch_related("_path__destination")
+        )
+        consoleport_table = tables.DeviceModuleConsolePortTable(data=consoleports, user=request.user, orderable=False)
+        if request.user.has_perm("dcim.change_consoleport") or request.user.has_perm("dcim.delete_consoleport"):
+            consoleport_table.columns.show("pk")
+
+        return Response(
+            {
+                "consoleport_table": consoleport_table,
+                "active_tab": "console-ports",
+            }
+        )
+
+    @action(detail=True, url_path="console-server-ports", component_model=ConsoleServerPort)
+    def consoleserverports(self, request, *args, **kwargs):
+        instance = self.get_object()
+        consoleserverports = (
+            instance.console_server_ports.restrict(request.user, "view")
+            .select_related("cable")
+            .prefetch_related("_path__destination")
+        )
+        consoleserverport_table = tables.DeviceModuleConsoleServerPortTable(
+            data=consoleserverports, user=request.user, orderable=False, parent_module=instance
+        )
+        if request.user.has_perm("dcim.change_consoleserverport") or request.user.has_perm(
+            "dcim.delete_consoleserverport"
+        ):
+            consoleserverport_table.columns.show("pk")
+
+        return Response(
+            {
+                "consoleserverport_table": consoleserverport_table,
+                "active_tab": "console-server-ports",
+            }
+        )
+
+    @action(detail=True, url_path="power-ports", component_model=PowerPort)
+    def powerports(self, request, *args, **kwargs):
+        instance = self.get_object()
+        powerports = (
+            instance.power_ports.restrict(request.user, "view")
+            .select_related("cable")
+            .prefetch_related("_path__destination")
+        )
+        powerport_table = tables.DeviceModulePowerPortTable(
+            data=powerports, user=request.user, orderable=False, parent_module=instance
+        )
+        if request.user.has_perm("dcim.change_powerport") or request.user.has_perm("dcim.delete_powerport"):
+            powerport_table.columns.show("pk")
+
+        return Response(
+            {
+                "powerport_table": powerport_table,
+                "active_tab": "power-ports",
+            }
+        )
+
+    @action(detail=True, url_path="power-outlets", component_model=PowerOutlet)
+    def poweroutlets(self, request, *args, **kwargs):
+        instance = self.get_object()
+        poweroutlets = (
+            instance.power_outlets.restrict(request.user, "view")
+            .select_related("cable", "power_port")
+            .prefetch_related("_path__destination")
+        )
+        poweroutlet_table = tables.DeviceModulePowerOutletTable(
+            data=poweroutlets, user=request.user, orderable=False, parent_module=instance
+        )
+        if request.user.has_perm("dcim.change_poweroutlet") or request.user.has_perm("dcim.delete_poweroutlet"):
+            poweroutlet_table.columns.show("pk")
+
+        return Response(
+            {
+                "poweroutlet_table": poweroutlet_table,
+                "active_tab": "power-outlets",
+            }
+        )
+
+    @action(detail=True, component_model=Interface)
+    def interfaces(self, request, *args, **kwargs):
+        instance = self.get_object()
+        interfaces = (
+            instance.interfaces.restrict(request.user, "view")
+            .prefetch_related(
+                Prefetch("ip_addresses", queryset=IPAddress.objects.restrict(request.user)),
+                Prefetch("member_interfaces", queryset=Interface.objects.restrict(request.user)),
+                "_path__destination",
+                "tags",
+            )
+            .select_related("lag", "cable")
+        )
+        interface_table = tables.DeviceModuleInterfaceTable(
+            data=interfaces, user=request.user, orderable=False, parent_module=instance
+        )
+        if request.user.has_perm("dcim.change_interface") or request.user.has_perm("dcim.delete_interface"):
+            interface_table.columns.show("pk")
+
+        return Response(
+            {
+                "interface_table": interface_table,
+                "active_tab": "interfaces",
+            }
+        )
+
+    @action(detail=True, url_path="front-ports", component_model=FrontPort)
+    def frontports(self, request, *args, **kwargs):
+        instance = self.get_object()
+        frontports = instance.front_ports.restrict(request.user, "view").select_related("cable", "rear_port")
+        frontport_table = tables.DeviceModuleFrontPortTable(
+            data=frontports, user=request.user, orderable=False, parent_module=instance
+        )
+        if request.user.has_perm("dcim.change_frontport") or request.user.has_perm("dcim.delete_frontport"):
+            frontport_table.columns.show("pk")
+
+        return Response(
+            {
+                "frontport_table": frontport_table,
+                "active_tab": "front-ports",
+            },
+        )
+
+    @action(detail=True, url_path="rear-ports", component_model=RearPort)
+    def rearports(self, request, *args, **kwargs):
+        instance = self.get_object()
+        rearports = instance.rear_ports.restrict(request.user, "view").select_related("cable")
+        rearport_table = tables.DeviceModuleRearPortTable(
+            data=rearports, user=request.user, orderable=False, parent_module=instance
+        )
+        if request.user.has_perm("dcim.change_rearport") or request.user.has_perm("dcim.delete_rearport"):
+            rearport_table.columns.show("pk")
+
+        return Response(
+            {
+                "rearport_table": rearport_table,
+                "active_tab": "rear-ports",
+            }
+        )
+
+    @action(detail=True, url_path="module-bays", component_model=ModuleBay)
+    def modulebays(self, request, *args, **kwargs):
+        instance = self.get_object()
+        modulebays = instance.module_bays.restrict(request.user, "view").prefetch_related(
+            "installed_module__status", "installed_module"
+        )
+        modulebay_table = tables.ModuleModuleBayTable(data=modulebays, user=request.user, orderable=False)
+        if request.user.has_perm("dcim.change_modulebay") or request.user.has_perm("dcim.delete_modulebay"):
+            modulebay_table.columns.show("pk")
+
+        return Response(
+            {
+                "modulebay_table": modulebay_table,
+                "active_tab": "module-bays",
+            }
+        )
+
+    @action(
+        detail=False,
+        methods=["POST"],
+        url_path="console-ports/add",
+        url_name="bulk_add_consoleport",
+        component_model=ConsolePort,
+    )
+    def bulk_add_consoleport(self, request, *args, **kwargs):
+        return self._bulk_component_create(
+            request=request,
+            component_queryset=ConsolePort.objects.all(),
+            bulk_component_form=forms.ModuleConsolePortBulkCreateForm,
+        )
+
+    @action(
+        detail=False,
+        methods=["POST"],
+        url_path="console-server-ports/add",
+        url_name="bulk_add_consoleserverport",
+        component_model=ConsoleServerPort,
+    )
+    def bulk_add_consoleserverport(self, request, *args, **kwargs):
+        return self._bulk_component_create(
+            request=request,
+            component_queryset=ConsoleServerPort.objects.all(),
+            bulk_component_form=forms.ModuleConsoleServerPortBulkCreateForm,
+        )
+
+    @action(
+        detail=False,
+        methods=["POST"],
+        url_path="power-ports/add",
+        url_name="bulk_add_powerport",
+        component_model=PowerPort,
+    )
+    def bulk_add_powerport(self, request, *args, **kwargs):
+        return self._bulk_component_create(
+            request=request,
+            component_queryset=PowerPort.objects.all(),
+            bulk_component_form=forms.ModulePowerPortBulkCreateForm,
+        )
+
+    @action(
+        detail=False,
+        methods=["POST"],
+        url_path="power-outlets/add",
+        url_name="bulk_add_poweroutlet",
+        component_model=PowerOutlet,
+    )
+    def bulk_add_poweroutlet(self, request, *args, **kwargs):
+        return self._bulk_component_create(
+            request=request,
+            component_queryset=PowerOutlet.objects.all(),
+            bulk_component_form=forms.ModulePowerOutletBulkCreateForm,
+        )
+
+    @action(
+        detail=False,
+        methods=["POST"],
+        url_path="interfaces/add",
+        url_name="bulk_add_interface",
+        component_model=Interface,
+    )
+    def bulk_add_interface(self, request, *args, **kwargs):
+        return self._bulk_component_create(
+            request=request,
+            component_queryset=Interface.objects.all(),
+            bulk_component_form=forms.ModuleInterfaceBulkCreateForm,
+        )
+
+    @action(
+        detail=False,
+        methods=["POST"],
+        url_path="rear-ports/add",
+        url_name="bulk_add_rearport",
+        component_model=RearPort,
+    )
+    def bulk_add_rearport(self, request, *args, **kwargs):
+        return self._bulk_component_create(
+            request=request,
+            component_queryset=RearPort.objects.all(),
+            bulk_component_form=forms.ModuleRearPortBulkCreateForm,
+        )
+
+    @action(
+        detail=False,
+        methods=["POST"],
+        url_path="module-bays/add",
+        url_name="bulk_add_modulebay",
+        component_model=ModuleBay,
+    )
+    def bulk_add_modulebay(self, request, *args, **kwargs):
+        return self._bulk_component_create(
+            request=request,
+            component_queryset=ModuleBay.objects.all(),
+            bulk_component_form=forms.ModuleModuleBayBulkCreateForm,
+            parent_field="parent_module",
+        )
+
+
 #
 # Console ports
 #
@@ -1643,7 +2582,11 @@ class ConsolePortView(generic.ObjectView):
     queryset = ConsolePort.objects.all()
 
     def get_extra_context(self, request, instance):
-        return {"breadcrumb_url": "dcim:device_consoleports", **super().get_extra_context(request, instance)}
+        return {
+            "device_breadcrumb_url": "dcim:device_consoleports",
+            "module_breadcrumb_url": "dcim:module_consoleports",
+            **super().get_extra_context(request, instance),
+        }
 
 
 class ConsolePortCreateView(generic.ComponentCreateView):
@@ -1705,7 +2648,11 @@ class ConsoleServerPortView(generic.ObjectView):
     queryset = ConsoleServerPort.objects.all()
 
     def get_extra_context(self, request, instance):
-        return {"breadcrumb_url": "dcim:device_consoleserverports", **super().get_extra_context(request, instance)}
+        return {
+            "device_breadcrumb_url": "dcim:device_consoleserverports",
+            "module_breadcrumb_url": "dcim:module_consoleserverports",
+            **super().get_extra_context(request, instance),
+        }
 
 
 class ConsoleServerPortCreateView(generic.ComponentCreateView):
@@ -1767,7 +2714,11 @@ class PowerPortView(generic.ObjectView):
     queryset = PowerPort.objects.all()
 
     def get_extra_context(self, request, instance):
-        return {"breadcrumb_url": "dcim:device_powerports", **super().get_extra_context(request, instance)}
+        return {
+            "device_breadcrumb_url": "dcim:device_powerports",
+            "module_breadcrumb_url": "dcim:module_powerports",
+            **super().get_extra_context(request, instance),
+        }
 
 
 class PowerPortCreateView(generic.ComponentCreateView):
@@ -1829,7 +2780,11 @@ class PowerOutletView(generic.ObjectView):
     queryset = PowerOutlet.objects.all()
 
     def get_extra_context(self, request, instance):
-        return {"breadcrumb_url": "dcim:device_poweroutlets", **super().get_extra_context(request, instance)}
+        return {
+            "device_breadcrumb_url": "dcim:device_poweroutlets",
+            "module_breadcrumb_url": "dcim:module_poweroutlets",
+            **super().get_extra_context(request, instance),
+        }
 
 
 class PowerOutletCreateView(generic.ComponentCreateView):
@@ -1922,7 +2877,8 @@ class InterfaceView(generic.ObjectView):
         return {
             "ipaddress_table": ipaddress_table,
             "vlan_table": vlan_table,
-            "breadcrumb_url": "dcim:device_interfaces",
+            "device_breadcrumb_url": "dcim:device_interfaces",
+            "module_breadcrumb_url": "dcim:module_interfaces",
             "child_interfaces_table": child_interfaces_tables,
             "redundancy_table": redundancy_table,
             **super().get_extra_context(request, instance),
@@ -2012,7 +2968,11 @@ class FrontPortView(generic.ObjectView):
     queryset = FrontPort.objects.all()
 
     def get_extra_context(self, request, instance):
-        return {"breadcrumb_url": "dcim:device_frontports", **super().get_extra_context(request, instance)}
+        return {
+            "device_breadcrumb_url": "dcim:device_frontports",
+            "module_breadcrumb_url": "dcim:module_frontports",
+            **super().get_extra_context(request, instance),
+        }
 
 
 class FrontPortCreateView(generic.ComponentCreateView):
@@ -2074,7 +3034,11 @@ class RearPortView(generic.ObjectView):
     queryset = RearPort.objects.all()
 
     def get_extra_context(self, request, instance):
-        return {"breadcrumb_url": "dcim:device_rearports", **super().get_extra_context(request, instance)}
+        return {
+            "device_breadcrumb_url": "dcim:device_rearports",
+            "module_breadcrumb_url": "dcim:module_rearports",
+            **super().get_extra_context(request, instance),
+        }
 
 
 class RearPortCreateView(generic.ComponentCreateView):
@@ -2136,7 +3100,7 @@ class DeviceBayView(generic.ObjectView):
     queryset = DeviceBay.objects.all()
 
     def get_extra_context(self, request, instance):
-        return {"breadcrumb_url": "dcim:device_devicebays", **super().get_extra_context(request, instance)}
+        return {"device_breadcrumb_url": "dcim:device_devicebays", **super().get_extra_context(request, instance)}
 
 
 class DeviceBayCreateView(generic.ComponentCreateView):
@@ -2262,6 +3226,43 @@ class DeviceBayBulkDeleteView(generic.BulkDeleteView):
     table = tables.DeviceBayTable
 
 
+#
+# Module bays
+#
+
+
+class ModuleBayUIViewSet(ModuleBayCommonViewSetMixin, NautobotUIViewSet):
+    queryset = ModuleBay.objects.all()
+    filterset_class = filters.ModuleBayFilterSet
+    filterset_form_class = forms.ModuleBayFilterForm
+    bulk_update_form_class = forms.ModuleBayBulkEditForm
+    create_form_class = forms.ModuleBayCreateForm
+    form_class = forms.ModuleBayForm
+    model_form_class = forms.ModuleBayForm
+    serializer_class = serializers.ModuleBaySerializer
+    table_class = tables.ModuleBayTable
+    create_template_name = "dcim/device_component_add.html"
+
+    def get_extra_context(self, request, instance):
+        if instance:
+            return {
+                "device_breadcrumb_url": "dcim:device_modulebays",
+                "module_breadcrumb_url": "dcim:module_modulebays",
+            }
+        return {}
+
+    def get_selected_objects_parents_name(self, selected_objects):
+        selected_object = selected_objects.first()
+        if selected_object:
+            parent = selected_object.parent_device or selected_object.parent_module
+            return parent.display
+        return ""
+
+    @action(detail=False, methods=["GET", "POST"], url_path="rename", url_name="bulk_rename")
+    def bulk_rename(self, request, *args, **kwargs):
+        return self._bulk_rename(request, *args, **kwargs)
+
+
 #
 # Inventory items
 #
@@ -2286,7 +3287,7 @@ class InventoryItemView(generic.ObjectView):
             software_version_images = []
 
         return {
-            "breadcrumb_url": "dcim:device_inventory",
+            "device_breadcrumb_url": "dcim:device_inventory",
             "software_version_images": software_version_images,
             **super().get_extra_context(request, instance),
         }
@@ -2425,6 +3426,17 @@ class DeviceBulkAddDeviceBayView(generic.BulkComponentCreateView):
     default_return_url = "dcim:device_list"
 
 
+class DeviceBulkAddModuleBayView(generic.BulkComponentCreateView):
+    parent_model = Device
+    parent_field = "parent_device"
+    form = forms.ModuleBayBulkCreateForm
+    queryset = ModuleBay.objects.all()
+    model_form = forms.ModuleBayForm
+    filterset = filters.DeviceFilterSet
+    table = tables.DeviceTable
+    default_return_url = "dcim:device_list"
+
+
 class DeviceBulkAddInventoryItemView(generic.BulkComponentCreateView):
     parent_model = Device
     parent_field = "device"
@@ -2695,7 +3707,7 @@ class InterfaceConnectionsListView(ConnectionsListView):
 
 
 class VirtualChassisListView(generic.ObjectListView):
-    queryset = VirtualChassis.objects.annotate(member_count=count_related(Device, "virtual_chassis"))
+    queryset = VirtualChassis.objects.all()
     table = tables.VirtualChassisTable
     filterset = filters.VirtualChassisFilterSet
     filterset_form = forms.VirtualChassisFilterForm
@@ -2931,7 +3943,7 @@ class VirtualChassisBulkDeleteView(generic.BulkDeleteView):
 
 
 class PowerPanelListView(generic.ObjectListView):
-    queryset = PowerPanel.objects.annotate(power_feed_count=count_related(PowerFeed, "power_panel"))
+    queryset = PowerPanel.objects.all()
     filterset = filters.PowerPanelFilterSet
     filterset_form = forms.PowerPanelFilterForm
     table = tables.PowerPanelTable
@@ -2971,9 +3983,7 @@ class PowerPanelBulkEditView(generic.BulkEditView):
 
 
 class PowerPanelBulkDeleteView(generic.BulkDeleteView):
-    queryset = PowerPanel.objects.select_related("location", "rack_group").annotate(
-        power_feed_count=count_related(PowerFeed, "power_panel")
-    )
+    queryset = PowerPanel.objects.all()
     filterset = filters.PowerPanelFilterSet
     table = tables.PowerPanelTable
 
@@ -3027,14 +4037,7 @@ class DeviceRedundancyGroupUIViewSet(NautobotUIViewSet):
     filterset_class = filters.DeviceRedundancyGroupFilterSet
     filterset_form_class = forms.DeviceRedundancyGroupFilterForm
     form_class = forms.DeviceRedundancyGroupForm
-    queryset = (
-        DeviceRedundancyGroup.objects.select_related("status")
-        .prefetch_related("controllers", "devices")
-        .annotate(
-            device_count=count_related(Device, "device_redundancy_group"),
-            controller_count=count_related(Controller, "controller_device_redundancy_group"),
-        )
-    )
+    queryset = DeviceRedundancyGroup.objects.all()
     serializer_class = serializers.DeviceRedundancyGroupSerializer
     table_class = tables.DeviceRedundancyGroupTable
 
@@ -3046,9 +4049,6 @@ class DeviceRedundancyGroupUIViewSet(NautobotUIViewSet):
             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
 
 
@@ -3059,11 +4059,7 @@ class InterfaceRedundancyGroupUIViewSet(NautobotUIViewSet):
     filterset_class = filters.InterfaceRedundancyGroupFilterSet
     filterset_form_class = forms.InterfaceRedundancyGroupFilterForm
     form_class = forms.InterfaceRedundancyGroupForm
-    queryset = InterfaceRedundancyGroup.objects.select_related("status")
-    queryset = queryset.prefetch_related("interfaces")
-    queryset = queryset.annotate(
-        interface_count=count_related(Interface, "interface_redundancy_groups"),
-    )
+    queryset = InterfaceRedundancyGroup.objects.all()
     serializer_class = serializers.InterfaceRedundancyGroupSerializer
     table_class = tables.InterfaceRedundancyGroupTable
     lookup_field = "pk"
@@ -3114,7 +4110,7 @@ class DeviceFamilyUIViewSet(NautobotUIViewSet):
     filterset_form_class = forms.DeviceFamilyFilterForm
     form_class = forms.DeviceFamilyForm
     bulk_update_form_class = forms.DeviceFamilyBulkEditForm
-    queryset = DeviceFamily.objects.annotate(device_type_count=count_related(DeviceType, "device_family"))
+    queryset = DeviceFamily.objects.all()
     serializer_class = serializers.DeviceFamilySerializer
     table_class = tables.DeviceFamilyTable
     lookup_field = "pk"
@@ -3157,8 +4153,7 @@ class SoftwareImageFileUIViewSet(NautobotUIViewSet):
     filterset_form_class = forms.SoftwareImageFileFilterForm
     form_class = forms.SoftwareImageFileForm
     bulk_update_form_class = forms.SoftwareImageFileBulkEditForm
-    queryset = SoftwareImageFile.objects.annotate(device_type_count=count_related(DeviceType, "software_image_files"))
-
+    queryset = SoftwareImageFile.objects.all()
     serializer_class = serializers.SoftwareImageFileSerializer
     table_class = tables.SoftwareImageFileTable
 
@@ -3168,11 +4163,7 @@ class SoftwareVersionUIViewSet(NautobotUIViewSet):
     filterset_form_class = forms.SoftwareVersionFilterForm
     form_class = forms.SoftwareVersionForm
     bulk_update_form_class = forms.SoftwareVersionBulkEditForm
-    queryset = SoftwareVersion.objects.annotate(
-        software_image_file_count=count_related(SoftwareImageFile, "software_version"),
-        device_count=count_related(Device, "software_version"),
-        inventory_item_count=count_related(InventoryItem, "software_version"),
-    )
+    queryset = SoftwareVersion.objects.all()
     serializer_class = serializers.SoftwareVersionSerializer
     table_class = tables.SoftwareVersionTable
 
@@ -3215,11 +4206,7 @@ class ControllerManagedDeviceGroupUIViewSet(NautobotUIViewSet):
     filterset_form_class = forms.ControllerManagedDeviceGroupFilterForm
     form_class = forms.ControllerManagedDeviceGroupForm
     bulk_update_form_class = forms.ControllerManagedDeviceGroupBulkEditForm
-    queryset = (
-        ControllerManagedDeviceGroup.objects.all()
-        .prefetch_related("devices")
-        .annotate(device_count=count_related(Device, "controller_managed_device_group"))
-    )
+    queryset = ControllerManagedDeviceGroup.objects.all()
     serializer_class = serializers.ControllerManagedDeviceGroupSerializer
     table_class = tables.ControllerManagedDeviceGroupTable
     template_name = "dcim/controllermanageddevicegroup_create.html"