Refactor update creation api

This merge request does the following:

• Raise DRF errors rather than returning response to take advantage of the DRF exception handling mechanism
• Create serialisers for PUT request to simplify the code
• Improve validation checks in several places
• Fixes several issues in DRF infrastructure uses
• Fixes JSON fields handling
• Remove routes that do no fully qualify objects
• Implement a custom DRF exception handler that will allow to log errors
• Improve testing
• Improve permission management

beat/web/databases/serializers.py

@@ -30,55 +30,57 @@ from django.conf import settings
 from rest_framework import serializers
 
 from ..common.serializers import VersionableSerializer
-from ..common.fields import JSONSerializerField
+from ..common import fields as beat_fields
 
 from .models import Database
 from .exceptions import DatabaseCreationError
 
 import beat.core.database
 
+
 class DatabaseSerializer(VersionableSerializer):
     protocols = serializers.SerializerMethodField()
     description = serializers.SerializerMethodField()
-    declaration = JSONSerializerField()
+    declaration = beat_fields.JSONField()
 
     class Meta(VersionableSerializer.Meta):
         model = Database
-        exclude = ['description_file', 'declaration_file', 'source_code_file']
+        exclude = ["description_file", "declaration_file", "source_code_file"]
 
     def __init__(self, *args, **kwargs):
         super(DatabaseSerializer, self).__init__(*args, **kwargs)
         self.experiments_stats = {}
 
     def get_description(self, obj):
-        return obj.description.decode('utf8')
+        return obj.description.decode("utf8")
 
     def get_protocols(self, obj):
-        protocols_options = self.context['request'].query_params.get('protocols_options', [])
-        include_datasets = 'datasets' in protocols_options
-        include_outputs = 'outputs' in protocols_options
+        protocols_options = self.context["request"].query_params.get(
+            "protocols_options", []
+        )
+        include_datasets = "datasets" in protocols_options
+        include_outputs = "outputs" in protocols_options
         entries = []
 
         for protocol in obj.protocols.all():
-            protocol_entry = {
-                'name': protocol.name,
-            }
+            protocol_entry = {"name": protocol.name}
 
             if include_datasets:
-                protocol_entry['datasets'] = []
+                protocol_entry["datasets"] = []
 
-                for dataset in protocol.sets.order_by('name'):
-                    dataset_entry = {
-                        'name': dataset.name,
-                    }
+                for dataset in protocol.sets.order_by("name"):
+                    dataset_entry = {"name": dataset.name}
 
                     if include_outputs:
-                        dataset_entry['outputs'] = map(lambda x: {
-                            'name': x.name,
-                              'dataformat': x.dataformat.fullname(),
-                        }, dataset.template.outputs.order_by('name'))
+                        dataset_entry["outputs"] = map(
+                            lambda x: {
+                                "name": x.name,
+                                "dataformat": x.dataformat.fullname(),
+                            },
+                            dataset.template.outputs.order_by("name"),
+                        )
 
-                    protocol_entry['datasets'].append(dataset_entry)
+                    protocol_entry["datasets"].append(dataset_entry)
 
             entries.append(protocol_entry)
         return entries
@@ -86,58 +88,76 @@ class DatabaseSerializer(VersionableSerializer):
 
 class DatabaseCreationSerializer(serializers.ModelSerializer):
     code = serializers.CharField(required=False)
-    declaration = JSONSerializerField(required=False)
+    declaration = beat_fields.JSONField(required=False)
     description = serializers.CharField(required=False, allow_blank=True)
     previous_version = serializers.CharField(required=False)
+    version = serializers.IntegerField(min_value=1)
 
     class Meta:
         model = Database
-        fields = ['name', 'short_description', 'description',
-                  'declaration', 'code', 'previous_version']
-        beat_core_class = beat.core.database
+        fields = [
+            "name",
+            "short_description",
+            "description",
+            "declaration",
+            "code",
+            "previous_version",
+            "version",
+        ]
+        beat_core_class = beat.core.database.Database
+
+    def validate_declaration(self, declaration):
+        obj = self.Meta.beat_core_class(prefix=settings.PREFIX, data=declaration)
+        if not obj.valid:
+            raise serializers.ValidationError(obj.errors)
+        return declaration
 
     def validate(self, data):
-        user = self.context.get('user')
-        name = self.Meta.model.sanitize_name(data['name'])
-        data['name'] = name
-
-        if 'previous_version' in data:
-            previous_version_id = self.Meta.beat_core_class.Storage(settings.PREFIX,
-                                                                    data['previous_version'])
-        else:
-            previous_version_id = None
-
-        # Retrieve the previous version (if applicable)
-        if previous_version_id is not None:
-            try:
-                previous_version = self.Meta.model.objects.get(
-                    name=previous_version_id.name,
-                    version=previous_version_id.version)
-            except:
-                raise serializers.ValidationError("Database '%s' not found" % \
-                                                  previous_version_id.fullname)
-
-            is_accessible = previous_version.accessibility_for(user)
-            if not is_accessible[0]:
-                raise serializers.ValidationError('No access allowed')
-            data['previous_version'] = previous_version
+        user = self.context.get("user")
+        name = self.Meta.model.sanitize_name(data["name"])
+        data["name"] = name
+        version = data["version"]
 
-        # Determine the version number
-        last_version = None
+        if self.Meta.model.objects.filter(name=name, version=version).exists():
+            raise serializers.ValidationError(
+                "{} {} version {} already exists".format(
+                    self.Meta.model.__name__.lower(), name, version
+                )
+            )
 
-        if previous_version_id is not None:
-            if (previous_version_id.name == name):
-                last_version = self.Meta.model.objects.filter(name=name).order_by('-version')[0]
+        previous_version = data.get("previous_version")
 
-        if last_version is None:
-            if self.Meta.model.objects.filter(name=name).count() > 0:
-                raise serializers.ValidationError('This {} name already exists'.format(self.Meta.model.__name__.lower()))
+        if previous_version is not None:
+            try:
+                previous_object = self.Meta.model.objects.get(
+                    name=name, version=previous_version
+                )
+            except self.Meta.model.DoesNotExist:
+                raise serializers.ValidationError(
+                    {
+                        "previous_version",
+                        "Database '{}' version '{}' not found".format(
+                            name, previous_version
+                        ),
+                    }
+                )
 
-        data['version'] = (last_version.version + 1 if last_version is not None else 1)
+            is_accessible = previous_object.accessibility_for(user)
+            if not is_accessible[0]:
+                raise serializers.ValidationError("No access allowed")
+            data["previous_version"] = previous_object
+
+            if version - previous_object.version != 1:
+                raise serializers.ValidationError(
+                    "The requested version ({}) for this {} does not match"
+                    "the standard increment with {}".format(
+                        version, self.Meta.model.__name__, previous_object.version
+                    )
+                )
+            data["previous_version"] = previous_object
 
         return data
 
-
     def create(self, validated_data):
         (db_object, errors) = self.Meta.model.objects.create_database(**validated_data)
         if errors: