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

vng_api_common/validators.py

@@ -5,17 +5,14 @@ from typing import Callable
 
 from django.conf import settings
 from django.core.exceptions import ValidationError
-from django.core.validators import RegexValidator
 from django.utils import timezone
 from django.utils.deconstruct import deconstructible
 from django.utils.module_loading import import_string
 from django.utils.translation import gettext_lazy as _
 
-import requests
 from rest_framework import serializers, validators
 
-from .client import get_client
-from .constants import RSIN_LENGTH
+from .constants import BSN_LENGTH, RSIN_LENGTH
 from .oas import fetcher, obj_has_shape
 
 logger = logging.getLogger(__name__)
@@ -24,6 +21,90 @@ logger = logging.getLogger(__name__)
 WORD_REGEX = re.compile(r"[\w\-]+$", re.ASCII)
 
 
+class BaseIdentifierValidator:
+    """
+    Validator base class that performs common validation logic.
+    Digit check, length, and optional 11-proof check.
+    """
+
+    error_messages = {
+        "isdigit": _("Voer een numerieke waarde in"),
+        "length": _("Waarde moet %(identifier_length)s tekens lang zijn"),
+        "11proefnumber": _("Ongeldige code"),
+    }
+
+    def __init__(
+        self,
+        value: str,
+        identifier_length: int,
+        validate_11proef: bool = False,
+    ):
+        self.value = value
+        self.identifier_length = identifier_length
+        self.validate_11proef = validate_11proef
+
+    def validate_isdigit(self) -> None:
+        """Validates that the value contains only digits."""
+        if not self.value.isdigit():
+            raise ValidationError(self.error_messages["isdigit"], code="only-digits")
+
+    def validate_length(self) -> None:
+        """Validates that the length of the value is within the allowed sizes."""
+        if len(self.value) != self.identifier_length:
+            raise ValidationError(
+                self.error_messages["length"]
+                % {"identifier_length": self.identifier_length},
+                code="invalid-length",
+            )
+
+    def validate_11proefnumber(self) -> None:
+        """Validates the value based on the 11-proof check."""
+        total = 0
+        for multiplier, char in enumerate(reversed(self.value), start=1):
+            if multiplier == 1:
+                total += -multiplier * int(char)
+            else:
+                total += multiplier * int(char)
+
+        if total % 11 != 0:
+            raise ValidationError(self.error_messages["11proefnumber"], code="invalid")
+
+    def validate(self) -> None:
+        self.validate_isdigit()
+        self.validate_length()
+        if self.validate_11proef:
+            self.validate_11proefnumber()
+
+
+def validate_rsin(value: str) -> None:
+    """
+    Validates that a string value is a valid RSIN number by applying the
+    '11-proef' checking.
+
+    :param value: String object representing a presumably good RSIN number.
+    """
+
+    validator = BaseIdentifierValidator(
+        value, identifier_length=RSIN_LENGTH, validate_11proef=True
+    )
+    validator.error_messages["11proefnumber"] = _("Onjuist RSIN nummer")
+    validator.validate()
+
+
+def validate_bsn(value: str) -> None:
+    """
+    Validates that a string value is a valid BSN number by applying the
+    '11-proef' checking.
+
+    :param value: String object representing a presumably good BSN number.
+    """
+    validator = BaseIdentifierValidator(
+        value, identifier_length=BSN_LENGTH, validate_11proef=True
+    )
+    validator.error_messages["11proefnumber"] = _("Onjuist BSN nummer")
+    validator.validate()
+
+
 @deconstructible
 class AlphanumericExcludingDiacritic:
     """
@@ -75,37 +156,6 @@ def validate_non_negative_string(value):
         raise ValidationError("De waarde moet een niet-negatief getal zijn.")
 
 
-validate_digits = RegexValidator(
-    regex="^[0-9]+$", message="Waarde moet numeriek zijn.", code="only-digits"
-)
-
-
-def validate_rsin(value):
-    """
-    Validates that a string value is a valid RSIN number by applying the
-    '11-proef' checking.
-
-    :param value: String object representing a presumably good RSIN number.
-    """
-    # Initial sanity checks.
-    validate_digits(value)
-    if len(value) != RSIN_LENGTH:
-        raise ValidationError(
-            "RSIN moet %s tekens lang zijn." % RSIN_LENGTH, code="invalid-length"
-        )
-
-    # 11-proef check.
-    total = 0
-    for multiplier, char in enumerate(reversed(value), start=1):
-        if multiplier == 1:
-            total += -multiplier * int(char)
-        else:
-            total += multiplier * int(char)
-
-    if total % 11 != 0:
-        raise ValidationError("Onjuist RSIN nummer.", code="invalid")
-
-
 class URLValidator:
     """
     Validate that the URL actually resolves to a HTTP 200
@@ -206,64 +256,21 @@ class ResourceValidator(URLValidator):
 
 
 class InformatieObjectUniqueValidator(validators.UniqueTogetherValidator):
+    requires_context = True
+
     def __init__(self, parent_field, field: str):
         self.parent_field = parent_field
         self.field = field
         super().__init__(None, (parent_field, field))
 
-    def set_context(self, serializer_field):
-        serializer = serializer_field.parent
-        super().set_context(serializer)
-
-        self.queryset = serializer.Meta.model._default_manager.all()
-        self.parent_object = serializer.context["parent_object"]
-
-    def __call__(self, informatieobject: str):
-        attrs = {self.parent_field: self.parent_object, self.field: informatieobject}
+    def __call__(self, informatieobject: str, serializer):
+        attrs = {
+            self.parent_field: serializer.context["parent_object"],
+            self.field: informatieobject,
+        }
         super().__call__(attrs)
 
 
-class ObjectInformatieObjectValidator:
-    """
-    Validate that the INFORMATIEOBJECT is linked already in the DRC.
-    """
-
-    message = _(
-        "Het informatieobject is in het DRC nog niet gerelateerd aan dit object."
-    )
-    code = "inconsistent-relation"
-
-    def set_context(self, serializer):
-        """
-        This hook is called by the serializer instance,
-        prior to the validation call being made.
-        """
-        self.parent_object = serializer.context["parent_object"]
-        self.request = serializer.context["request"]
-
-    def __call__(self, informatieobject: str):
-        object_url = self.parent_object.get_absolute_api_url(self.request)
-
-        # dynamic so that it can be mocked in tests easily
-        client = get_client(informatieobject)
-
-        try:
-            oios = client.list(
-                "objectinformatieobject",
-                query_params={
-                    "informatieobject": informatieobject,
-                    "object": object_url,
-                },
-            )
-        except requests.HTTPError as exc:
-            raise serializers.ValidationError(
-                exc.args[0], code="relation-validation-error"
-            ) from exc
-
-        if len(oios) == 0:
-            raise serializers.ValidationError(self.message, code=self.code)
-
-
 @deconstructible
 class UntilNowValidator:
     """
@@ -309,42 +316,35 @@ class UniekeIdentificatieValidator:
     :param identificatie_field: naam van het veld dat de identificatie bevat
     """
 
-    message = _("Deze identificatie bestaat al binnen de organisatie")
+    message = _("Deze identificatie ({identificatie}) bestaat al binnen de organisatie")
     code = "identificatie-niet-uniek"
+    requires_context = True
 
     def __init__(self, organisatie_field: str, identificatie_field="identificatie"):
         self.organisatie_field = organisatie_field
         self.identificatie_field = identificatie_field
 
-    def set_context(self, serializer):
-        """
-        This hook is called by the serializer instance,
-        prior to the validation call being made.
-        """
-        # Determine the existing instance, if this is an update operation.
-        self.instance = getattr(serializer, "instance", None)
-        self.model = serializer.Meta.model
-
-    def __call__(self, attrs: dict):
+    def __call__(self, attrs: dict, serializer):
+        instance = getattr(serializer, "instance", None)
         identificatie = attrs.get(self.identificatie_field)
         if not identificatie:
-            if self.instance:
+            if instance:
                 # In case of a partial update
-                identificatie = self.instance.identificatie
+                identificatie = instance.identificatie
             else:
                 # identification is being generated, and the generation checks for
                 # uniqueness
                 return
 
         organisatie = attrs.get(self.organisatie_field)
-        pk = self.instance.pk if self.instance else None
+        pk = instance.pk if instance else None
 
         # if we're updating an instance, setting the current values will not
         # trigger an error because the instance-to-be-updated is excluded from
         # the queryset. If either bronorganisatie or identificatie changes,
         # and it already exists, it will raise a validation error
         combination_exists = (
-            self.model.objects
+            serializer.Meta.model.objects
             # in case of an update, exclude the current object. for a create, this
             # will be None
             .exclude(pk=pk)
@@ -359,7 +359,12 @@ class UniekeIdentificatieValidator:
 
         if combination_exists:
             raise serializers.ValidationError(
-                {self.identificatie_field: self.message}, code=self.code
+                {
+                    self.identificatie_field: self.message.format(
+                        identificatie=identificatie
+                    )
+                },
+                code=self.code,
             )
 
 
@@ -370,22 +375,15 @@ class IsImmutableValidator:
 
     message = _("Dit veld mag niet gewijzigd worden.")
     code = "wijzigen-niet-toegelaten"
+    requires_context = True
 
-    def set_context(self, serializer_field):
-        """
-        This hook is called by the serializer instance,
-        prior to the validation call being made.
-        """
-        # Determine the existing instance, if this is an update operation.
-        self.serializer_field = serializer_field
-        self.instance = getattr(serializer_field.parent, "instance", None)
-
-    def __call__(self, new_value):
+    def __call__(self, new_value, serializer_field):
+        instance = getattr(serializer_field.parent, "instance", None)
         # no instance -> it's not an update
-        if not self.instance:
+        if not instance:
             return
 
-        current_value = getattr(self.instance, self.serializer_field.field_name)
+        current_value = getattr(instance, serializer_field.field_name)
 
         if new_value != current_value:
             raise serializers.ValidationError(self.message, code=self.code)

vng_api_common/views.py

@@ -1,6 +1,7 @@
 import logging
 import os
 from collections import OrderedDict
+from typing import Optional
 
 from django.apps import apps
 from django.conf import settings
@@ -13,7 +14,8 @@ import requests
 from rest_framework import exceptions as drf_exceptions, status
 from rest_framework.response import Response
 from rest_framework.views import exception_handler as drf_exception_handler
-from zds_client import ClientError
+
+from vng_api_common.client import Client
 
 from . import exceptions
 from .compat import sentry_client
@@ -128,12 +130,20 @@ def _test_ac_config() -> list:
     auth_config = AuthorizationsConfig.get_solo()
 
     # check if AC auth is configured
-    ac_client = AuthorizationsConfig.get_client()
-    has_ac_auth = ac_client.auth is not None
+    ac_client: Optional[Client] = AuthorizationsConfig.get_client()
+    has_ac_auth = ac_client.auth is not None if ac_client else False
 
     checks = [
         (_("Type of component"), auth_config.get_component_display(), None),
-        (_("AC"), auth_config.api_root, auth_config.api_root.endswith("/")),
+        (
+            _("AC"),
+            (
+                auth_config.authorizations_api_service.api_root
+                if ac_client
+                else _("Missing")
+            ),
+            bool(ac_client),
+        ),
         (
             _("Credentials for AC"),
             _("Configured") if has_ac_auth else _("Missing"),
@@ -145,18 +155,17 @@ def _test_ac_config() -> list:
     if has_ac_auth:
         error = False
 
+        client_id = ac_client.auth.service.client_id
+
         try:
-            ac_client.list(
-                "applicatie", query_params={"clientIds": ac_client.auth.client_id}
+            response: requests.Response = ac_client.get(
+                "applicaties", params={"clientIds": client_id}
             )
-        except requests.ConnectionError:
+
+            response.raise_for_status()
+        except requests.RequestException:
             error = True
             message = _("Could not connect with AC")
-        except ClientError as exc:
-            error = True
-            message = _(
-                "Cannot retrieve authorizations: HTTP {status_code} - {error_code}"
-            ).format(status_code=exc.args[0]["status"], error_code=exc.args[0]["code"])
         else:
             message = _("Can retrieve authorizations")
 
@@ -165,15 +174,17 @@ def _test_ac_config() -> list:
     return checks
 
 
-def _test_nrc_config() -> list:
-    if not apps.is_installed("vng_api_common.notifications"):
+def _test_nrc_config(check_autorisaties_subscription=True) -> list:
+    if not apps.is_installed("notifications_api_common"):
         return []
 
     from notifications_api_common.models import NotificationsConfig, Subscription
 
     nrc_config = NotificationsConfig.get_solo()
+    nrc_client: Optional[Client] = NotificationsConfig.get_client()
 
-    nrc_client = NotificationsConfig.get_client()
+    if not nrc_client:
+        return [((_("NRC"), _("Missing"), False))]
 
     has_nrc_auth = nrc_client.auth is not None if nrc_client else False
 
@@ -199,20 +210,24 @@ def _test_nrc_config() -> list:
         error = False
 
         try:
-            nrc_client.list("kanaal")
+            response: requests.Response = nrc_client.get("kanaal")
+            response.raise_for_status()
         except requests.ConnectionError:
             error = True
             message = _("Could not connect with NRC")
-        except ClientError as exc:
+        except requests.HTTPError as exc:
             error = True
-            message = _(
-                "Cannot retrieve kanalen: HTTP {status_code} - {error_code}"
-            ).format(status_code=exc.args[0]["status"], error_code=exc.args[0]["code"])
+            message = _("Cannot retrieve kanalen: HTTP {status_code}").format(
+                status_code=exc.response.status_code
+            )
         else:
             message = _("Can retrieve kanalen")
 
         checks.append((_("NRC connection and authorizations"), message, not error))
 
+    if not check_autorisaties_subscription:
+        return checks
+
     #  check if there's a subscription for AC notifications
     has_sub = (
         Subscription.objects.filter(channels__contains=["autorisaties"])

commonground_api_common-1.12.2.data/scripts/generate_schema

@@ -1,39 +0,0 @@
-#!/bin/bash
-
-# Run this script from the root of the repository
-
-set -e
-
-if [[ -z "$VIRTUAL_ENV" ]]; then
-    echo "You need to activate your virtual env before running this script"
-    exit 1
-fi
-
-echo "Generating Swagger schema"
-src/manage.py generate_swagger \
-    ./src/swagger2.0.json \
-    --overwrite \
-    --format=json \
-    --mock-request \
-    --url https://example.com/api/v1
-
-echo "Converting Swagger to OpenAPI 3.0..."
-npm run convert
-patch_content_types
-
-echo "Generating unresolved OpenAPI 3.0 schema"
-use_external_components
-
-echo "Generating resources document"
-src/manage.py generate_swagger \
-    ./src/resources.md \
-    --overwrite \
-    --mock-request \
-    --url https://example.com/api/v1 \
-    --to-markdown-table
-
-echo "Generating autorisaties.md"
-src/manage.py generate_autorisaties --output-file ./src/autorisaties.md
-
-echo "Generating notificaties.md"
-src/manage.py generate_notificaties --output-file ./src/notificaties.md

commonground_api_common-1.12.2.data/scripts/use_external_components

@@ -1,16 +0,0 @@
-#!/bin/bash
-
-# Run this script from the root of the repository
-
-set -e
-
-if [[ -z "$VIRTUAL_ENV" ]]; then
-    echo "You need to activate your virtual env before running this script"
-    exit 1
-fi
-
-source_file=${1:-./src/openapi.yaml}
-output=${2:-./src/openapi_unresolved.yaml}
-manage=${MANAGE:-src/manage.py}
-
-python $manage use_external_components $source_file $output

vng_api_common/inspectors/cache.py

@@ -1,57 +0,0 @@
-from collections import OrderedDict
-
-from django.utils.translation import gettext_lazy as _
-
-from drf_yasg import openapi
-from rest_framework.views import APIView
-
-from ..caching.introspection import has_cache_header
-
-CACHE_REQUEST_HEADERS = [
-    openapi.Parameter(
-        name="If-None-Match",
-        type=openapi.TYPE_STRING,
-        in_=openapi.IN_HEADER,
-        required=False,
-        description=_(
-            "Perform conditional requests. This header should contain one or "
-            "multiple ETag values of resources the client has cached. If the "
-            "current resource ETag value is in this set, then an HTTP 304 "
-            "empty body will be returned. See "
-            "[MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match) "
-            "for details."
-        ),
-        examples={
-            "oneValue": {
-                "summary": _("One ETag value"),
-                "value": '"79054025255fb1a26e4bc422aef54eb4"',
-            },
-            "multipleValues": {
-                "summary": _("Multiple ETag values"),
-                "value": '"79054025255fb1a26e4bc422aef54eb4", "e4d909c290d0fb1ca068ffaddf22cbd0"',
-            },
-        },
-    )
-]
-
-
-def get_cache_headers(view: APIView) -> OrderedDict:
-    if not has_cache_header(view):
-        return OrderedDict()
-
-    return OrderedDict(
-        (
-            (
-                "ETag",
-                openapi.Schema(
-                    type=openapi.TYPE_STRING,
-                    description=_(
-                        "De ETag berekend op de response body JSON. "
-                        "Indien twee resources exact dezelfde ETag hebben, dan zijn "
-                        "deze resources identiek aan elkaar. Je kan de ETag gebruiken "
-                        "om caching te implementeren."
-                    ),
-                ),
-            ),
-        )
-    )

vng_api_common/inspectors/fields.py

@@ -1,126 +0,0 @@
-import logging
-
-from drf_yasg import openapi
-from drf_yasg.inspectors.base import NotHandled
-from drf_yasg.inspectors.field import FieldInspector, InlineSerializerInspector
-from rest_framework import serializers
-
-from ..serializers import GegevensGroepSerializer, LengthHyperlinkedRelatedField
-
-logger = logging.getLogger(__name__)
-
-
-TYPES_MAP = {
-    str: openapi.TYPE_STRING,
-    int: openapi.TYPE_INTEGER,
-    bool: openapi.TYPE_BOOLEAN,
-}
-
-
-class ReadOnlyFieldInspector(FieldInspector):
-    """
-    Provides conversion for derived ReadOnlyField from model fields.
-
-    This inspector looks at the type hint to determine the type/format of
-    a model property.
-    """
-
-    def field_to_swagger_object(
-        self, field, swagger_object_type, use_references, **kwargs
-    ):
-        SwaggerType, ChildSwaggerType = self._get_partial_types(
-            field, swagger_object_type, use_references, **kwargs
-        )
-
-        if (
-            isinstance(field, serializers.ReadOnlyField)
-            and swagger_object_type == openapi.Schema
-        ):
-            prop = getattr(field.parent.Meta.model, field.source)
-            if not isinstance(prop, property):
-                return NotHandled
-
-            return_type = prop.fget.__annotations__.get("return")
-            if return_type is None:  # no type annotation, too bad...
-                logger.debug(
-                    "Missing return type annotation for prop %s on model %s",
-                    field.source,
-                    field.parent.Meta.model,
-                )
-                return NotHandled
-
-            type_ = TYPES_MAP.get(return_type)
-            if type_ is None:
-                logger.debug("Missing type mapping for %r", return_type)
-
-            return SwaggerType(type=type_ or openapi.TYPE_STRING)
-
-        return NotHandled
-
-
-class HyperlinkedIdentityFieldInspector(FieldInspector):
-    def field_to_swagger_object(
-        self, field, swagger_object_type, use_references, **kwargs
-    ):
-        SwaggerType, ChildSwaggerType = self._get_partial_types(
-            field, swagger_object_type, use_references, **kwargs
-        )
-
-        if (
-            isinstance(field, serializers.HyperlinkedIdentityField)
-            and swagger_object_type == openapi.Schema
-        ):
-            return SwaggerType(
-                type=openapi.TYPE_STRING,
-                format=openapi.FORMAT_URI,
-                min_length=1,
-                max_length=1000,
-                description="URL-referentie naar dit object. Dit is de unieke identificatie en locatie van dit object.",
-            )
-
-        return NotHandled
-
-
-class HyperlinkedRelatedFieldInspector(FieldInspector):
-    def field_to_swagger_object(
-        self, field, swagger_object_type, use_references, **kwargs
-    ):
-        SwaggerType, ChildSwaggerType = self._get_partial_types(
-            field, swagger_object_type, use_references, **kwargs
-        )
-
-        if (
-            isinstance(field, LengthHyperlinkedRelatedField)
-            and swagger_object_type == openapi.Schema
-        ):
-            max_length = field.max_length
-            min_length = field.min_length
-            return SwaggerType(
-                type=openapi.TYPE_STRING,
-                format=openapi.FORMAT_URI,
-                min_length=min_length,
-                max_length=max_length,
-                description=field.help_text,
-            )
-
-        return NotHandled
-
-
-class GegevensGroepInspector(InlineSerializerInspector):
-    def process_result(self, result, method_name, obj, **kwargs):
-        if not isinstance(result, openapi.Schema.OR_REF):
-            return result
-
-        if not isinstance(obj, GegevensGroepSerializer):
-            return result
-
-        if method_name != "field_to_swagger_object":
-            return result
-
-        if not obj.allow_null:
-            return result
-
-        schema = openapi.resolve_ref(result, self.components)
-        schema.x_nullable = True
-
-        return result