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

nautobot/core/api/urls.py

@@ -11,11 +11,10 @@ from nautobot.core.api.views import (
     CSVImportFieldsForContentTypeAPIView,
     GetFilterSetFieldDOMElementAPIView,
     GetFilterSetFieldLookupExpressionChoicesAPIView,
-    GetMenuAPIView,
-    GetObjectCountsView,
     GraphQLDRFAPIView,
     NautobotSpectacularRedocView,
     NautobotSpectacularSwaggerView,
+    RenderJinjaView,
     SettingsJSONSchemaView,
     StatusView,
 )
@@ -33,12 +32,11 @@ core_api_patterns = [
         GetFilterSetFieldDOMElementAPIView.as_view(),
         name="filtersetfield-retrieve-lookupvaluedomelement",
     ),
+    path("render-jinja-template/", RenderJinjaView.as_view(), name="render_jinja_template"),
 ]
 ui_api_patterns = [
     # Lookup Expr
     path("core/", include((core_api_patterns, "core-api"))),
-    path("get-menu/", GetMenuAPIView.as_view(), name="get-menu"),
-    path("get-object-counts/", GetObjectCountsView.as_view(), name="get-object-counts"),
 ]
 
 urlpatterns = [
@@ -52,6 +50,7 @@ urlpatterns = [
     path("tenancy/", include("nautobot.tenancy.api.urls")),
     path("users/", include("nautobot.users.api.urls")),
     path("virtualization/", include("nautobot.virtualization.api.urls")),
+    path("wireless/", include("nautobot.wireless.api.urls")),
     path("status/", StatusView.as_view(), name="api-status"),
     path("docs/", NautobotSpectacularSwaggerView.as_view(url_name="schema"), name="api_docs"),
     path("redoc/", NautobotSpectacularRedocView.as_view(url_name="schema"), name="api_redocs"),

nautobot/core/api/utils.py

@@ -221,68 +221,6 @@ def rest_api_server_error(request, *args, **kwargs):
     return JsonResponse(data, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
 
-# TODO: This is part of the drf-react-template work towards auto-generating create/edit form UI from the REST API.
-def format_output(field, field_value):
-    """TODO: docstring required."""
-    data = {
-        "field_name": field,  # Form field placeholder
-        "type": "others",  # Param type e.g select field, char field, datetime field etc.
-        "choices": [],  # Param choices for select fields
-        "help_text": None,  # Form field placeholder
-        "label": None,  # Form field placeholder
-        "required": False,  # Form field placeholder
-    }
-    # TODO: fix these local imports if at all possible
-    from rest_framework.fields import CharField, IntegerField
-    from rest_framework.serializers import ListSerializer
-
-    from nautobot.core.api import ChoiceField, WritableNestedSerializer
-
-    kwargs = {}
-    if isinstance(field_value, (WritableNestedSerializer, ListSerializer)):
-        kwargs = {
-            "type": "dynamic-choice-field",
-        }
-        extra_kwargs = {}
-
-        if isinstance(field_value, WritableNestedSerializer):
-            extra_kwargs = {
-                "label": getattr(field_value, "label", None) or field,
-                "required": field_value.required,
-                "help_text": field_value.help_text,
-            }
-        elif isinstance(field_value, ListSerializer):
-            extra_kwargs = {
-                "label": "Tags",
-                "required": False,
-            }
-        kwargs.update(extra_kwargs)
-    elif isinstance(field_value, ChoiceField):
-        kwargs = {
-            "type": "choice-field",
-            "label": getattr(field_value, "label", None) or field,
-            "required": field_value.required,
-            "help_text": field_value.help_text,
-            "choices": field_value.choices.items(),
-        }
-    elif isinstance(field_value, CharField):
-        kwargs = {
-            "type": "char-field",
-            "label": getattr(field_value, "label", None) or field,
-            "required": field_value.required,
-            "help_text": field_value.help_text,
-        }
-    elif isinstance(field_value, IntegerField):
-        kwargs = {
-            "type": "integer-field",
-            "label": getattr(field_value, "label", None) or field,
-            "required": field_value.required,
-            "help_text": field_value.help_text,
-        }
-    data.update(kwargs)
-    return data
-
-
 def get_relation_info_for_nested_serializers(model_class, related_model, field_name):
     """Get the DRF RelationInfo object needed for build_nested_field()"""
     relation_info = RelationInfo(

nautobot/core/api/views.py

@@ -1,5 +1,4 @@
 from collections import OrderedDict
-import itertools
 import logging
 import os
 import platform
@@ -13,7 +12,6 @@ from django.db import transaction
 from django.db.models import ProtectedError
 from django.http.response import HttpResponseBadRequest
 from django.shortcuts import get_object_or_404, redirect
-from django.urls import NoReverseMatch, reverse as django_reverse
 from drf_spectacular.plumbing import get_relative_url, set_query_parameters
 from drf_spectacular.renderers import OpenApiJsonRenderer
 from drf_spectacular.utils import extend_schema
@@ -26,7 +24,8 @@ from graphql.execution.middleware import MiddlewareManager
 from graphql.type.schema import GraphQLSchema
 import redis.exceptions
 from rest_framework import routers, status
-from rest_framework.exceptions import ParseError, PermissionDenied
+from rest_framework.exceptions import APIException, ParseError, PermissionDenied
+from rest_framework.generics import GenericAPIView
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 from rest_framework.reverse import reverse
@@ -39,13 +38,11 @@ from nautobot.core.api.exceptions import SerializerNotFound
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.celery import app as celery_app
 from nautobot.core.exceptions import FilterSetFieldNotFound
-from nautobot.core.utils.data import is_uuid
+from nautobot.core.utils.data import is_uuid, render_jinja2
 from nautobot.core.utils.filtering import get_all_lookup_expr_for_field, get_filterset_parameter_form_field
-from nautobot.core.utils.lookup import get_form_for_model, get_route_for_model
-from nautobot.core.utils.permissions import get_permission_for_model
+from nautobot.core.utils.lookup import get_form_for_model
 from nautobot.core.utils.requests import ensure_content_type_and_field_name_in_query_params
 from nautobot.core.views.utils import get_csv_form_fields_from_serializer_class
-from nautobot.extras.registry import registry
 
 from . import serializers
 
@@ -373,7 +370,7 @@ class APIRootView(AuthenticatedAPIRootView):
     name = "API Root"
 
     @extend_schema(exclude=True)
-    def get(self, request, *args, format=None, **kwargs):  # pylint: disable=redefined-builtin
+    def get(self, request, format=None):  # pylint: disable=redefined-builtin
         return Response(
             OrderedDict(
                 (
@@ -423,6 +420,14 @@ class APIRootView(AuthenticatedAPIRootView):
                             format=format,
                         ),
                     ),
+                    (
+                        "wireless",
+                        reverse(
+                            "wireless-api:api-root",
+                            request=request,
+                            format=format,
+                        ),
+                    ),
                 )
             )
         )
@@ -572,13 +577,12 @@ class GraphQLDRFAPIView(NautobotAPIVersionMixin, APIView):
     middleware = None
     root_value = None
 
-    def __init__(self, schema=None, executor=None, middleware=None, root_value=None, backend=None, **kwargs):
+    def __init__(self, schema=None, executor=None, middleware=None, root_value=None, backend=None):
         self.schema = schema
         self.executor = executor
         self.middleware = middleware
         self.root_value = root_value
         self.backend = backend
-        super().__init__(**kwargs)
 
     def get_root_value(self, request):
         return self.root_value
@@ -752,154 +756,6 @@ class GraphQLDRFAPIView(NautobotAPIVersionMixin, APIView):
 #
 
 
-class GetMenuAPIView(NautobotAPIVersionMixin, APIView):
-    """API View that returns the nav-menu content applicable to the requesting user."""
-
-    permission_classes = [IsAuthenticated]
-
-    def format_and_remove_hidden_menu(self, request, data):
-        """
-        Formats the menu data and removes hidden menu items based on user permissions.
-
-        Args:
-            request (HttpRequest): The request object.
-            data (dict): The menu data to format and filter.
-
-        Returns:
-            (dict): The formatted menu data without hidden items.
-
-        Example:
-            Input:
-            {
-                "Devices": {
-                    "permission": [...],
-                    "weight": "",
-                    "data": "data value"
-                },
-            }
-
-            Output:
-            {"Devices": "data value"}
-        """
-        return_value = {}
-        for name, value in data.items():
-            if "permissions" in value:
-                permissions = value["permissions"]
-                user_has_permission = (
-                    any(request.user.has_perm(permission) for permission in permissions) or not permissions
-                )
-                if user_has_permission:
-                    return_value[name] = value["data"]
-            else:
-                return_data = self.format_and_remove_hidden_menu(request, value["data"])
-                if return_data:
-                    return_value[name] = return_data
-        return return_value
-
-    @extend_schema(exclude=True)
-    def get(self, request):
-        """Get the menu data for the requesting user.
-
-        Returns the following data-structure (as not all context in registry["nav_menu"] is relevant to the UI):
-
-        {
-            "Inventory": {
-                "Devices": {
-                    "Devices": "/dcim/devices/",
-                    "Device Types": "/dcim/device-types/",
-                    ...
-                    "Connections": {
-                        "Cables": "/dcim/cables/",
-                        "Console Connections": "/dcim/console-connections/",
-                        ...
-                    },
-                    ...
-                },
-                "Organization": {
-                    ...
-                },
-                ...
-            },
-            "Networks": {
-                ...
-            },
-            "Security": {
-                ...
-            },
-            "Automation": {
-                ...
-            },
-            "Platform": {
-                ...
-            },
-        }
-        """
-        base_menu = registry["new_ui_nav_menu"]
-        formatted_data = self.format_and_remove_hidden_menu(request, base_menu)
-        return Response(formatted_data)
-
-
-class GetObjectCountsView(NautobotAPIVersionMixin, APIView):
-    """
-    Enumerate the models listed on the Nautobot home page and return data structure
-    containing verbose_name_plural, url and count.
-    """
-
-    permission_classes = [IsAuthenticated]
-
-    @extend_schema(exclude=True)
-    def get(self, request):
-        object_counts = {
-            "Inventory": [
-                {"model": "dcim.rack"},
-                {"model": "dcim.devicetype"},
-                {"model": "dcim.device"},
-                {"model": "dcim.virtualchassis"},
-                {"model": "dcim.deviceredundancygroup"},
-                {"model": "dcim.cable"},
-            ],
-            "Networks": [
-                {"model": "ipam.vrf"},
-                {"model": "ipam.prefix"},
-                {"model": "ipam.ipaddress"},
-                {"model": "ipam.vlan"},
-            ],
-            "Security": [{"model": "extras.secret"}],
-            "Platform": [
-                {"model": "extras.gitrepository"},
-                {"model": "extras.relationship"},
-                {"model": "extras.computedfield"},
-                {"model": "extras.customfield"},
-                {"model": "extras.customlink"},
-                {"model": "extras.tag"},
-                {"model": "extras.status"},
-                {"model": "extras.role"},
-            ],
-        }
-
-        for entry in itertools.chain(*object_counts.values()):
-            app_label, model_name = entry["model"].split(".")
-            model = apps.get_model(app_label, model_name)
-            permission = get_permission_for_model(model, "view")
-            if not request.user.has_perm(permission):
-                continue
-            data = {"name": model._meta.verbose_name_plural}
-            try:
-                data["url"] = django_reverse(get_route_for_model(model, "list"))
-            except NoReverseMatch:
-                route = get_route_for_model(model, "list")
-                logger.warning(f"Handled expected exception when generating filter field: {route}")
-            manager = model.objects
-            if request.user.has_perm(permission):
-                if hasattr(manager, "restrict"):
-                    data["count"] = model.objects.restrict(request.user).count()
-                else:
-                    data["count"] = model.objects.count()
-            entry.update(data)
-
-        return Response(object_counts)
-
-
 class CSVImportFieldsForContentTypeAPIView(NautobotAPIVersionMixin, APIView):
     """Get information about CSV import fields for a given ContentType."""
 
@@ -1024,3 +880,37 @@ class SettingsJSONSchemaView(NautobotAPIVersionMixin, APIView):
         with open(file_path, "r") as yamlfile:
             schema_data = yaml.safe_load(yamlfile)
         return Response(schema_data)
+
+
+class RenderJinjaError(APIException):
+    status_code = status.HTTP_400_BAD_REQUEST
+    default_detail = "Failed to render Jinja template."
+    default_code = "render_jinja_error"
+
+
+class RenderJinjaView(NautobotAPIVersionMixin, GenericAPIView):
+    """
+    View to render a Jinja template.
+    """
+
+    name = "Render Jinja2 Template"
+    permission_classes = [IsAuthenticated]
+    serializer_class = serializers.RenderJinjaSerializer
+
+    def post(self, request, *args, **kwargs):
+        data = serializers.RenderJinjaSerializer(data=request.data)
+        data.is_valid(raise_exception=True)
+        template_code = data.validated_data["template_code"]
+        context = data.validated_data["context"]
+        try:
+            rendered_template = render_jinja2(template_code, context)
+        except Exception as exc:
+            raise RenderJinjaError(f"Failed to render Jinja template: {exc}") from exc
+        return Response(
+            {
+                "rendered_template": rendered_template,
+                "rendered_template_lines": rendered_template.split("\n"),
+                "template_code": template_code,
+                "context": context,
+            }
+        )