#31 API POST Intervention

* adds support for proper POST of intervention
* makes /<id> optional (required for Post)

api/utils/serializer/__init__.py

@@ -0,0 +1,7 @@
+"""
+Author: Michel Peltriaux
+Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
+Contact: michel.peltriaux@sgdnord.rlp.de
+Created on: 24.01.22
+
+"""

api/utils/serializer/serializer.py

@@ -0,0 +1,106 @@
+"""
+Author: Michel Peltriaux
+Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
+Contact: michel.peltriaux@sgdnord.rlp.de
+Created on: 24.01.22
+
+"""
+import json
+from abc import abstractmethod
+
+from django.contrib.gis import geos
+from django.contrib.gis.geos import GEOSGeometry
+
+
+class AbstractModelAPISerializer:
+    model = None
+    lookup = None
+    properties_data = None
+
+    class Meta:
+        abstract = True
+
+    def __init__(self, *args, **kwargs):
+        self.lookup = {
+            "id": None,  # must be set
+            "deleted__isnull": True,
+            "users__in": [],  # must be set
+        }
+        super().__init__(*args, **kwargs)
+
+    @abstractmethod
+    def model_to_geo_json(self, entry):
+        """ Defines the model as geo json
+
+        Args:
+            entry (): The found entry from the database
+
+        Returns:
+
+        """
+        raise NotImplementedError("Must be implemented in subclasses")
+
+    @abstractmethod
+    def extend_properties_data(self, entry):
+        """ Defines the 'properties' part of geo json
+
+        Args:
+            entry (): The found entry from the database
+
+        Returns:
+
+        """
+        raise NotImplementedError("Must be implemented in subclasses")
+
+    @abstractmethod
+    def prepare_lookup(self, _id, user):
+        """ Updates lookup dict for db fetching
+
+        Args:
+            _id (str): The object's id
+            user (User): The user requesting for
+
+        Returns:
+
+        """
+        self.lookup["id"] = _id
+        self.lookup["users__in"] = [user]
+
+    def fetch_and_serialize(self):
+        """ Serializes the model entry according to the given lookup data
+
+        Args:
+
+        Returns:
+            serialized_data (dict)
+        """
+        entry = self.model.objects.get(**self.lookup)
+        serialized_data = self.model_to_geo_json(entry)
+        return serialized_data
+
+    @abstractmethod
+    def create_model_from_json(self, json_model, user):
+        """ Creates a new instance from given json data
+
+        Args:
+            json_model (dict): JSON data
+            user (User): The performing user
+
+        Returns:
+
+        """
+        raise NotImplementedError("Must be implemented in subclasses")
+
+    def create_geometry_from_json(self, geojson) -> GEOSGeometry:
+        """ Creates a GEOSGeometry object based on the given geojson
+
+        Args:
+            geojson (str|dict): The geojson as str or dict
+
+        Returns:
+            geometry (GEOSGeometry)
+        """
+        if isinstance(geojson, dict):
+            geojson = json.dumps(geojson)
+        geometry = geos.fromstr(geojson)
+        return geometry

api/utils/serializer/v1/__init__.py

@@ -0,0 +1,7 @@
+"""
+Author: Michel Peltriaux
+Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
+Contact: michel.peltriaux@sgdnord.rlp.de
+Created on: 24.01.22
+
+"""

api/utils/serializer/v1/compensation.py

@@ -0,0 +1,34 @@
+"""
+Author: Michel Peltriaux
+Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
+Contact: michel.peltriaux@sgdnord.rlp.de
+Created on: 24.01.22
+
+"""
+from api.utils.serializer.v1.serializer import AbstractModelAPISerializerV1
+from compensation.models import Compensation
+
+
+class CompensationAPISerializerV1(AbstractModelAPISerializerV1):
+    model = Compensation
+
+    def prepare_lookup(self, id, user):
+        self.lookup["id"] = id
+        del self.lookup["users__in"]
+        self.lookup["intervention__users__in"] = [user]
+
+    def intervention_to_json(self, entry):
+        return {
+            "id": entry.pk,
+            "identifier": entry.identifier,
+            "title": entry.title,
+        }
+
+    def extend_properties_data(self, entry):
+        self.properties_data["is_cef"] = entry.is_cef
+        self.properties_data["is_coherence_keeping"] = entry.is_coherence_keeping
+        self.properties_data["intervention"] = self.intervention_to_json(entry.intervention)
+        self.properties_data["before_states"] = self.compensation_state_to_json(entry.before_states.all())
+        self.properties_data["after_states"] = self.compensation_state_to_json(entry.after_states.all())
+        self.properties_data["actions"] = self.compensation_actions_to_json(entry.actions.all())
+        self.properties_data["deadlines"] = self.deadlines_to_json(entry.deadlines.all())

api/utils/serializer/v1/ecoaccount.py

@@ -0,0 +1,37 @@
+"""
+Author: Michel Peltriaux
+Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
+Contact: michel.peltriaux@sgdnord.rlp.de
+Created on: 24.01.22
+
+"""
+from api.utils.serializer.v1.serializer import AbstractModelAPISerializerV1
+from compensation.models import EcoAccount
+from intervention.models import Legal, Responsibility
+
+
+class EcoAccountAPISerializerV1(AbstractModelAPISerializerV1):
+    model = EcoAccount
+
+    def extend_properties_data(self, entry):
+        self.properties_data["deductable_surface"] = entry.deductable_surface
+        self.properties_data["deductable_surface_available"] = entry.deductable_surface - entry.get_deductions_surface()
+        self.properties_data["responsible"] = self.responsible_to_json(entry.responsible)
+        self.properties_data["legal"] = self.legal_to_json(entry.legal)
+        self.properties_data["before_states"] = self.compensation_state_to_json(entry.before_states.all())
+        self.properties_data["after_states"] = self.compensation_state_to_json(entry.after_states.all())
+        self.properties_data["actions"] = self.compensation_actions_to_json(entry.actions.all())
+        self.properties_data["deadlines"] = self.deadlines_to_json(entry.deadlines.all())
+        self.properties_data["deductions"] = self.deductions_to_json(entry.deductions.all())
+
+    def legal_to_json(self, legal: Legal):
+        return {
+            "agreement_date": legal.registration_date,
+        }
+
+    def responsible_to_json(self, responsible: Responsibility):
+        return {
+            "conservation_office": self.konova_code_to_json(responsible.conservation_office),
+            "conservation_file_number": responsible.conservation_file_number,
+            "handler": responsible.handler,
+        }

api/utils/serializer/v1/ema.py

@@ -0,0 +1,28 @@
+"""
+Author: Michel Peltriaux
+Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
+Contact: michel.peltriaux@sgdnord.rlp.de
+Created on: 24.01.22
+
+"""
+from api.utils.serializer.v1.serializer import AbstractModelAPISerializerV1
+from ema.models import Ema
+from intervention.models import Responsibility
+
+
+class EmaAPISerializerV1(AbstractModelAPISerializerV1):
+    model = Ema
+
+    def responsible_to_json(self, responsible: Responsibility):
+        return {
+            "conservation_office": self.konova_code_to_json(responsible.conservation_office),
+            "conservation_file_number": responsible.conservation_file_number,
+            "handler": responsible.handler,
+        }
+
+    def extend_properties_data(self, entry):
+        self.properties_data["responsible"] = self.responsible_to_json(entry.responsible)
+        self.properties_data["before_states"] = self.compensation_state_to_json(entry.before_states.all())
+        self.properties_data["after_states"] = self.compensation_state_to_json(entry.after_states.all())
+        self.properties_data["actions"] = self.compensation_actions_to_json(entry.actions.all())
+        self.properties_data["deadlines"] = self.deadlines_to_json(entry.deadlines.all())

api/utils/serializer/v1/intervention.py

@@ -0,0 +1,88 @@
+"""
+Author: Michel Peltriaux
+Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
+Contact: michel.peltriaux@sgdnord.rlp.de
+Created on: 24.01.22
+
+"""
+from django.db import transaction
+from django.db.models import QuerySet
+
+from api.utils.serializer.v1.serializer import AbstractModelAPISerializerV1
+from codelist.settings import CODELIST_CONSERVATION_OFFICE_ID, CODELIST_REGISTRATION_OFFICE_ID, \
+    CODELIST_PROCESS_TYPE_ID, CODELIST_LAW_ID
+from intervention.models import Intervention, Responsibility, Legal
+from konova.models import Geometry
+from konova.tasks import celery_update_parcels
+from user.models import UserActionLogEntry
+
+
+class InterventionAPISerializerV1(AbstractModelAPISerializerV1):
+    model = Intervention
+
+    def compensations_to_json(self, qs: QuerySet):
+        return list(
+            qs.values(
+                "id", "identifier", "title"
+            )
+        )
+
+    def extend_properties_data(self, entry):
+        self.properties_data["responsible"] = self.responsible_to_json(entry.responsible)
+        self.properties_data["legal"] = self.legal_to_json(entry.legal)
+        self.properties_data["compensations"] = self.compensations_to_json(entry.compensations.all())
+        self.properties_data["payments"] = self.payments_to_json(entry.payments.all())
+        self.properties_data["deductions"] = self.deductions_to_json(entry.deductions.all())
+
+    def create_model_from_json(self, json_model, user):
+        with transaction.atomic():
+            # Create geometry
+            json_geom = self.create_geometry_from_json(json_model)
+            geometry = Geometry()
+            geometry.geom = json_geom
+
+            # Create linked objects
+            obj = Intervention()
+            resp = Responsibility()
+            legal = Legal()
+            created = UserActionLogEntry.get_created_action(user, comment="API Import")
+            obj.legal = legal
+            obj.created = created
+            obj.geometry = geometry
+            obj.responsible = resp
+
+            # Fill in data to objects
+            properties = json_model["properties"]
+            obj.identifier = obj.generate_new_identifier()
+            obj.title = properties["title"]
+            obj.responsible.registration_office = self.konova_code_from_json(
+                properties["responsible"]["registration_office"],
+                CODELIST_REGISTRATION_OFFICE_ID
+            )
+            obj.responsible.registration_file_number = properties["responsible"]["registration_file_number"]
+            obj.responsible.conservation_office = self.konova_code_from_json(
+                properties["responsible"]["conservation_office"],
+                CODELIST_CONSERVATION_OFFICE_ID,
+            )
+            obj.responsible.conservation_file_number = properties["responsible"]["conservation_file_number"]
+            obj.responsible.handler = properties["responsible"]["handler"]
+
+            obj.legal.registration_date = properties["legal"]["registration_date"]
+            obj.legal.binding_date = properties["legal"]["binding_date"]
+            obj.legal.process_type = self.konova_code_from_json(
+                properties["legal"]["process_type"],
+                CODELIST_PROCESS_TYPE_ID,
+            )
+            laws = [self.konova_code_from_json(law, CODELIST_LAW_ID) for law in properties["legal"]["laws"]]
+            obj.legal.laws.set(laws)
+
+            obj.responsible.save()
+            obj.geometry.save()
+            obj.legal.save()
+            obj.save()
+
+            obj.users.add(user)
+
+            celery_update_parcels.delay(geometry.id)
+
+            return obj.id

api/utils/serializer/v1/serializer.py

@@ -0,0 +1,216 @@
+"""
+Author: Michel Peltriaux
+Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
+Contact: michel.peltriaux@sgdnord.rlp.de
+Created on: 24.01.22
+
+"""
+
+import json
+
+from django.db.models import QuerySet
+
+from api.utils.serializer.serializer import AbstractModelAPISerializer
+from codelist.models import KonovaCode
+from intervention.models import Responsibility, Legal
+
+
+class AbstractModelAPISerializerV1(AbstractModelAPISerializer):
+    def model_to_geo_json(self, entry):
+        """ Adds the basic data, which all elements hold
+
+        Args:
+            entry (): The data entry
+
+        Returns:
+
+        """
+        geom = entry.geometry.geom.geojson
+        geo_json = json.loads(geom)
+        self.properties_data = {
+            "id": entry.id,
+            "identifier": entry.identifier,
+            "title": entry.title,
+            "created_on": self.created_on_to_json(entry),
+            "modified_on": self.modified_on_to_json(entry),
+        }
+        self.extend_properties_data(entry)
+        geo_json["properties"] = self.properties_data
+        return geo_json
+
+    def konova_code_to_json(self, konova_code: KonovaCode):
+        """ Serializes KonovaCode model into json
+
+        Args:
+            konova_code (KonovaCode): The KonovaCode entry
+
+        Returns:
+            serialized_json (dict)
+        """
+        return {
+            "atom_id": konova_code.atom_id,
+            "long_name": konova_code.long_name,
+            "short_name": konova_code.short_name,
+        }
+
+    def konova_code_from_json(self, json_str, code_list_identifier):
+        """ Returns a konova code instance
+
+        Args:
+            json_str (str): The value for the code (atom id)
+            code_list_identifier (str): From which konova code list this code is supposed to be from
+
+        Returns:
+
+        """
+        code = KonovaCode.objects.get(
+            atom_id=json_str,
+            code_lists__in=[code_list_identifier]
+        )
+        return code
+
+    def responsible_to_json(self, responsible: Responsibility):
+        """ Serializes Responsibility model into json
+
+        Args:
+            responsible (Responsibility): The Responsibility entry
+
+        Returns:
+            serialized_json (dict)
+        """
+        return {
+            "registration_office": self.konova_code_to_json(responsible.registration_office),
+            "registration_file_number": responsible.registration_file_number,
+            "conservation_office": self.konova_code_to_json(responsible.conservation_office),
+            "conservation_file_number": responsible.conservation_file_number,
+            "handler": responsible.handler,
+        }
+
+    def legal_to_json(self, legal: Legal):
+        """ Serializes Legal model into json
+
+        Args:
+            legal (Legal): The Legal entry
+
+        Returns:
+            serialized_json (dict)
+        """
+        return {
+            "registration_date": legal.registration_date,
+            "binding_date": legal.binding_date,
+            "process_type": self.konova_code_to_json(legal.process_type),
+            "laws": [self.konova_code_to_json(law) for law in legal.laws.all()],
+        }
+
+    def payments_to_json(self, qs: QuerySet):
+        """ Serializes payments into json
+
+        Args:
+            qs (QuerySet): A queryset of Payment entries
+
+        Returns:
+            serialized_json (list)
+        """
+        return list(qs.values("amount", "due_on", "comment"))
+
+    def deductions_to_json(self, qs: QuerySet):
+        """ Serializes eco account deductions into json
+
+        Args:
+            qs (QuerySet): A queryset of EcoAccountDeduction entries
+
+        Returns:
+            serialized_json (list)
+        """
+        return [
+            {
+                "id": entry.pk,
+                "eco_account": {
+                    "id": entry.account.pk,
+                    "identifier": entry.account.identifier,
+                    "title": entry.account.title,
+                },
+                "surface": entry.surface,
+                "intervention": {
+                    "id": entry.intervention.pk,
+                    "identifier": entry.intervention.identifier,
+                    "title": entry.intervention.title,
+                }
+            }
+            for entry in qs
+        ]
+
+    def compensation_state_to_json(self, qs: QuerySet):
+        """ Serializes compensation states into json
+
+        Args:
+            qs (QuerySet): A queryset of CompensationState entries
+
+        Returns:
+            serialized_json (list)
+        """
+        return [
+            {
+                "biotope": self.konova_code_to_json(entry.biotope_type),
+                "surface": entry.surface,
+            }
+            for entry in qs
+        ]
+
+    def compensation_actions_to_json(self, qs: QuerySet):
+        """ Serializes CompensationActions into json
+
+        Args:
+            qs (QuerySet): A queryset of CompensationAction entries
+
+        Returns:
+            serialized_json (list)
+        """
+        return [
+            {
+                "action": self.konova_code_to_json(entry.action_type),
+                "amount": entry.amount,
+                "unit": entry.unit,
+                "comment": entry.comment,
+            }
+            for entry in qs
+        ]
+
+    def deadlines_to_json(self, qs: QuerySet):
+        """ Serializes deadlines into json
+
+        Args:
+            qs (QuerySet): A queryset of Deadline entries
+
+        Returns:
+            serialized_json (list)
+        """
+        return list(qs.values(
+            "type",
+            "date",
+            "comment",
+        ))
+
+    def created_on_to_json(self, entry):
+        """ Serializes the created_on into json
+
+        Args:
+            entry (BaseObject): The entry
+
+        Returns:
+            created_on (timestamp)
+        """
+        return entry.created.timestamp
+
+    def modified_on_to_json(self, entry):
+        """ Serializes the modified_on into json
+
+        Args:
+            entry (BaseObject): The entry
+
+        Returns:
+            modified_on (timestamp)
+        """
+        modified_on = entry.modified or entry.created
+        modified_on = modified_on.timestamp
+        return modified_on