Feature/writable api

requirements/base.in

@@ -22,6 +22,7 @@ django-sniplates
 djangorestframework
 # django-extra-fields
 # django-filter
+drf-nested-routers
 drf-yasg  # api documentation
 
 # WSGI servers & monitoring - production oriented

requirements/base.txt

@@ -28,7 +28,7 @@ django-solo==1.1.3        # via vng-api-common
 django==2.2.12            # via -r requirements/base.in, django-appconf, django-axes, django-choices, django-filter, django-jsonsuit, django-redis, django-rest-framework-condition, django-rosetta, django-sniplates, drf-nested-routers, drf-yasg, vng-api-common
 djangorestframework-camel-case==1.2.0  # via vng-api-common
 djangorestframework==3.9.4  # via -r requirements/base.in, drf-nested-routers, drf-yasg, vng-api-common
-drf-nested-routers==0.91  # via vng-api-common
+drf-nested-routers==0.91  # via -r requirements/base.in, vng-api-common
 drf-yasg==1.16.0          # via -r requirements/base.in, vng-api-common
 elastic-apm==5.5.2        # via -r requirements/base.in
 gemma-zds-client==0.13.3  # via vng-api-common

src/objecttypes/api/serializers.py

@@ -1,26 +1,57 @@
 from rest_framework import serializers
+from rest_framework_nested.relations import NestedHyperlinkedRelatedField
+from rest_framework_nested.serializers import NestedHyperlinkedModelSerializer
 
 from objecttypes.core.models import ObjectType, ObjectVersion
 
+from .validators import JsonSchemaValidator, VersionUpdateValidator
+
+
+class ObjectVersionSerializer(NestedHyperlinkedModelSerializer):
+    parent_lookup_kwargs = {"objecttype_uuid": "object_type__uuid"}
 
-class ObjectVersionSerializer(serializers.ModelSerializer):
     class Meta:
         model = ObjectVersion
         fields = (
+            "url",
             "version",
+            "objectType",
             "publicationDate",
             "status",
             "jsonSchema",
         )
         extra_kwargs = {
-            "publicationDate": {"source": "publication_date"},
-            "jsonSchema": {"source": "json_schema"},
-            "status": {"read_only": True},
+            "url": {"lookup_field": "version"},
+            "version": {"read_only": True},
+            "objectType": {
+                "source": "object_type",
+                "lookup_field": "uuid",
+                "read_only": True,
+            },
+            "publicationDate": {"source": "publication_date", "read_only": True},
+            "jsonSchema": {
+                "source": "json_schema",
+                "validators": [JsonSchemaValidator()],
+            },
         }
+        validators = [VersionUpdateValidator()]
+
+    def create(self, validated_data):
+        kwargs = self.context["request"].resolver_match.kwargs
+        object_type = ObjectType.objects.get(uuid=kwargs["objecttype_uuid"])
+        validated_data["object_type"] = object_type
+
+        return super().create(validated_data)
 
 
 class ObjectTypeSerializer(serializers.HyperlinkedModelSerializer):
-    versions = ObjectVersionSerializer(many=True)
+    versions = NestedHyperlinkedRelatedField(
+        many=True,
+        read_only=True,
+        lookup_field="version",
+        view_name="objectversion-detail",
+        parent_lookup_kwargs={"objecttype_uuid": "object_type__uuid"},
+    )
 
     class Meta:
         model = ObjectType

src/objecttypes/api/urls.py

@@ -1,13 +1,17 @@
 from django.conf.urls import include
 from django.urls import path, re_path
 
-from rest_framework import routers
+from vng_api_common import routers
 from vng_api_common.schema import SchemaView
 
-from .views import ObjectTypeViewSet
+from .views import ObjectTypeViewSet, ObjectVersionViewSet
 
-router = routers.DefaultRouter(trailing_slash=False)
-router.register(r"objecttypes", ObjectTypeViewSet)
+router = routers.DefaultRouter()
+router.register(
+    r"objecttypes",
+    ObjectTypeViewSet,
+    [routers.nested("versions", ObjectVersionViewSet)],
+)
 
 
 urlpatterns = [

src/objecttypes/api/validators.py

@@ -0,0 +1,38 @@
+from django.core.exceptions import ValidationError
+from django.utils.translation import ugettext_lazy as _
+
+from rest_framework import serializers
+
+from objecttypes.core.constants import ObjectVersionStatus
+from objecttypes.core.utils import check_json_schema
+
+
+class VersionUpdateValidator:
+    message = _("Only draft versions can be changed")
+    code = "non-draft-version-update"
+
+    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.request = serializer.context["request"]
+
+    def __call__(self, attrs):
+        if not self.instance:
+            return
+
+        if self.instance.status != ObjectVersionStatus.draft:
+            raise serializers.ValidationError(self.message, code=self.code)
+
+
+class JsonSchemaValidator:
+    code = "invalid-json-schema"
+
+    def __call__(self, value):
+        try:
+            check_json_schema(value)
+        except ValidationError as exc:
+            raise serializers.ValidationError(exc.args[0], code=self.code) from exc

src/objecttypes/api/views.py

@@ -1,13 +1,53 @@
+from django.utils.translation import ugettext_lazy as _
+
 from rest_framework import viewsets
+from rest_framework.exceptions import ValidationError
+from rest_framework.settings import api_settings
+from vng_api_common.viewsets import NestedViewSetMixin
 
-from objecttypes.core.models import ObjectType
+from objecttypes.core.constants import ObjectVersionStatus
+from objecttypes.core.models import ObjectType, ObjectVersion
 
 from .filters import ObjectTypeFilterSet
-from .serializers import ObjectTypeSerializer
+from .serializers import ObjectTypeSerializer, ObjectVersionSerializer
 
 
-class ObjectTypeViewSet(viewsets.ReadOnlyModelViewSet):
+class ObjectTypeViewSet(viewsets.ModelViewSet):
     queryset = ObjectType.objects.prefetch_related("versions").order_by("-pk")
     serializer_class = ObjectTypeSerializer
     lookup_field = "uuid"
     filterset_class = ObjectTypeFilterSet
+
+    def perform_destroy(self, instance):
+        if instance.versions.exists():
+            raise ValidationError(
+                {
+                    api_settings.NON_FIELD_ERRORS_KEY: [
+                        _(
+                            "All related versions should be destroyed before destroying the objecttype"
+                        )
+                    ]
+                },
+                code="pending-versions",
+            )
+
+        super().perform_destroy(instance)
+
+
+class ObjectVersionViewSet(NestedViewSetMixin, viewsets.ModelViewSet):
+    queryset = ObjectVersion.objects.order_by("object_type", "-version")
+    serializer_class = ObjectVersionSerializer
+    lookup_field = "version"
+
+    def perform_destroy(self, instance):
+        if instance.status != ObjectVersionStatus.draft:
+            raise ValidationError(
+                {
+                    api_settings.NON_FIELD_ERRORS_KEY: [
+                        _("Only draft versions can be destroyed")
+                    ]
+                },
+                code="non-draft-version-destroy",
+            )
+
+        super().perform_destroy(instance)

src/objecttypes/core/migrations/0013_auto_20201118_1251.py

@@ -0,0 +1,20 @@
+# Generated by Django 2.2.12 on 2020-11-18 11:51
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0012_auto_20201112_1123"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="objectversion",
+            name="version",
+            field=models.PositiveSmallIntegerField(
+                help_text="Integer version of the OBJECTTYPE", verbose_name="version"
+            ),
+        ),
+    ]

src/objecttypes/core/models.py

@@ -2,18 +2,15 @@
 from datetime import date
 
 from django.contrib.postgres.fields import JSONField
-from django.core.exceptions import ValidationError
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
 
-from jsonschema.exceptions import SchemaError
-from jsonschema.validators import validator_for
-
 from .constants import (
     DataClassificationChoices,
     ObjectVersionStatus,
     UpdateFrequencyChoices,
 )
+from .utils import check_json_schema
 
 
 class ObjectType(models.Model):
@@ -120,7 +117,7 @@ class ObjectVersion(models.Model):
         ObjectType, on_delete=models.CASCADE, related_name="versions"
     )
     version = models.PositiveSmallIntegerField(
-        _("version"), help_text=_("Integer version of the OBJECTTYPE"), default=1
+        _("version"), help_text=_("Integer version of the OBJECTTYPE")
     )
     publication_date = models.DateField(
         _("publication date"),
@@ -147,8 +144,22 @@ def __str__(self):
     def clean(self):
         super().clean()
 
-        schema_validator = validator_for(self.json_schema)
-        try:
-            schema_validator.check_schema(self.json_schema)
-        except SchemaError as exc:
-            raise ValidationError(exc.args[0]) from exc
+        check_json_schema(self.json_schema)
+
+    def save(self, *args, **kwargs):
+        if not self.version:
+            self.version = self.generate_version_number()
+
+        super().save(*args, **kwargs)
+
+    def generate_version_number(self) -> int:
+        existed_versions = ObjectVersion.objects.filter(object_type=self.object_type)
+
+        max_version = 0
+        if existed_versions.exists():
+            max_version = existed_versions.aggregate(models.Max("version"))[
+                "version__max"
+            ]
+
+        version_number = max_version + 1
+        return version_number

src/objecttypes/core/tests/factories.py

@@ -14,7 +14,6 @@ class Meta:
 
 class ObjectVersionFactory(factory.django.DjangoModelFactory):
     object_type = factory.SubFactory(ObjectTypeFactory)
-    version = factory.Sequence(lambda n: n)
     json_schema = {
         "type": "object",
         "title": "Tree",

src/objecttypes/core/utils.py

@@ -0,0 +1,12 @@
+from django.core.exceptions import ValidationError
+
+from jsonschema.exceptions import SchemaError
+from jsonschema.validators import validator_for
+
+
+def check_json_schema(json_schema: dict):
+    schema_validator = validator_for(json_schema)
+    try:
+        schema_validator.check_schema(json_schema)
+    except SchemaError as exc:
+        raise ValidationError(exc.args[0]) from exc