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

"""
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:

        """
        if json_str is None or len(json_str) == 0:
            return None
        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