commonground-api-common 1.13.0__py3-none-any.whl → 2.4.1__py3-none-any.whl

vng_api_common/contrib/setup_configuration/models.py

@@ -0,0 +1,32 @@
+from django_setup_configuration.models import ConfigurationModel
+from pydantic import Field
+
+from vng_api_common.authorizations.models import Applicatie
+from vng_api_common.models import JWTSecret
+
+
+class SingleJWTSecretConfigurationModel(ConfigurationModel):
+    class Meta:
+        django_model_refs = {
+            JWTSecret: [
+                "identifier",
+                "secret",
+            ]
+        }
+
+
+class JWTSecretsConfigurationModel(ConfigurationModel):
+    items: list[SingleJWTSecretConfigurationModel] = Field(default_factory=list)
+
+
+class SingleApplicatieConfigurationModel(ConfigurationModel):
+    client_ids: list[str]
+
+    class Meta:
+        django_model_refs = {
+            Applicatie: ["uuid", "client_ids", "label", "heeft_alle_autorisaties"]
+        }
+
+
+class ApplicatieConfigurationModel(ConfigurationModel):
+    items: list[SingleApplicatieConfigurationModel] = Field(default_factory=list)

vng_api_common/contrib/setup_configuration/steps.py

@@ -0,0 +1,46 @@
+from django_setup_configuration.configuration import BaseConfigurationStep
+
+from vng_api_common.authorizations.models import Applicatie
+from vng_api_common.models import JWTSecret
+
+from .models import ApplicatieConfigurationModel, JWTSecretsConfigurationModel
+
+
+class JWTSecretsConfigurationStep(BaseConfigurationStep[JWTSecretsConfigurationModel]):
+    """
+    Configure credentials for Applications that need access
+    """
+
+    verbose_name = "Configuration to create credentials"
+    config_model = JWTSecretsConfigurationModel
+    namespace = "vng_api_common_credentials"
+    enable_setting = "vng_api_common_credentials_config_enable"
+
+    def execute(self, model: JWTSecretsConfigurationModel):
+        for config in model.items:
+            JWTSecret.objects.update_or_create(
+                identifier=config.identifier,
+                defaults={"secret": config.secret},
+            )
+
+
+class ApplicatieConfigurationStep(BaseConfigurationStep[ApplicatieConfigurationModel]):
+    """
+    Configure Applicatie used for authorization
+    """
+
+    verbose_name = "Configuration to create applicaties"
+    config_model = ApplicatieConfigurationModel
+    namespace = "vng_api_common_applicaties"
+    enable_setting = "vng_api_common_applicaties_config_enable"
+
+    def execute(self, model: ApplicatieConfigurationModel):
+        for config in model.items:
+            Applicatie.objects.update_or_create(
+                uuid=config.uuid,
+                defaults={
+                    "client_ids": config.client_ids,
+                    "label": config.label,
+                    "heeft_alle_autorisaties": config.heeft_alle_autorisaties,
+                },
+            )

vng_api_common/extensions/file.py

@@ -0,0 +1,26 @@
+from django.utils.translation import gettext_lazy as _
+
+from drf_spectacular.extensions import OpenApiSerializerFieldExtension
+from drf_spectacular.openapi import OpenApiTypes
+from drf_spectacular.plumbing import build_basic_type
+
+
+class Base64FileFileFieldExtension(OpenApiSerializerFieldExtension):
+    target_class = "drf_extra_fields.fields.Base64FileField"
+    match_subclasses = True
+
+    def map_serializer_field(self, auto_schema, direction):
+        base64_schema = {
+            **build_basic_type(OpenApiTypes.BYTE),
+            "description": _("Base64 encoded binary content."),
+        }
+
+        uri_schema = {
+            **build_basic_type(OpenApiTypes.URI),
+            "description": _("Download URL of the binary content."),
+        }
+
+        if direction == "request":
+            return base64_schema
+        elif direction == "response":
+            return uri_schema if not self.target.represent_in_base64 else base64_schema

vng_api_common/extensions/gegevensgroep.py

@@ -0,0 +1,16 @@
+from drf_spectacular.extensions import OpenApiSerializerExtension
+from drf_spectacular.openapi import AutoSchema
+
+
+class GegevensGroepFieldExtension(OpenApiSerializerExtension):
+    target_class = "vng_api_common.serializers.GegevensGroepSerializer"
+    match_subclasses = True
+
+    def map_serializer(self, auto_schema: AutoSchema, direction):
+        schema = auto_schema._map_serializer(
+            self.target, direction, bypass_extensions=True
+        )
+
+        del schema["description"]
+
+        return schema

vng_api_common/extensions/geojson.py

@@ -0,0 +1,270 @@
+from drf_spectacular.extensions import OpenApiSerializerFieldExtension
+from drf_spectacular.plumbing import ResolvedComponent
+
+
+class GeometryFieldExtension(OpenApiSerializerFieldExtension):
+    target_class = "rest_framework_gis.fields.GeometryField"
+    match_subclasses = True
+    priority = 1
+
+    def get_name(self):
+        return "GeoJSONGeometry"
+
+    def map_serializer_field(self, auto_schema, direction):
+        geometry = ResolvedComponent(
+            name="Geometry",
+            type=ResolvedComponent.SCHEMA,
+            object="Geometry",
+            schema={
+                "type": "object",
+                "title": "Geometry",
+                "description": "GeoJSON geometry",
+                "required": ["type"],
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1"
+                },
+                "properties": {
+                    "type": {
+                        "type": "string",
+                        "enum": [
+                            "Point",
+                            "MultiPoint",
+                            "LineString",
+                            "MultiLineString",
+                            "Polygon",
+                            "MultiPolygon",
+                            "Feature",
+                            "FeatureCollection",
+                            "GeometryCollection",
+                        ],
+                        "description": "The geometry type",
+                    }
+                },
+            },
+        )
+        point_2d = ResolvedComponent(
+            name="Point2D",
+            type=ResolvedComponent.SCHEMA,
+            object="Point2D",
+            schema={
+                "type": "array",
+                "title": "Point2D",
+                "description": "A 2D point",
+                "items": {"type": "number"},
+                "maxItems": 2,
+                "minItems": 2,
+            },
+        )
+        point = ResolvedComponent(
+            name="Point",
+            type=ResolvedComponent.SCHEMA,
+            object="Point",
+            schema={
+                "type": "object",
+                "description": "GeoJSON point geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.2"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {"coordinates": point_2d.ref},
+                    },
+                ],
+            },
+        )
+
+        multi_point = ResolvedComponent(
+            name="MultiPoint",
+            type=ResolvedComponent.SCHEMA,
+            object="MultiPoint",
+            schema={
+                "type": "object",
+                "description": "GeoJSON multi-point geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.3"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {"type": "array", "items": point_2d.ref}
+                        },
+                    },
+                ],
+            },
+        )
+
+        line_string = ResolvedComponent(
+            name="LineString",
+            type=ResolvedComponent.SCHEMA,
+            object="LineString",
+            schema={
+                "type": "object",
+                "description": "GeoJSON line-string geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.4"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {
+                                "type": "array",
+                                "items": point_2d.ref,
+                                "minItems": 2,
+                            }
+                        },
+                    },
+                ],
+            },
+        )
+
+        multi_line_string = ResolvedComponent(
+            name="MultiLineString",
+            type=ResolvedComponent.SCHEMA,
+            object="MultiLineString",
+            schema={
+                "type": "object",
+                "description": "GeoJSON multi-line-string geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.5"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {
+                                "type": "array",
+                                "items": {
+                                    "type": "array",
+                                    "items": point_2d.ref,
+                                },
+                            }
+                        },
+                    },
+                ],
+            },
+        )
+
+        polygon = ResolvedComponent(
+            name="Polygon",
+            type=ResolvedComponent.SCHEMA,
+            object="Polygon",
+            schema={
+                "type": "object",
+                "description": "GeoJSON polygon geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.6"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {
+                                "type": "array",
+                                "items": {
+                                    "type": "array",
+                                    "items": point_2d.ref,
+                                },
+                            }
+                        },
+                    },
+                ],
+            },
+        )
+
+        multi_polygon = ResolvedComponent(
+            name="MultiPolygon",
+            type=ResolvedComponent.SCHEMA,
+            object="MultiPolygon",
+            schema={
+                "type": "object",
+                "description": "GeoJSON multi-polygon geometry",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.7"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["coordinates"],
+                        "properties": {
+                            "coordinates": {
+                                "type": "array",
+                                "items": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "array",
+                                        "items": point_2d.ref,
+                                    },
+                                },
+                            }
+                        },
+                    },
+                ],
+            },
+        )
+
+        geometry_collection = ResolvedComponent(
+            name="GeometryCollection",
+            type=ResolvedComponent.SCHEMA,
+            object="GeometryCollection",
+            schema={
+                "type": "object",
+                "description": "GeoJSON geometry collection",
+                "externalDocs": {
+                    "url": "https://tools.ietf.org/html/rfc7946#section-3.1.8"
+                },
+                "allOf": [
+                    geometry.ref,
+                    {
+                        "type": "object",
+                        "required": ["geometries"],
+                        "properties": {
+                            "geometries": {"type": "array", "items": geometry.ref}
+                        },
+                    },
+                ],
+            },
+        )
+
+        for component in [
+            geometry,
+            point_2d,
+            point,
+            multi_point,
+            line_string,
+            multi_line_string,
+            polygon,
+            multi_polygon,
+            geometry_collection,
+        ]:
+            auto_schema.registry.register_on_missing(component)
+
+        return {
+            "title": "GeoJSONGeometry",
+            "type": "object",
+            "oneOf": [
+                point.ref,
+                multi_point.ref,
+                line_string.ref,
+                multi_line_string.ref,
+                polygon.ref,
+                multi_polygon.ref,
+                geometry_collection.ref,
+            ],
+            "discriminator": {
+                "propertyName": "type",
+            },
+        }

vng_api_common/extensions/hyperlink.py

@@ -0,0 +1,37 @@
+from django.utils.translation import gettext_lazy as _
+
+from drf_spectacular.extensions import OpenApiSerializerFieldExtension
+from drf_spectacular.openapi import AutoSchema
+
+
+class HyperlinkedRelatedFieldExtension(OpenApiSerializerFieldExtension):
+    target_class = "vng_api_common.serializers.LengthHyperlinkedRelatedField"
+    match_subclasses = True
+
+    def map_serializer_field(self, auto_schema: AutoSchema, direction):
+        default_schema = auto_schema._map_serializer_field(
+            self.target, direction, bypass_extensions=True
+        )
+        return {
+            **default_schema,
+            "minLength": self.target.min_length,
+            "maxLength": self.target.max_length,
+        }
+
+
+class HyperlinkedIdentityFieldExtension(OpenApiSerializerFieldExtension):
+    target_class = "rest_framework.serializers.HyperlinkedIdentityField"
+    match_subclasses = True
+
+    def map_serializer_field(self, auto_schema: AutoSchema, direction):
+        default_schema = auto_schema._map_serializer_field(
+            self.target, direction, bypass_extensions=True
+        )
+        return {
+            **default_schema,
+            "minLength": 1,
+            "maxLength": 1000,
+            "description": _(
+                "URL-referentie naar dit object. Dit is de unieke identificatie en locatie van dit object."
+            ),
+        }

vng_api_common/extensions/polymorphic.py

@@ -0,0 +1,68 @@
+from drf_spectacular.extensions import OpenApiSerializerExtension
+from drf_spectacular.plumbing import ResolvedComponent
+from drf_spectacular.settings import spectacular_settings
+
+from ..utils import underscore_to_camel
+
+
+class PolymorphicSerializerExtension(OpenApiSerializerExtension):
+    target_class = "vng_api_common.polymorphism.PolymorphicSerializer"
+    match_subclasses = True
+
+    def map_serializer(self, auto_schema, direction):
+        if not getattr(self.target, "discriminator", None):
+            raise AttributeError(
+                "'PolymorphicSerializer' derived serializers need to have 'discriminator' set"
+            )
+
+        discriminator = self.target.discriminator
+
+        # resolve component with base path
+        base_schema = auto_schema._map_serializer(
+            self.target, direction, bypass_extensions=True
+        )
+        base_name = f"Base_{self.target.__class__.__name__}"
+        if direction == "request" and spectacular_settings.COMPONENT_SPLIT_REQUEST:
+            base_name = base_name + "Request"
+        base_component = ResolvedComponent(
+            name=base_name,
+            type=ResolvedComponent.SCHEMA,
+            object=base_name,
+            schema=base_schema,
+        )
+        auto_schema.registry.register_on_missing(base_component)
+
+        components = {}
+        # resolve sub components and components
+        for resource_type, sub_serializer in discriminator.mapping.items():
+            if not sub_serializer or not sub_serializer.fields:
+                schema = {"allOf": [base_component.ref]}
+            else:
+                sub_component = auto_schema.resolve_serializer(
+                    sub_serializer, direction
+                )
+                schema = {"allOf": [base_component.ref, sub_component.ref]}
+
+            component_name = f"{resource_type.value}_{self.target.__class__.__name__}"
+            if direction == "request" and spectacular_settings.COMPONENT_SPLIT_REQUEST:
+                component_name = component_name + "Request"
+            component = ResolvedComponent(
+                name=component_name,
+                type=ResolvedComponent.SCHEMA,
+                object=component_name,
+                schema=schema,
+            )
+            auto_schema.registry.register_on_missing(component)
+
+            components[resource_type.value] = component
+
+        return {
+            "oneOf": [component.ref for _, component in components.items()],
+            "discriminator": {
+                "propertyName": underscore_to_camel(discriminator.discriminator_field),
+                "mapping": {
+                    resource: component.ref["$ref"]
+                    for resource, component in components.items()
+                },
+            },
+        }

vng_api_common/extensions/query.py

@@ -0,0 +1,20 @@
+from drf_spectacular.contrib.django_filters import DjangoFilterExtension
+
+from vng_api_common.utils import underscore_to_camel
+
+
+class CamelizeFilterExtension(DjangoFilterExtension):
+    priority = 1
+
+    def get_schema_operation_parameters(self, auto_schema, *args, **kwargs):
+        """
+        camelize query parameters
+        """
+        parameters = super().get_schema_operation_parameters(
+            auto_schema, *args, **kwargs
+        )
+
+        for parameter in parameters:
+            parameter["name"] = underscore_to_camel(parameter["name"])
+
+        return parameters

vng_api_common/filters.py

@@ -26,7 +26,6 @@ logger = logging.getLogger(__name__)
 
 
 class Backend(DjangoFilterBackend):
-    # Taken from drf_yasg.inspectors.field.CamelCaseJSONFilter
     def _is_camel_case(self, view):
         return any(
             issubclass(parser, CamelCaseJSONParser) for parser in view.parser_classes

vng_api_common/generators.py

@@ -1,16 +1,7 @@
-from collections import OrderedDict
-from typing import List
-
-from drf_yasg import openapi
-from drf_yasg.generators import (
+from drf_spectacular.generators import (
     EndpointEnumerator as _EndpointEnumerator,
-    OpenAPISchemaGenerator as _OpenAPISchemaGenerator,
+    SchemaGenerator as _OpenAPISchemaGenerator,
 )
-from drf_yasg.utils import get_consumes, get_produces
-from rest_framework.schemas.utils import is_list_view
-from rest_framework.settings import api_settings
-
-from vng_api_common.utils import get_view_summary
 
 
 class EndpointEnumerator(_EndpointEnumerator):
@@ -29,110 +20,18 @@ class EndpointEnumerator(_EndpointEnumerator):
 
 
 class OpenAPISchemaGenerator(_OpenAPISchemaGenerator):
-    endpoint_enumerator_class = EndpointEnumerator
-
-    def get_tags(self, request=None, public=False):
-        """Retrieve the tags for the root schema.
-
-        :param request: the request used for filtering accessible endpoints and finding the spec URI
-        :param bool public: if True, all endpoints are included regardless of access through `request`
-
-        :return: List of tags containing the tag name and a description.
-        """
-        tags = {}
+    endpoint_inspector_cls = EndpointEnumerator
 
-        endpoints = self.get_endpoints(request)
-        for path, (view_cls, methods) in sorted(endpoints.items()):
-            if "{" in path:
-                continue
-
-            tag = path.rsplit("/", 1)[-1]
-            if tag in tags:
-                continue
-
-            # exclude special non-rest actions
-            if tag.startswith("_"):
-                continue
-            tags[tag] = get_view_summary(view_cls)
-
-        return [
-            OrderedDict([("name", operation), ("description", desc)])
-            for operation, desc in sorted(tags.items())
-        ]
-
-    def get_schema(self, request=None, public=False):
-        """
-        Rewrite parent class to add 'responses' in components
+    def create_view(self, callback, method, request=None):
         """
-        endpoints = self.get_endpoints(request)
-        components = self.reference_resolver_class(
-            openapi.SCHEMA_DEFINITIONS, "responses", force_init=True
-        )
-        self.consumes = get_consumes(api_settings.DEFAULT_PARSER_CLASSES)
-        self.produces = get_produces(api_settings.DEFAULT_RENDERER_CLASSES)
-        paths, prefix = self.get_paths(endpoints, components, request, public)
-
-        security_definitions = self.get_security_definitions()
-        if security_definitions:
-            security_requirements = self.get_security_requirements(security_definitions)
-        else:
-            security_requirements = None
-
-        url = self.url
-        if url is None and request is not None:
-            url = request.build_absolute_uri()
-
-        return openapi.Swagger(
-            info=self.info,
-            paths=paths,
-            consumes=self.consumes or None,
-            produces=self.produces or None,
-            tags=self.get_tags(request, public),
-            security_definitions=security_definitions,
-            security=security_requirements,
-            _url=url,
-            _prefix=prefix,
-            _version=self.version,
-            **dict(components),
-        )
-
-    def get_path_parameters(self, path, view_cls):
-        """Return a list of Parameter instances corresponding to any templated path variables.
-
-        :param str path: templated request path
-        :param type view_cls: the view class associated with the path
-        :return: path parameters
-        :rtype: list[openapi.Parameter]
+        workaround for HEAD method which doesn't have action
         """
-        parameters = super().get_path_parameters(path, view_cls)
-
-        # see if we can specify UUID a bit more
-        for parameter in parameters:
-            # the most pragmatic of checks
-            if not parameter.name.endswith("_uuid"):
-                continue
-            parameter.format = openapi.FORMAT_UUID
-            parameter.description = "Unieke resource identifier (UUID4)"
-        return parameters
-
-    def get_operation_keys(self, subpath, method, view) -> List[str]:
-        if method != "HEAD":
-            return super().get_operation_keys(subpath, method, view)
-
-        assert not is_list_view(
-            subpath, method, view
-        ), "HEAD requests are only supported on detail endpoints"
-
-        # taken from DRF schema generation
-        named_path_components = [
-            component
-            for component in subpath.strip("/").split("/")
-            if "{" not in component
-        ]
+        if method == "HEAD":
+            view = super(_OpenAPISchemaGenerator, self).create_view(
+                callback, method, request=request
+            )
+            return view
 
-        return named_path_components + ["headers"]
+        return super().create_view(callback, method, request=request)
 
-    def get_overrides(self, view, method) -> dict:
-        if method == "HEAD":
-            return {}
-        return super().get_overrides(view, method)
+    # todo support registering and reusing Response components