compensation/forms/eco_account.py

@@ -172,23 +172,6 @@ class EditEcoAccountForm(NewEcoAccountForm):
             disabled_fields
         )
 
-    def is_valid(self):
-        valid = super().is_valid()
-
-        deductable_surface = self.cleaned_data.get("surface")
-        deduction_surface_sum = self.instance.get_deductions_surface()
-        if deductable_surface < deduction_surface_sum:
-            self.add_error(
-                "surface",
-                _("{}m² have been deducted from this eco account so far. The given value of {} would be too low.").format(
-                    deduction_surface_sum,
-                    deductable_surface
-                )
-            )
-            valid &= False
-
-        return valid
-
     def save(self, user: User, geom_form: SimpleGeomForm):
         with transaction.atomic():
             # Fetch data from cleaned POST values

compensation/forms/modals/deadline.py

@@ -65,22 +65,6 @@ class NewDeadlineModalForm(BaseModalForm):
         self.form_title = _("New deadline")
         self.form_caption = _("Insert data for the new deadline")
 
-    def is_valid(self):
-        valid = super().is_valid()
-        deadline_type = self.cleaned_data.get("type")
-        comment = self.cleaned_data.get("comment") or None
-
-        other_deadline_without_comment = deadline_type == DeadlineType.OTHER and comment is None
-
-        if other_deadline_without_comment:
-            self.add_error(
-                "comment",
-                _("Please explain this 'other' type of deadline.")
-            )
-            valid &= False
-
-        return valid
-
     def save(self):
         deadline = self.instance.add_deadline(self)
         return deadline

compensation/models/compensation.py

@@ -22,7 +22,7 @@ from compensation.utils.quality import CompensationQualityChecker
 from konova.models import BaseObject, AbstractDocument, Deadline, generate_document_file_upload_path, \
     GeoReferencedMixin, DeadlineType, ResubmitableObjectMixin
 from konova.utils.message_templates import DATA_UNSHARED_EXPLANATION, COMPENSATION_REMOVED_TEMPLATE, \
-    DOCUMENT_REMOVED_TEMPLATE, DEADLINE_REMOVED, DEADLINE_ADDED, \
+    DOCUMENT_REMOVED_TEMPLATE, DEADLINE_REMOVED, ADDED_DEADLINE, \
     COMPENSATION_ACTION_REMOVED, COMPENSATION_STATE_REMOVED, INTERVENTION_HAS_REVOCATIONS_TEMPLATE
 from user.models import UserActionLogEntry
 
@@ -76,7 +76,7 @@ class AbstractCompensation(BaseObject,
 
             self.save()
             self.deadlines.add(deadline)
-            self.mark_as_edited(user, edit_comment=DEADLINE_ADDED)
+            self.mark_as_edited(user, edit_comment=ADDED_DEADLINE)
             return deadline
 
     def remove_deadline(self, form):
@@ -200,9 +200,7 @@ class AbstractCompensation(BaseObject,
         Returns:
 
         """
-        val = qs.aggregate(Sum("surface"))["surface__sum"] or 0
-        val = float('{:0.2f}'.format(val))
-        return val
+        return qs.aggregate(Sum("surface"))["surface__sum"] or 0
 
     def quality_check(self) -> CompensationQualityChecker:
         """ Performs data quality check
@@ -399,7 +397,7 @@ class Compensation(AbstractCompensation, CEFMixin, CoherenceMixin, PikMixin):
         Returns:
             users (QuerySet)
         """
-        return self.intervention.shared_users
+        return self.intervention.users.all()
 
     @property
     def shared_teams(self) -> QuerySet:
@@ -408,7 +406,7 @@ class Compensation(AbstractCompensation, CEFMixin, CoherenceMixin, PikMixin):
         Returns:
             users (QuerySet)
         """
-        return self.intervention.shared_teams
+        return self.intervention.teams.all()
 
     def get_documents(self) -> QuerySet:
         """ Getter for all documents of a compensation
@@ -513,11 +511,8 @@ class CompensationDocument(AbstractDocument):
             # The only file left for this compensation is the one which is currently processed and will be deleted
             # Make sure that the compensation folder itself is deleted as well, not only the file
             # Therefore take the folder path from the file path
-            try:
-                folder_path = self.file.path.split("/")[:-1]
-                folder_path = "/".join(folder_path)
-            except ValueError:
-                folder_path = None
+            folder_path = self.file.path.split("/")[:-1]
+            folder_path = "/".join(folder_path)
 
         if user:
             self.instance.mark_as_edited(user, edit_comment=DOCUMENT_REMOVED_TEMPLATE.format(self.title))

compensation/models/eco_account.py

@@ -59,6 +59,20 @@ class EcoAccount(AbstractCompensation, ShareableObjectMixin, RecordableObjectMix
     def __str__(self):
         return f"{self.identifier} ({self.title})"
 
+    def clean(self):
+        # Deductable surface can not be larger than added states after surface
+        after_state_sum = self.get_state_after_surface_sum()
+        if self.deductable_surface > after_state_sum:
+            raise ValidationError(_("Deductable surface can not be larger than existing surfaces in after states"))
+
+        # Deductable surface can not be lower than amount of already deducted surfaces
+        # User needs to contact deducting user in case of further problems
+        deducted_sum = self.get_deductions_surface()
+        if self.deductable_surface < deducted_sum:
+            raise ValidationError(
+                _("Deductable surface can not be smaller than the sum of already existing deductions. Please contact the responsible users for the deductions!")
+            )
+
     def save(self, *args, **kwargs):
         if self.identifier is None or len(self.identifier) == 0:
             # Create new identifier if none was given
@@ -86,9 +100,15 @@ class EcoAccount(AbstractCompensation, ShareableObjectMixin, RecordableObjectMix
         Returns:
             sum_surface (float)
         """
-        val = self.deductions.all().aggregate(Sum("surface"))["surface__sum"] or 0
-        val = float('{:0.2f}'.format(val))
-        return val
+        return self.deductions.all().aggregate(Sum("surface"))["surface__sum"] or 0
+
+    def get_state_after_surface_sum(self) -> float:
+        """ Calculates the account's after state surface sum
+
+        Returns:
+            sum_surface (float)
+        """
+        return self.after_states.all().aggregate(Sum("surface"))["surface__sum"] or 0
 
     def __calculate_deductable_rest(self):
         """ Calculates available rest surface of the eco account
@@ -98,7 +118,10 @@ class EcoAccount(AbstractCompensation, ShareableObjectMixin, RecordableObjectMix
         Returns:
             ret_val_total (float): Total amount
         """
-        deductions_surfaces = self.get_deductions_surface()
+        deductions = self.deductions.filter(
+            intervention__deleted=None,
+        )
+        deductions_surfaces = deductions.aggregate(Sum("surface"))["surface__sum"] or 0
 
         available_surface = self.deductable_surface
         if available_surface is None:
@@ -226,11 +249,8 @@ class EcoAccountDocument(AbstractDocument):
             # The only file left for this eco account is the one which is currently processed and will be deleted
             # Make sure that the compensation folder itself is deleted as well, not only the file
             # Therefore take the folder path from the file path
-            try:
-                folder_path = self.file.path.split("/")[:-1]
-                folder_path = "/".join(folder_path)
-            except ValueError:
-                folder_path = None
+            folder_path = self.file.path.split("/")[:-1]
+            folder_path = "/".join(folder_path)
 
         if user:
             self.instance.mark_as_edited(user, edit_comment=DOCUMENT_REMOVED_TEMPLATE.format(self.title))

compensation/tests/compensation/unit/test_forms.py

@@ -5,21 +5,27 @@ Contact: ksp-servicestelle@sgdnord.rlp.de
 Created on: 21.08.23
 
 """
+from datetime import timedelta
+
+from dateutil.parser import parse
 from django.core.exceptions import ObjectDoesNotExist
 from django.test import RequestFactory
+from django.utils.timezone import now
 from django.utils.translation import gettext_lazy as _
 
 from codelist.models import KonovaCodeList
 from codelist.settings import CODELIST_COMPENSATION_ACTION_ID, CODELIST_BIOTOPES_ID
 from compensation.forms.modals.compensation_action import NewCompensationActionModalForm, \
     EditCompensationActionModalForm, RemoveCompensationActionModalForm
+from compensation.forms.modals.deadline import NewDeadlineModalForm, EditDeadlineModalForm
 from compensation.forms.modals.state import NewCompensationStateModalForm, EditCompensationStateModalForm, \
     RemoveCompensationStateModalForm
 from compensation.models import UnitChoices
+from konova.models import DeadlineType
 from konova.tests.test_views import BaseTestCase
 from konova.utils.generators import generate_random_string
 from konova.utils.message_templates import COMPENSATION_ACTION_EDITED, ADDED_COMPENSATION_ACTION, \
-    COMPENSATION_ACTION_REMOVED, ADDED_COMPENSATION_STATE, COMPENSATION_STATE_EDITED, \
+    COMPENSATION_ACTION_REMOVED, ADDED_DEADLINE, DEADLINE_EDITED, ADDED_COMPENSATION_STATE, COMPENSATION_STATE_EDITED, \
     COMPENSATION_STATE_REMOVED
 from user.models import UserAction
 
@@ -157,6 +163,95 @@ class RemoveCompensationActionModalFormTestCase(EditCompensationActionModalFormT
             pass
 
 
+class NewDeadlineModalFormTestCase(BaseTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        self.request = RequestFactory().request()
+        self.request.user = self.superuser
+
+    def test_init(self):
+        form = NewDeadlineModalForm(
+            request=self.request,
+            instance=self.compensation
+        )
+        self.assertEqual(form.form_title, str(_("New deadline")))
+        self.assertEqual(form.form_caption, str(_("Insert data for the new deadline")))
+
+    def test_save(self):
+        deadline_type = DeadlineType.MAINTAIN
+        deadline_date = now().date() + timedelta(days=500)
+        deadline_comment = generate_random_string(50, use_letters_uc=True, use_letters_lc=True)
+
+        data = {
+            "type": deadline_type,
+            "date": deadline_date,
+            "comment": deadline_comment,
+        }
+
+        form = NewDeadlineModalForm(data, request=self.request, instance=self.compensation)
+        self.assertTrue(form.is_valid())
+
+        deadline = form.save()
+        last_log = self.compensation.log.first()
+
+        self.assertEqual(last_log.user, self.superuser)
+        self.assertEqual(last_log.action, UserAction.EDITED)
+        self.assertEqual(last_log.comment, ADDED_DEADLINE)
+
+        self.assertEqual(deadline.date, deadline_date)
+        self.assertEqual(deadline.type, deadline_type)
+        self.assertEqual(deadline.comment, deadline_comment)
+        self.assertIn(deadline, self.compensation.deadlines.all())
+
+
+class EditDeadlineModalFormTestCase(NewDeadlineModalFormTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        self.compensation.deadlines.add(self.finished_deadline)
+
+    def test_init(self):
+        form = EditDeadlineModalForm(
+            request=self.request,
+            instance=self.compensation,
+            deadline=self.finished_deadline
+        )
+        self.assertEqual(form.deadline, self.finished_deadline)
+        self.assertEqual(form.form_title, str(_("Edit deadline")))
+        self.assertEqual(form.fields["type"].initial, self.finished_deadline.type)
+        self.assertEqual(form.fields["date"].initial, self.finished_deadline.date)
+        self.assertEqual(form.fields["comment"].initial, self.finished_deadline.comment)
+
+    def test_save(self):
+        edit_type = DeadlineType.MAINTAIN
+        edit_date = parse(self.finished_deadline.date).date() - timedelta(days=5)
+        edit_comment = generate_random_string(length=40, use_letters_lc=True)
+
+        data = {
+            "type": edit_type,
+            "date": edit_date,
+            "comment": edit_comment,
+        }
+        form = EditDeadlineModalForm(
+            data,
+            request=self.request,
+            instance=self.compensation,
+            deadline=self.finished_deadline
+        )
+        self.assertTrue(form.is_valid())
+
+        deadline = form.save()
+        self.assertEqual(deadline.type, edit_type)
+        self.assertEqual(deadline.date, edit_date)
+        self.assertEqual(deadline.comment, edit_comment)
+
+        last_log = self.compensation.log.first()
+        self.assertEqual(last_log.action, UserAction.EDITED)
+        self.assertEqual(last_log.user, self.superuser)
+        self.assertEqual(last_log.comment, DEADLINE_EDITED)
+
+        self.assertIn(deadline, self.compensation.deadlines.all())
+
+
 class NewCompensationStateModalFormTestCase(BaseTestCase):
     def setUp(self) -> None:
         super().setUp()
@@ -276,7 +371,6 @@ class EditCompensationStateModalFormTestCase(NewCompensationStateModalFormTestCa
         self.assertEqual(last_log.user, self.superuser)
         self.assertEqual(last_log.comment, COMPENSATION_STATE_EDITED)
 
-
 class RemoveCompensationStateModalFormTestCase(EditCompensationStateModalFormTestCase):
     def setUp(self) -> None:
         super().setUp()

compensation/tests/compensation/unit/test_models.py

@@ -1,201 +0,0 @@
-"""
-Author: Michel Peltriaux
-Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
-Contact: ksp-servicestelle@sgdnord.rlp.de
-Created on: 30.08.23
-
-"""
-from django.core.exceptions import ObjectDoesNotExist
-from django.test import RequestFactory
-from django.utils.timezone import now
-
-from compensation.forms.modals.deadline import NewDeadlineModalForm
-from compensation.models import CompensationDocument
-from konova.forms.modals import RemoveDeadlineModalForm
-from konova.models import DeadlineType
-from konova.tests.test_views import BaseTestCase
-from konova.utils.message_templates import DEADLINE_REMOVED, DOCUMENT_REMOVED_TEMPLATE, COMPENSATION_REMOVED_TEMPLATE, \
-    DEADLINE_ADDED
-from user.models import UserAction, Team
-
-
-class AbstractCompensationModelTestCase(BaseTestCase):
-    def setUp(self) -> None:
-        super().setUp()
-        self.request = RequestFactory().request()
-        self.request.user = self.superuser
-
-    def test_remove_deadline(self):
-        self.compensation.deadlines.add(self.finished_deadline)
-
-        data = {
-            "confirm": True
-        }
-
-        form = RemoveDeadlineModalForm(
-            data,
-            request=self.request,
-            instance=self.compensation,
-            deadline=self.finished_deadline,
-        )
-        self.assertTrue(form.is_valid(), msg=form.errors)
-        self.assertIn(self.finished_deadline, self.compensation.deadlines.all())
-        form.save()
-
-        last_log = self.compensation.log.first()
-        self.assertEqual(last_log.user, self.request.user)
-        self.assertEqual(last_log.action, UserAction.EDITED)
-        self.assertEqual(last_log.comment, DEADLINE_REMOVED)
-
-        self.assertNotIn(self.finished_deadline, self.compensation.deadlines.all())
-        try:
-            self.finished_deadline.refresh_from_db()
-            self.fail("Deadline should not exist anymore after removing from abstract compensation")
-        except ObjectDoesNotExist:
-            pass
-
-    def test_add_deadline(self):
-        request = RequestFactory().request()
-        request.user = self.superuser
-
-        data = {
-            "type": DeadlineType.MAINTAIN,
-            "date": now().date(),
-            "comment": "TestDeadline"
-        }
-        form = NewDeadlineModalForm(
-            data,
-            request=self.request,
-            instance=self.compensation,
-        )
-        self.assertTrue(form.is_valid(), msg=form.errors)
-        deadline = self.compensation.add_deadline(form)
-        self.assertEqual(deadline.date, data["date"])
-        self.assertEqual(deadline.type, data["type"])
-        self.assertEqual(deadline.comment, data["comment"])
-        self.assertEqual(deadline.created.action, UserAction.CREATED)
-        self.assertEqual(deadline.created.user, self.superuser)
-        self.assertEqual(deadline.created.comment, None)
-        self.assertIn(deadline, self.compensation.deadlines.all())
-
-        last_log = self.compensation.log.first()
-        self.assertEqual(last_log.action, UserAction.EDITED)
-        self.assertEqual(last_log.user, self.superuser)
-        self.assertEqual(last_log.comment, DEADLINE_ADDED)
-
-
-class CompensationTestCase(BaseTestCase):
-    def setUp(self) -> None:
-        super().setUp()
-
-    def test_str(self):
-        self.assertEqual(str(self.compensation), self.compensation.identifier)
-
-    def test_save(self):
-        old_identifier = self.compensation.identifier
-        self.compensation.identifier = None
-        self.compensation.save()
-        self.assertIsNotNone(self.compensation.identifier)
-        self.assertNotEqual(old_identifier, self.compensation.identifier)
-
-    def test_share_with_user(self):
-        self.assertNotIn(self.user, self.compensation.shared_users)
-        self.compensation.share_with_user(self.user)
-        self.assertIn(self.user, self.compensation.shared_users)
-
-    def test_share_with_user_list(self):
-        user_list = [
-            self.user
-        ]
-        self.assertNotIn(self.user, self.compensation.shared_users)
-        self.compensation.share_with_user_list(user_list)
-        self.assertIn(self.user, self.compensation.shared_users)
-        user_list = [
-            self.superuser
-        ]
-        self.assertNotIn(self.superuser, self.compensation.shared_users)
-        self.compensation.share_with_user_list(user_list)
-        self.assertIn(self.superuser, self.compensation.shared_users)
-        self.assertNotIn(self.user, self.compensation.shared_users)
-
-    def test_share_with_team(self):
-        self.assertNotIn(self.team, self.compensation.shared_teams)
-        self.compensation.share_with_team(self.team)
-        self.assertIn(self.team, self.compensation.shared_teams)
-
-    def test_share_with_team_list(self):
-        self.compensation.share_with_team(self.team)
-        self.assertIn(self.team, self.compensation.shared_teams)
-        other_team = Team.objects.create(
-            name="NewTeam"
-        )
-        team_list = [
-            other_team
-        ]
-        self.compensation.share_with_team_list(team_list)
-        self.assertIn(other_team, self.compensation.shared_teams)
-        self.assertNotIn(self.team, self.compensation.shared_teams)
-
-    def test_shared_users(self):
-        intervention = self.compensation.intervention
-        diff = self.compensation.shared_users.difference(intervention.shared_users)
-        self.assertEqual(diff.count(), 0)
-
-        self.compensation.share_with_user(self.superuser)
-        diff = self.compensation.shared_users.difference(intervention.shared_users)
-        self.assertEqual(diff.count(), 0)
-
-    def test_shared_teams(self):
-        intervention = self.compensation.intervention
-        diff = self.compensation.shared_users.difference(intervention.shared_users)
-        self.assertEqual(diff.count(), 0)
-
-        self.compensation.share_with_user(self.superuser)
-        diff = self.compensation.shared_users.difference(intervention.shared_users)
-        self.assertEqual(diff.count(), 0)
-
-    def test_get_documents(self):
-        doc = self.create_dummy_document(CompensationDocument, self.compensation)
-        docs = self.compensation.get_documents()
-        self.assertIn(doc, docs)
-
-    def test_mark_as_deleted(self):
-        self.assertIsNone(self.compensation.deleted)
-        self.compensation.mark_as_deleted(self.superuser, send_mail=False)
-
-        comp_deleted = self.compensation.deleted
-        self.assertIsNotNone(comp_deleted)
-        self.assertEqual(comp_deleted.action, UserAction.DELETED)
-        self.assertEqual(comp_deleted.user, self.superuser)
-        self.assertEqual(comp_deleted.comment, None)
-
-        intervention_last_log = self.compensation.intervention.log.first()
-        self.assertEqual(intervention_last_log.action, UserAction.EDITED)
-        self.assertEqual(intervention_last_log.user, self.superuser)
-        self.assertEqual(
-            intervention_last_log.comment,
-            COMPENSATION_REMOVED_TEMPLATE.format(
-                self.compensation.identifier
-            )
-        )
-
-
-class CompensationDocumentTestCase(BaseTestCase):
-    def setUp(self) -> None:
-        super().setUp()
-        self.doc = self.create_dummy_document(CompensationDocument, self.compensation)
-
-    def test_delete(self):
-        doc_title = self.doc.title
-        self.assertIn(self.doc, self.compensation.get_documents())
-        self.doc.delete(self.superuser)
-        self.assertNotIn(self.doc, self.compensation.get_documents())
-        try:
-            self.doc.refresh_from_db()
-            self.fail("Document should not be fetchable anymore")
-        except ObjectDoesNotExist:
-            pass
-        last_log = self.compensation.log.first()
-        self.assertEqual(last_log.user, self.superuser)
-        self.assertEqual(last_log.action, UserAction.EDITED)
-        self.assertEqual(last_log.comment, DOCUMENT_REMOVED_TEMPLATE.format(doc_title))

compensation/tests/ecoaccount/unit/__init__.py

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

compensation/tests/ecoaccount/unit/test_models.py

@@ -1,128 +0,0 @@
-"""
-Author: Michel Peltriaux
-Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
-Contact: ksp-servicestelle@sgdnord.rlp.de
-Created on: 30.08.23
-
-"""
-from django.core.exceptions import ObjectDoesNotExist
-from django.urls import reverse
-
-from compensation.models import EcoAccountDocument
-from konova.tests.test_views import BaseTestCase
-from konova.utils.message_templates import DOCUMENT_REMOVED_TEMPLATE, DEDUCTION_REMOVED
-from user.models import UserAction
-
-
-class EcoAccountTestCase(BaseTestCase):
-
-    def setUp(self) -> None:
-        super().setUp()
-
-    def test_str(self):
-        self.assertEqual(str(self.eco_account), f"{self.eco_account.identifier} ({self.eco_account.title})")
-
-    def test_save(self):
-        old_id = self.eco_account.identifier
-        self.assertIsNotNone(self.eco_account.identifier)
-        self.eco_account.identifier = None
-        self.eco_account.save()
-        self.assertIsNotNone(self.eco_account.identifier)
-        self.assertNotEqual(old_id, self.eco_account.identifier)
-
-    def test_property_deductions_surface_sum(self):
-        self.assertEqual(
-            self.eco_account.deductions_surface_sum,
-            self.eco_account.get_deductions_surface()
-        )
-
-    def test_get_documents(self):
-        docs = self.eco_account.get_documents()
-        self.assertEqual(docs.count(), 0)
-        doc = self.create_dummy_document(EcoAccountDocument, self.eco_account)
-        self.assertIn(doc, self.eco_account.get_documents())
-
-    def test_get_share_link(self):
-        self.assertEqual(
-            self.eco_account.get_share_link(),
-            reverse(
-                "compensation:acc:share-token",
-                args=(self.eco_account.id, self.eco_account.access_token)
-            )
-        )
-
-    def test_get_deductable_rest_relative(self):
-        self.assertEqual(self.eco_account.deductions.count(), 0)
-        self.eco_account.deductable_surface = 5.0
-        self.eco_account.save()
-        self.eco_account.update_deductable_rest()
-
-        self.assertEqual(self.eco_account.get_deductable_rest_relative(), 100)
-        self.eco_account.deductable_surface = None
-        self.eco_account.save()
-        self.assertEqual(self.eco_account.get_deductable_rest_relative(), 0)
-
-
-class EcoAccountDocumentTestCase(BaseTestCase):
-    def setUp(self) -> None:
-        super().setUp()
-
-    def test_delete(self):
-        doc = self.create_dummy_document(
-            EcoAccountDocument,
-            self.eco_account
-        )
-        doc_title = doc.title
-        docs = self.eco_account.get_documents()
-        self.assertIn(doc, docs)
-
-        doc.delete(user=self.superuser)
-        last_log = self.eco_account.log.first()
-        self.assertEqual(last_log.user, self.superuser)
-        self.assertEqual(last_log.action, UserAction.EDITED)
-        self.assertEqual(last_log.comment, DOCUMENT_REMOVED_TEMPLATE.format(
-            doc_title
-        ))
-        try:
-            doc.refresh_from_db()
-            self.fail("Document should not have been fetchable")
-        except ObjectDoesNotExist:
-            pass
-
-
-class EcoAccountDeductionTestCase(BaseTestCase):
-    def setUp(self) -> None:
-        super().setUp()
-
-    def test_str(self):
-        self.assertEqual(str(self.deduction), f"{self.deduction.surface} of {self.deduction.account}")
-
-    def test_delete(self):
-        self.deduction.account = self.eco_account
-        self.deduction.intervention = self.intervention
-        self.deduction.save()
-
-        self.eco_account.update_deductable_rest()
-        old_deductable_rest = self.eco_account.deductable_rest
-        deduction_surface = self.deduction.surface
-
-        self.deduction.delete(self.superuser)
-
-        last_log_intervention = self.intervention.log.first()
-        last_log_account = self.eco_account.log.first()
-        logs = [
-            last_log_intervention,
-            last_log_account,
-        ]
-        for log in logs:
-            self.assertEqual(log.action, UserAction.EDITED)
-            self.assertEqual(log.user, self.superuser)
-            self.assertEqual(log.comment, DEDUCTION_REMOVED)
-
-        self.assertLess(old_deductable_rest, self.eco_account.deductable_rest)
-        self.assertEqual(old_deductable_rest + deduction_surface, self.eco_account.deductable_rest)
-        try:
-            self.deduction.refresh_from_db()
-            self.fail("Deduction still fetchable after deleting")
-        except ObjectDoesNotExist:
-            pass

compensation/utils/quality.py

@@ -95,7 +95,7 @@ class EcoAccountQualityChecker(CompensationQualityChecker):
         is_surface_invalid = surface == 0
         if is_surface_invalid:
             self._add_missing_attr_name(_("Available Surface"))
-        after_state_surface = self.obj.get_surface_after_states()
+        after_state_surface = self.obj.get_state_after_surface_sum()
         if surface > after_state_surface:
             self.messages.append(
                 _("Deductable surface can not be larger than state surface")

compensation/views/compensation/compensation.py

@@ -228,6 +228,8 @@ def detail_view(request: HttpRequest, id: str):
     _user = request.user
     is_data_shared = comp.intervention.is_shared_with(_user)
 
+
+
     # Order states according to surface
     before_states = comp.before_states.all().prefetch_related("biotope_type").order_by("-surface")
     after_states = comp.after_states.all().prefetch_related("biotope_type").order_by("-surface")
@@ -235,8 +237,8 @@ def detail_view(request: HttpRequest, id: str):
 
     # Precalculate logical errors between before- and after-states
     # Sum() returns None in case of no states, so we catch that and replace it with 0 for easier handling
-    sum_before_states = comp.get_surface_before_states()
-    sum_after_states = comp.get_surface_after_states()
+    sum_before_states = before_states.aggregate(Sum("surface"))["surface__sum"] or 0
+    sum_after_states = after_states.aggregate(Sum("surface"))["surface__sum"] or 0
     diff_states = abs(sum_before_states - sum_after_states)
 
     request = comp.set_status_messages(request)

compensation/views/eco_account/eco_account.py

@@ -150,9 +150,7 @@ def edit_view(request: HttpRequest, id: str):
     data_form = EditEcoAccountForm(request.POST or None, instance=acc)
     geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=acc)
     if request.method == "POST":
-        data_form_valid = data_form.is_valid()
-        geom_form_valid = geom_form.is_valid()
-        if data_form_valid and geom_form_valid:
+        if data_form.is_valid() and geom_form.is_valid():
             # The data form takes the geom form for processing, as well as the performing user
             acc = data_form.save(request.user, geom_form)
             messages.success(request, _("Eco-Account {} edited").format(acc.identifier))
@@ -210,8 +208,8 @@ def detail_view(request: HttpRequest, id: str):
 
     # Precalculate logical errors between before- and after-states
     # Sum() returns None in case of no states, so we catch that and replace it with 0 for easier handling
-    sum_before_states = acc.get_surface_before_states()
-    sum_after_states = acc.get_surface_after_states()
+    sum_before_states = before_states.aggregate(Sum("surface"))["surface__sum"] or 0
+    sum_after_states = after_states.aggregate(Sum("surface"))["surface__sum"] or 0
     diff_states = abs(sum_before_states - sum_after_states)
     # Calculate rest of available surface for deductions
     available_total = acc.deductable_rest

ema/views/ema.py

@@ -149,8 +149,8 @@ def detail_view(request: HttpRequest, id: str):
 
     # Precalculate logical errors between before- and after-states
     # Sum() returns None in case of no states, so we catch that and replace it with 0 for easier handling
-    sum_before_states = ema.get_surface_before_states()
-    sum_after_states = ema.get_surface_after_states()
+    sum_before_states = before_states.aggregate(Sum("surface"))["surface__sum"] or 0
+    sum_after_states = after_states.aggregate(Sum("surface"))["surface__sum"] or 0
     diff_states = abs(sum_before_states - sum_after_states)
 
     ema.set_status_messages(request)

intervention/models/intervention.py

@@ -419,11 +419,8 @@ class InterventionDocument(AbstractDocument):
             # The only file left for this intervention is the one which is currently processed and will be deleted
             # Make sure that the intervention folder itself is deleted as well, not only the file
             # Therefore take the folder path from the file path
-            try:
-                folder_path = self.file.path.split("/")[:-1]
-                folder_path = "/".join(folder_path)
-            except ValueError:
-                folder_path = None
+            folder_path = self.file.path.split("/")[:-1]
+            folder_path = "/".join(folder_path)
 
         if user:
             self.instance.mark_as_edited(user, edit_comment=DOCUMENT_REMOVED_TEMPLATE.format(self.title))

konova/forms/geometry_form.py

@@ -8,10 +8,10 @@ Created on: 15.08.22
 import json
 
 from django.contrib.gis import gdal
+from django.contrib.gis.forms import MultiPolygonField
 from django.contrib.gis.geos import MultiPolygon, Polygon
 from django.contrib.gis.geos.prototypes.io import WKTWriter
 from django.utils.translation import gettext_lazy as _
-from django.forms import JSONField
 
 from konova.forms.base_form import BaseForm
 from konova.models import Geometry
@@ -27,7 +27,8 @@ class SimpleGeomForm(BaseForm):
     """
     read_only = True
     geometry_simplified = False
-    geom = JSONField(
+    geom = MultiPolygonField(
+        srid=DEFAULT_SRID_RLP,
         label=_("Geometry"),
         help_text=_(""),
         label_suffix="",

konova/tests/test_views.py

@@ -453,7 +453,7 @@ class BaseTestCase(TestCase):
         eco_account.actions.add(self.comp_action)
         eco_account.geometry.geom = self.create_dummy_geometry()
         eco_account.geometry.save()
-        eco_account.deductable_surface = eco_account.get_surface_after_states()
+        eco_account.deductable_surface = eco_account.get_state_after_surface_sum()
         eco_account.deadlines.add(self.finished_deadline)
         eco_account.save()
         return eco_account

konova/tests/unit/__init__.py

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

konova/tests/unit/test_deadline.py

@@ -1,118 +0,0 @@
-"""
-Author: Michel Peltriaux
-Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
-Contact: ksp-servicestelle@sgdnord.rlp.de
-Created on: 29.08.23
-
-"""
-from django.test import RequestFactory
-from django.utils.timezone import now
-from django.utils.translation import gettext_lazy as _
-
-from compensation.forms.modals.deadline import NewDeadlineModalForm, EditDeadlineModalForm
-from konova.models import DeadlineType
-from konova.tests.test_views import BaseTestCase
-from konova.utils.generators import generate_random_string
-from konova.utils.message_templates import DEADLINE_ADDED, DEADLINE_EDITED
-from user.models import UserAction
-
-
-class NewDeadlineModalFormTestCase(BaseTestCase):
-    def setUp(self) -> None:
-        super().setUp()
-        self.request = RequestFactory().request()
-        self.request.user = self.superuser
-        self.today = now().date()
-
-    def test_init(self):
-        form = NewDeadlineModalForm(request=self.request, instance=self.compensation)
-        self.assertEqual(form.form_title, str(_("New deadline")))
-        self.assertEqual(form.form_caption, str(_("Insert data for the new deadline")))
-        self.assertEqual(form.user, self.superuser)
-        self.assertEqual(form.request, self.request)
-
-    def test_is_valid(self):
-        data = {
-            "type": DeadlineType.MAINTAIN,
-            "date": self.today,
-            "comment": "",
-        }
-        form = NewDeadlineModalForm(
-            data,
-            request=self.request,
-            instance=self.compensation
-        )
-        self.assertTrue(form.is_valid())
-
-        data["type"] = DeadlineType.OTHER
-        form = NewDeadlineModalForm(
-            data,
-            request=self.request,
-            instance=self.compensation
-        )
-        self.assertFalse(form.is_valid(), msg=form.errors)
-        self.assertTrue(form.has_error("comment"))
-        _error = form.errors["comment"]
-        self.assertEqual(len(_error), 1)
-        self.assertEqual(_error[0], str(_("Please explain this 'other' type of deadline.")))
-
-        data["comment"] = "Test"
-        data["type"] = DeadlineType.OTHER
-        form = NewDeadlineModalForm(
-            data,
-            request=self.request,
-            instance=self.compensation
-        )
-        self.assertTrue(form.is_valid())
-
-    def test_save(self):
-        data = {
-            "type": DeadlineType.MAINTAIN,
-            "date": self.today,
-            "comment": generate_random_string(length=20, use_letters_lc=True),
-        }
-        form = NewDeadlineModalForm(
-            data,
-            request=self.request,
-            instance=self.compensation
-        )
-        self.assertTrue(form.is_valid(), msg=form.errors)
-        deadline = form.save()
-        self.assertEqual(deadline.type, data["type"])
-        self.assertEqual(deadline.date, data["date"])
-        self.assertEqual(deadline.comment, data["comment"])
-        self.assertIn(deadline, self.compensation.deadlines.all())
-
-        last_log = self.compensation.log.first()
-        self.assertEqual(last_log.user, self.superuser)
-        self.assertEqual(last_log.action, UserAction.EDITED)
-        self.assertEqual(last_log.comment, DEADLINE_ADDED)
-
-
-class EditDeadlineModalFormTestCase(NewDeadlineModalFormTestCase):
-    def setUp(self) -> None:
-        super().setUp()
-
-    def test_save(self):
-        data = {
-            "type": DeadlineType.MAINTAIN,
-            "date": self.today,
-            "comment": generate_random_string(length=20, use_letters_lc=True),
-        }
-        form = EditDeadlineModalForm(
-            data,
-            request=self.request,
-            instance=self.compensation,
-            deadline=self.finished_deadline,
-        )
-
-        self.assertTrue(form.is_valid(), msg=form.errors)
-        deadline = form.save()
-        self.assertEqual(deadline.type, data["type"])
-        self.assertEqual(deadline.date, data["date"])
-        self.assertEqual(deadline.comment, data["comment"])
-
-        last_log = self.compensation.log.first()
-        self.assertEqual(last_log.action, UserAction.EDITED)
-        self.assertEqual(last_log.user, self.superuser)
-        self.assertEqual(last_log.comment, DEADLINE_EDITED)

konova/utils/message_templates.py

@@ -79,6 +79,7 @@ DOCUMENT_EDITED = _("Document edited")
 
 # Edited
 EDITED_GENERAL_DATA = _("Edited general data")
+ADDED_DEADLINE = _("Added deadline")
 
 # Geometry
 GEOMETRY_CONFLICT_WITH_TEMPLATE = _("Geometry conflict detected with {}")