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

vng_api_common/conf/api.py

@@ -1,10 +1,9 @@
 __all__ = [
     "API_VERSION",
     "BASE_REST_FRAMEWORK",
-    "BASE_SWAGGER_SETTINGS",
+    "BASE_SPECTACULAR_SETTINGS",
     "COMMON_SPEC",
     "LINK_FETCHER",
-    "ZDS_CLIENT_CLASS",
     "GEMMA_URL_TEMPLATE",
     "GEMMA_URL_COMPONENTTYPE",
     "GEMMA_URL_INFORMATIEMODEL",
@@ -13,43 +12,30 @@ __all__ = [
     "NOTIFICATIONS_KANAAL",
     "NOTIFICATIONS_DISABLED",
     "JWT_LEEWAY",
+    "SECURITY_DEFINITION_NAME",
     "COMMONGROUND_API_COMMON_GET_DOMAIN",
+    "JWT_SPECTACULAR_SETTINGS",
 ]
 
 API_VERSION = "1.0.0-rc1"  # semantic version
 
+SECURITY_DEFINITION_NAME = "JWT-Claims"
+
 BASE_REST_FRAMEWORK = {
+    "DEFAULT_SCHEMA_CLASS": "vng_api_common.schema.AutoSchema",
     "DEFAULT_RENDERER_CLASSES": (
         "djangorestframework_camel_case.render.CamelCaseJSONRenderer",
     ),
     "DEFAULT_PARSER_CLASSES": (
         "djangorestframework_camel_case.parser.CamelCaseJSONParser",
     ),
-    "DEFAULT_AUTHENTICATION_CLASSES": (
-        # 'oauth2_provider.contrib.rest_framework.OAuth2Authentication',
-        # 'rest_framework.authentication.SessionAuthentication',
-        # 'rest_framework.authentication.BasicAuthentication'
-    ),
     # there is no authentication of 'end-users', only authorization (via JWT)
     # of applications
     "DEFAULT_AUTHENTICATION_CLASSES": (),
-    # 'DEFAULT_PERMISSION_CLASSES': (
-    #     'oauth2_provider.contrib.rest_framework.TokenHasReadWriteScope',
-    #     # 'rest_framework.permissions.IsAuthenticated',
-    #     # 'rest_framework.permissions.AllowAny',
-    # ),
     "DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.URLPathVersioning",
-    #
-    # # Generic view behavior
-    # 'DEFAULT_PAGINATION_CLASS': 'ztc.api.utils.pagination.HALPagination',
-    "DEFAULT_FILTER_BACKENDS": (
-        "vng_api_common.filters.Backend",
-        # 'rest_framework.filters.SearchFilter',
-        # 'rest_framework.filters.OrderingFilter',
-    ),
+    "DEFAULT_FILTER_BACKENDS": ("vng_api_common.filters.Backend",),
     #
     # # Filtering
-    # 'SEARCH_PARAM': 'zoek',  # 'search',
     "ORDERING_PARAM": "ordering",  # 'ordering',
     #
     # Versioning
@@ -61,41 +47,40 @@ BASE_REST_FRAMEWORK = {
     "EXCEPTION_HANDLER": "vng_api_common.views.exception_handler",
     "TEST_REQUEST_DEFAULT_FORMAT": "json",
 }
-
-BASE_SWAGGER_SETTINGS = {
+BASE_SPECTACULAR_SETTINGS = {
     "DEFAULT_GENERATOR_CLASS": "vng_api_common.generators.OpenAPISchemaGenerator",
-    "DEFAULT_AUTO_SCHEMA_CLASS": "vng_api_common.inspectors.view.AutoSchema",
-    "DEFAULT_INFO": "must.be.overridden",
-    "DEFAULT_FIELD_INSPECTORS": (
-        # GeometryFieldInspector has external dependencies, and is opt-in
-        # 'vng_api_common.inspectors.geojson.GeometryFieldInspector',
-        "vng_api_common.inspectors.fields.HyperlinkedIdentityFieldInspector",
-        "vng_api_common.inspectors.fields.ReadOnlyFieldInspector",
-        "vng_api_common.inspectors.polymorphic.PolymorphicSerializerInspector",
-        "vng_api_common.inspectors.fields.GegevensGroepInspector",
-        "drf_yasg.inspectors.CamelCaseJSONFilter",
-        "drf_yasg.inspectors.RecursiveFieldInspector",
-        "drf_yasg.inspectors.ReferencingSerializerInspector",
-        "drf_yasg.inspectors.ChoiceFieldInspector",
-        "drf_yasg.inspectors.FileFieldInspector",
-        "drf_yasg.inspectors.DictFieldInspector",
-        "drf_yasg.inspectors.JSONFieldInspector",
-        "drf_yasg.inspectors.HiddenFieldInspector",
-        "drf_yasg.inspectors.RelatedFieldInspector",
-        "drf_yasg.inspectors.SerializerMethodFieldInspector",
-        "drf_yasg.inspectors.SimpleFieldInspector",
-        "drf_yasg.inspectors.StringDefaultFieldInspector",
-    ),
-    "DEFAULT_FILTER_INSPECTORS": ("vng_api_common.inspectors.query.FilterInspector",),
+    "SERVE_INCLUDE_SCHEMA": False,
+    "POSTPROCESSING_HOOKS": [
+        "drf_spectacular.hooks.postprocess_schema_enums",
+        "drf_spectacular.contrib.djangorestframework_camel_case.camelize_serializer_fields",
+    ],
+    "SCHEMA_PATH_PREFIX": "/api/v1",
+}
+
+# add to SPECTACULAR_SETTINGS if you are using the AuthMiddleware
+JWT_SPECTACULAR_SETTINGS = {
+    "APPEND_COMPONENTS": {
+        "securitySchemes": {
+            SECURITY_DEFINITION_NAME: {
+                "type": "http",
+                "bearerFormat": "JWT",
+                "scheme": "bearer",
+            }
+        },
+    },
+    "SECURITY": [
+        {
+            SECURITY_DEFINITION_NAME: [],
+        }
+    ],
 }
 
+
 REDOC_SETTINGS = {"EXPAND_RESPONSES": "200,201", "SPEC_URL": "openapi.json"}
 
 # See: https://github.com/Rebilly/ReDoc#redoc-options-object
 LINK_FETCHER = "requests.get"
 
-ZDS_CLIENT_CLASS = "zds_client.Client"
-
 GEMMA_URL_TEMPLATE = "https://www.gemmaonline.nl/index.php/{informatiemodel}_{versie}/doc/{componenttype}/{component}"
 GEMMA_URL_COMPONENTTYPE = "objecttype"
 GEMMA_URL_INFORMATIEMODEL = "Rgbz"

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