#19 Tests

* refactors CheckableMixin and RecordableMixin into CheckableObject and RecordableObject
* adds ShareableObject for wrapping share related fields and functionality
* adds share functionality to EcoAccount and EMA, just like Intervention

intervention/forms/modalForms.py

@@ -68,8 +68,9 @@ class ShareInterventionModalForm(BaseModalForm):
 
         """
         # Initialize share_link field
+        url_name = f"{self.instance._meta.app_label}:share"
         self.share_link = self.request.build_absolute_uri(
-            reverse("intervention:share", args=(self.instance.id, self.instance.access_token,))
+            reverse(url_name, args=(self.instance.id, self.instance.access_token,))
         )
         self.initialize_form_field(
             "url",

intervention/models.py

@@ -17,7 +17,7 @@ from codelist.settings import CODELIST_REGISTRATION_OFFICE_ID, CODELIST_CONSERVA
 from intervention.managers import InterventionManager
 from intervention.utils.quality import InterventionQualityChecker
 from konova.models import BaseObject, Geometry, UuidModel, BaseResource, AbstractDocument, \
-    generate_document_file_upload_path, RecordableMixin, CheckableMixin
+    generate_document_file_upload_path, RecordableObject, CheckableObject, ShareableObject
 from konova.settings import DEFAULT_SRID_RLP, LANIS_LINK_TEMPLATE, LANIS_ZOOM_LUT
 from konova.utils import generators
 from user.models import UserActionLogEntry
@@ -171,7 +171,7 @@ class LegalData(UuidModel):
     revocation = models.OneToOneField(Revocation, null=True, blank=True, help_text="Refers to 'Widerspruch am'", on_delete=models.SET_NULL)
 
 
-class Intervention(BaseObject, RecordableMixin, CheckableMixin):
+class Intervention(BaseObject, ShareableObject, RecordableObject, CheckableObject):
     """
     Interventions are e.g. construction sites where nature used to be.
     """
@@ -191,74 +191,11 @@ class Intervention(BaseObject, RecordableMixin, CheckableMixin):
     )
     geometry = models.ForeignKey(Geometry, null=True, blank=True, on_delete=models.SET_NULL)
 
-    # Checks - Refers to "Genehmigen" but optional
-    checked = models.OneToOneField(
-        UserActionLogEntry,
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        help_text="Holds data on user and timestamp of this action",
-        related_name="+"
-    )
-
-    # Refers to "verzeichnen"
-    recorded = models.OneToOneField(
-        UserActionLogEntry,
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        help_text="Holds data on user and timestamp of this action",
-        related_name="+"
-    )
-
-    # Users having access on this object
-    users = models.ManyToManyField(User, help_text="Users having access (data shared with)")
-    access_token = models.CharField(
-        max_length=255,
-        null=True,
-        blank=True,
-        help_text="Used for sharing access",
-    )
-
     objects = InterventionManager()
 
     def __str__(self):
         return "{} ({})".format(self.identifier, self.title)
 
-    def generate_access_token(self, make_unique: bool = False, rec_depth: int = 5):
-        """ Creates a new access token for the intervention
-
-        Tokens are not used for identification of a table row. The share logic checks the intervention id as well
-        as the given token. Therefore two different interventions can hold the same access_token without problems.
-        For (possible) future changes to the share logic, the make_unique parameter may be used for checking whether
-        the access_token is already used in any intervention. If so, tokens will be generated as long as a free token
-        can be found.
-
-        Args:
-            make_unique (bool): Perform check on uniqueness over all intervention entries
-            rec_depth (int): How many tries for generating a free random token (only if make_unique)
-
-        Returns:
-
-        """
-        # Make sure we won't end up in an infinite loop of trying to generate access_tokens
-        rec_depth = rec_depth - 1
-        if rec_depth < 0 and make_unique:
-            raise RuntimeError(
-                "Access token generating for {} does not seem to find a free random token! Aborted!".format(self.id)
-            )
-
-        # Create random token
-        token = generators.generate_random_string(15, True, True, False)
-        token_used_in = Intervention.objects.filter(access_token=token)
-        # Make sure the token is not used anywhere as access_token, yet.
-        # Make use of QuerySet lazy method for checking if it exists or not.
-        if token_used_in and make_unique:
-            self.generate_access_token(make_unique, rec_depth)
-        else:
-            self.access_token = token
-            self.save()
-
     def save(self, *args, **kwargs):
         """ Custom save functionality