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

@@ -25,8 +25,6 @@
 #                                                                             #
 ###############################################################################
 
-from django.conf import settings
-
 from rest_framework import serializers
 
 from ..common.serializers import VersionableSerializer
@@ -91,6 +89,7 @@ class DatabaseCreationSerializer(serializers.ModelSerializer):
     declaration = JSONSerializerField(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
@@ -101,55 +100,53 @@ class DatabaseCreationSerializer(serializers.ModelSerializer):
             "declaration",
             "code",
             "previous_version",
+            "version",
         ]
-        beat_core_class = beat.core.database
+        beat_core_class = beat.core.database.Database
 
     def validate(self, data):
         user = self.context.get("user")
         name = self.Meta.model.sanitize_name(data["name"])
         data["name"] = name
+        version = data["version"]
 
-        if "previous_version" in data:
-            previous_version_id = self.Meta.beat_core_class.Storage(
-                settings.PREFIX, data["previous_version"]
+        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
+                )
             )
-        else:
-            previous_version_id = None
 
-        # Retrieve the previous version (if applicable)
-        if previous_version_id is not None:
+        previous_version = data.get("previous_version")
+
+        if previous_version is not None:
             try:
-                previous_version = self.Meta.model.objects.get(
-                    name=previous_version_id.name, version=previous_version_id.version
+                previous_object = self.Meta.model.objects.get(
+                    name=name, version=previous_version
                 )
-            except Exception:
+            except self.Meta.model.DoesNotExist:
                 raise serializers.ValidationError(
-                    "Database '%s' not found" % previous_version_id.fullname
+                    {
+                        "previous_version",
+                        "Database '{}' version '{}' not found".format(
+                            name, previous_version
+                        ),
+                    }
                 )
 
-            is_accessible = previous_version.accessibility_for(user)
+            is_accessible = previous_object.accessibility_for(user)
             if not is_accessible[0]:
                 raise serializers.ValidationError("No access allowed")
-            data["previous_version"] = previous_version
+            data["previous_version"] = previous_object
 
-        # Determine the version number
-        last_version = None
-
-        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]
-
-        if last_version is None:
-            if self.Meta.model.objects.filter(name=name).count() > 0:
+            if version - previous_object.version != 1:
                 raise serializers.ValidationError(
-                    "This {} name already exists".format(
-                        self.Meta.model.__name__.lower()
+                    "The requested version ({}) for this {} does not match"
+                    "the standard increment with {}".format(
+                        version, self.Meta.model.__name__, previous_object.version
                     )
                 )
-
-        data["version"] = last_version.version + 1 if last_version is not None else 1
+            data["previous_version"] = previous_object
 
         return data