#31 API code cleaning

* splits large AbstractModelAPISerializer into different reusable Mixins to increase reusability of code for similar models

api/utils/serializer/v1/compensation.py

@@ -7,16 +7,15 @@ Created on: 24.01.22
 """
 from django.db import transaction
 
-from api.utils.serializer.v1.serializer import AbstractModelAPISerializerV1
-from codelist.settings import CODELIST_COMPENSATION_ACTION_ID, CODELIST_BIOTOPES_ID
-from compensation.models import Compensation, CompensationAction, CompensationState, UnitChoices
+from api.utils.serializer.v1.serializer import AbstractModelAPISerializerV1, AbstractCompensationAPISerializerV1Mixin
+from compensation.models import Compensation
 from intervention.models import Intervention
-from konova.models import Geometry, Deadline, DeadlineType
+from konova.models import Geometry
 from konova.tasks import celery_update_parcels
 from user.models import UserActionLogEntry
 
 
-class CompensationAPISerializerV1(AbstractModelAPISerializerV1):
+class CompensationAPISerializerV1(AbstractModelAPISerializerV1, AbstractCompensationAPISerializerV1Mixin):
     model = Compensation
 
     def prepare_lookup(self, id, user):
@@ -88,122 +87,6 @@ class CompensationAPISerializerV1(AbstractModelAPISerializerV1):
         obj.intervention = intervention
         return obj
 
-    def set_deadlines(self, obj, deadline_data):
-        """ Sets the linked deadline data according to the given deadline_data
-
-
-        Args:
-            obj (Compensation): The Compensation object
-            deadline_data (dict): The posted deadline_data
-
-        Returns:
-            obj (Compensation)
-        """
-        found_deadlines = []
-        for entry in deadline_data:
-            deadline_type = entry["type"]
-            date = entry["date"]
-            comment = entry["comment"]
-
-            if deadline_type not in DeadlineType:
-                raise ValueError(f"Invalid deadline type. Choices are {DeadlineType.values}")
-
-            pre_existing_deadlines = obj.deadlines.filter(
-                type=deadline_type,
-                date=date,
-                comment=comment,
-            ).exclude(
-                id__in=found_deadlines
-            )
-            if pre_existing_deadlines.count() > 0:
-                found_deadlines += pre_existing_deadlines.values_list("id", flat=True)
-            else:
-                # Create!
-                new_deadline = Deadline.objects.create(
-                    type=deadline_type,
-                    date=date,
-                    comment=comment,
-                )
-                obj.deadlines.add(new_deadline)
-        return obj
-
-    def set_compensation_states(self, obj, states_data, states_manager):
-        """ Sets the linked compensation state data according to the given states_data
-
-
-        Args:
-            obj (Compensation): The Compensation object
-            states_data (dict): The posted states_data
-            states_manager (Manager): The before_states or after_states manager
-
-        Returns:
-            obj (Compensation)
-        """
-        found_states = []
-        for entry in states_data:
-            biotope_type = entry["biotope"]
-            surface = float(entry["surface"])
-            if surface <= 0:
-                raise ValueError("State surfaces must be > 0")
-            pre_existing_states = states_manager.filter(
-                biotope_type__atom_id=biotope_type,
-                surface=surface,
-            ).exclude(
-                id__in=found_states
-            )
-            if pre_existing_states.count() > 0:
-                found_states += pre_existing_states.values_list("id", flat=True)
-            else:
-                # Create!
-                new_state = CompensationState.objects.create(
-                    biotope_type=self.konova_code_from_json(biotope_type, CODELIST_BIOTOPES_ID),
-                    surface=surface
-                )
-                states_manager.add(new_state)
-        return obj
-
-    def set_compensation_actions(self, obj, actions_data):
-        """ Sets the linked compensation action data according to the given actions_data
-
-
-        Args:
-            obj (Compensation): The Compensation object
-            actions_data (dict): The posted actions_data
-
-        Returns:
-            obj (Compensation)
-        """
-        found_actions = []
-        for entry in actions_data:
-            action = entry["action"]
-            amount = float(entry["amount"])
-            unit = entry["unit"]
-            comment = entry["comment"]
-
-            if amount <= 0:
-                raise ValueError("Action amount must be > 0")
-            if unit not in UnitChoices:
-                raise ValueError(f"Invalid unit. Choices are {UnitChoices.values}")
-            pre_existing_actions = obj.actions.filter(
-                action_type__atom_id=action,
-                amount=amount,
-                unit=unit,
-                comment=comment,
-            ).exclude(
-                id__in=found_actions
-            )
-            if pre_existing_actions.count() > 0:
-                found_actions += pre_existing_actions.values_list("id", flat=True)
-            else:
-                # Create!
-                new_action = CompensationAction.objects.create(
-                    action_type=self.konova_code_from_json(action, CODELIST_COMPENSATION_ACTION_ID),
-                    amount=amount,
-                    unit=unit,
-                    comment=comment,
-                )
-                obj.actions.add(new_action)
-        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