konova/api/utils/serializer/v1/intervention.py

"""
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 initialize_objects(self, json_model, user):
        """ Initializes all needed objects from the json_model data

        Does not persist data to the DB!

        Args:
            json_model (dict): The json data
            user (User): The API user

        Returns:
            obj (Intervention)
        """
        create_action = UserActionLogEntry.get_created_action(user, comment="API Import")
        # Create geometry
        json_geom = self.create_geometry_from_json(json_model)
        geometry = Geometry()
        geometry.geom = json_geom
        geometry.created = create_action

        # Create linked objects
        obj = Intervention()
        resp = Responsibility()
        legal = Legal()
        created = create_action
        obj.legal = legal
        obj.created = created
        obj.geometry = geometry
        obj.responsible = resp
        return obj

    def set_legal(self, obj, legal_data):
        """ Sets the legal data contents to the provided legal_data dict

        Args:
            obj (Intervention): The intervention object
            legal_data (dict): The new data

        Returns:
            obj
        """
        obj.legal.registration_date = legal_data["registration_date"]
        obj.legal.binding_date = legal_data["binding_date"]
        obj.legal.process_type = self.konova_code_from_json(
            legal_data["process_type"],
            CODELIST_PROCESS_TYPE_ID,
        )
        laws = [self.konova_code_from_json(law, CODELIST_LAW_ID) for law in legal_data["laws"]]
        obj.legal.laws.set(laws)
        return obj
    
    def set_responsibility(self, obj, responsibility_data: dict):
        """ Sets the responsible data contents to the provided responsibility_data dict

        Args:
            obj (Intervention): The intervention object
            responsibility_data (dict): The new data

        Returns:
            obj
        """
        obj.responsible.registration_office = self.konova_code_from_json(
            responsibility_data["registration_office"],
            CODELIST_REGISTRATION_OFFICE_ID
        )
        obj.responsible.registration_file_number = responsibility_data["registration_file_number"]
        obj.responsible.conservation_office = self.konova_code_from_json(
            responsibility_data["conservation_office"],
            CODELIST_CONSERVATION_OFFICE_ID,
        )
        obj.responsible.conservation_file_number = responsibility_data["conservation_file_number"]
        obj.responsible.handler = responsibility_data["handler"]
        return obj

    def create_model_from_json(self, json_model, user):
        """ Creates a new entry for the model based on the contents of json_model

        Args:
            json_model (dict): The json containing data
            user (User): The API user

        Returns:
            created_id (str): The id of the newly created Intervention entry
        """
        with transaction.atomic():
            obj = self.initialize_objects(json_model, user)

            # Fill in data to objects
            properties = json_model["properties"]
            obj.identifier = obj.generate_new_identifier()
            obj.title = properties["title"]
            self.set_responsibility(obj, properties["responsible"])
            self.set_legal(obj, properties["legal"])

            obj.responsible.save()
            obj.geometry.save()
            obj.legal.save()
            obj.save()

            obj.users.add(user)
            obj.log.add(obj.created)

            celery_update_parcels.delay(obj.geometry.id)

            return obj.id

    def update_model_from_json(self, id, json_model, user):
        """ Updates an entry for the model based on the contents of json_model

        Args:
            id (str): The object's id
            json_model (dict): The json containing data
            user (User): The API user

        Returns:
            created_id (str): The id of the newly created Intervention entry
        """
        with transaction.atomic():
            obj = self.get_obj_from_db(id, user)

            # Fill in data to objects
            properties = json_model["properties"]
            obj.title = properties["title"]
            self.set_responsibility(obj, properties["responsible"])
            self.set_legal(obj, properties["legal"])
            obj.geometry.geom = self.create_geometry_from_json(json_model)

            obj.responsible.save()
            obj.geometry.save()
            obj.legal.save()
            obj.save()

            obj.users.add(user)

            celery_update_parcels.delay(obj.geometry.id)

            return obj.id