refactor: Landscape membership list

terraso_backend/apps/collaboration/graphql/memberships.py

@@ -53,6 +53,7 @@ class Meta:
         fields = (
             "memberships",
             "membership_type",
+            "enroll_method",
         )
         interfaces = (relay.Node,)
         connection_class = TerrasoConnection
@@ -61,9 +62,15 @@ def resolve_account_membership(self, info):
         user = info.context.user
         if user.is_anonymous:
             return None
+        if hasattr(self, "account_memberships"):
+            if len(self.account_memberships):
+                return self.account_memberships[0]
+            return None
         return self.memberships.filter(user=user).first()
 
     def resolve_memberships_count(self, info):
+        if hasattr(self, "memberships_count"):
+            return self.memberships_count
         user = info.context.user
         if user.is_anonymous:
             return 0

terraso_backend/apps/collaboration/models/memberships.py

@@ -54,8 +54,16 @@ class MembershipList(BaseModel):
         default=DEFAULT_MEMERBSHIP_TYPE,
     )
 
+    def default_validation_func(self):
+        return False
+
     def save_membership(
-        self, user_email, user_role, membership_status, validation_func, membership_class=None
+        self,
+        user_email,
+        user_role,
+        membership_status,
+        validation_func=default_validation_func,
+        membership_class=None,
     ):
         membership_class = membership_class or Membership
         user = User.objects.filter(email__iexact=user_email).first()
@@ -71,6 +79,8 @@ def save_membership(
                 "user_role": user_role,
                 "membership_status": membership_status,
                 "current_membership": membership,
+                "user_exists": user_exists,
+                "user_email": user_email,
             }
         ):
             raise ValidationError("User cannot request membership")
@@ -119,7 +129,7 @@ def approved_members(self):
         return User.objects.filter(id__in=approved_memberships_user_ids)
 
     def has_role(self, user: User, role: str) -> bool:
-        return self.memberships.by_role(role).filter(id=user.id).exists()
+        return self.memberships.by_role(role).filter(user=user).exists()
 
     def is_approved_member(self, user: User) -> bool:
         return self.approved_members.filter(id=user.id).exists()

terraso_backend/apps/core/admin.py

@@ -14,8 +14,6 @@
 # along with this program. If not, see https://www.gnu.org/licenses/.
 
 from django.contrib import admin
-from django.urls import reverse
-from django.utils.safestring import mark_safe
 
 from .models import (
     Group,
@@ -52,38 +50,14 @@ def get_queryset(self, request):
 @admin.register(Landscape)
 class LandscapeAdmin(admin.ModelAdmin):
     list_display = ("name", "slug", "location", "website", "created_at")
-
-    readonly_fields = ("default_group",)
-
-    def default_group(self, obj):
-        group = obj.get_default_group()
-        url = reverse("admin:core_landscapedefaultgroup_change", args=[group.pk])
-        return mark_safe(f'<a href="{url}">{group}</a>')
-
-    default_group.short_description = "Default Group"
+    raw_id_fields = ("membership_list",)
 
 
 class LandscapeDefaultGroup(Group):
     class Meta:
         proxy = True
 
 
-@admin.register(LandscapeDefaultGroup)
-class LandscapeDefaultGroupAdmin(admin.ModelAdmin):
-    list_display = ("name", "slug", "website", "created_at")
-    inlines = [MembershipInline]
-
-    def get_queryset(self, request):
-        qs = super().get_queryset(request)
-        landscape_group_ids = [
-            values[0]
-            for values in LandscapeGroup.objects.filter(
-                is_default_landscape_group=True
-            ).values_list("group__id")
-        ]
-        return qs.filter(id__in=landscape_group_ids)
-
-
 @admin.register(LandscapeGroup)
 class LandscapeGroupAdmin(admin.ModelAdmin):
     list_display = ("landscape", "group")

terraso_backend/apps/core/landscape_collaboration_roles.py

@@ -0,0 +1,20 @@
+# Copyright © 2023 Technology Matters
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see https://www.gnu.org/licenses/.
+
+
+ROLE_MANAGER = "manager"
+ROLE_MEMBER = "member"
+
+ALL_ROLES = [ROLE_MANAGER, ROLE_MEMBER]

terraso_backend/apps/core/management/commands/loadsampledata.py

@@ -13,6 +13,7 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see https://www.gnu.org/licenses/.
 
+from apps.collaboration.models import MembershipList
 from apps.core.models import Group, Landscape, LandscapeGroup
 
 from ._base_airtable import BaseAirtableCommand
@@ -47,13 +48,8 @@ def handle(self, *args, **kwargs):
                 name=landscape_name, defaults=model_data
             )
 
-            # Creates Landscape default group
-            default_group, _ = Group.objects.update_or_create(name=f"{landscape_name} Group")
-            landscape_group, _ = LandscapeGroup.objects.update_or_create(
-                landscape=landscape,
-                group=default_group,
-                defaults={"is_default_landscape_group": True},
-            )
+            # Creates Landscape membership list
+            membership_list, _ = MembershipList.objects.update_or_create(landscape=landscape)
 
             # Creates Partnership group
             partnership_name = landscape_data.get("Landscape Partnership Name")

terraso_backend/apps/core/migrations/0047_landscape_membership_list.py

@@ -0,0 +1,71 @@
+# Copyright © 2023 Technology Matters
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see https://www.gnu.org/licenses/.
+
+# Generated by Django 4.2.6 on 2023-10-10 20:45
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+import apps.core.models.commons
+
+
+def copy_memberships(apps, schema_editor):
+    Landscape = apps.get_model("core", "Landscape")
+    MembershipList = apps.get_model("collaboration", "MembershipList")
+    Membership = apps.get_model("collaboration", "Membership")
+    landscapes = Landscape.objects.all()
+    for landscape in landscapes:
+        if not landscape.membership_list:
+            landscape.membership_list = MembershipList.objects.create(
+                enroll_method="both",
+                membership_type="open",
+            )
+            landscape.save()
+        default_group = landscape.associated_groups.filter(is_default_landscape_group=True).first()
+        if not default_group:
+            print(f"no default group for landscape {landscape.name}")
+            continue
+        current_memberships = default_group.group.memberships.filter(
+            deleted_at__isnull=True
+        ).distinct("user")
+        for membership in current_memberships:
+            Membership.objects.create(
+                membership_list=landscape.membership_list,
+                user=membership.user,
+                user_role=membership.user_role,
+                membership_status=membership.membership_status,
+            )
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("collaboration", "0005_change_collaborator_to_editor"),
+        ("core", "0046_shared_resource"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="landscape",
+            name="membership_list",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="landscape",
+                to="collaboration.membershiplist",
+            ),
+        ),
+        migrations.RunPython(copy_memberships),
+    ]

terraso_backend/apps/core/models/landscapes.py

@@ -15,6 +15,7 @@
 
 import structlog
 from dirtyfields import DirtyFieldsMixin
+from django.apps import apps
 from django.contrib.contenttypes.fields import GenericRelation
 from django.db import models, transaction
 
@@ -23,6 +24,7 @@
     calculate_geojson_centroid,
     calculate_geojson_feature_area,
 )
+from apps.core.landscape_collaboration_roles import ROLE_MANAGER
 from apps.core.models.taxonomy_terms import TaxonomyTerm
 
 from .commons import BaseModel, SlugModel, validate_name
@@ -64,6 +66,12 @@ class Landscape(SlugModel, DirtyFieldsMixin):
         related_name="created_landscapes",
     )
     groups = models.ManyToManyField(Group, through="LandscapeGroup")
+    membership_list = models.ForeignKey(
+        "collaboration.MembershipList",
+        on_delete=models.CASCADE,
+        related_name="landscape",
+        null=True,
+    )
 
     area_types = models.JSONField(blank=True, null=True)
     taxonomy_terms = models.ManyToManyField(TaxonomyTerm, blank=True)
@@ -101,6 +109,9 @@ class Meta(SlugModel.Meta):
         _unique_fields = ["name"]
         abstract = False
 
+    def full_clean(self, *args, **kwargs):
+        super().full_clean(*args, **kwargs, exclude=["membership_list"])
+
     def save(self, *args, **kwargs):
         dirty_fields = self.get_dirty_fields()
         if self.area_polygon and "area_polygon" in dirty_fields:
@@ -110,52 +121,31 @@ def save(self, *args, **kwargs):
             self.center_coordinates = calculate_geojson_centroid(self.area_polygon)
 
         with transaction.atomic():
+            MembershipList = apps.get_model("collaboration", "MembershipList")
+            Membership = apps.get_model("collaboration", "Membership")
             creating = not Landscape.objects.filter(pk=self.pk).exists()
 
-            super().save(*args, **kwargs)
-
             if creating and self.created_by:
-                group = Group(
-                    name="Group {}".format(self.slug),
-                    description="",
-                    created_by=self.created_by,
+                self.membership_list = MembershipList.objects.create(
+                    enroll_method=MembershipList.ENROLL_METHOD_BOTH,
+                    membership_type=MembershipList.MEMBERSHIP_TYPE_OPEN,
                 )
-                group.save()
-                landscape_group = LandscapeGroup(
-                    group=group, landscape=self, is_default_landscape_group=True
+                self.membership_list.save_membership(
+                    self.created_by.email, ROLE_MANAGER, Membership.APPROVED
                 )
-                landscape_group.save()
+
+            super().save(*args, **kwargs)
 
     def delete(self, *args, **kwargs):
-        default_group = self.get_default_group()
+        membership_list = self.membership_list
 
         with transaction.atomic():
             ret = super().delete(*args, **kwargs)
-            # default group should be deleted as well
-            if default_group is not None:
-                default_group.delete()
+            if membership_list is not None:
+                membership_list.delete()
 
         return ret
 
-    def get_default_group(self):
-        """
-        A default Group in a Landscape is that Group where any
-        individual (associated or not with other Groups) is added when
-        associating directly with a Landscape.
-        """
-        try:
-            # associated_groups is the related_name defined on
-            # LandscapeGroup relationship with Landscape. It returns a
-            # queryset of LandscapeGroup
-            landscape_group = self.associated_groups.get(is_default_landscape_group=True)
-        except LandscapeGroup.DoesNotExist:
-            logger.error(
-                "Landscape has no default group, but it must have", extra={"landscape_id": self.pk}
-            )
-            return None
-
-        return landscape_group.group
-
     def __str__(self):
         return self.name
 

terraso_backend/apps/core/models/users.py

@@ -21,6 +21,8 @@
 from django.utils.translation import gettext_lazy as _
 from safedelete.models import SOFT_DELETE_CASCADE, SafeDeleteManager, SafeDeleteModel
 
+from apps.core import landscape_collaboration_roles
+
 NOTIFICATION_KEY_GROUP = "group_notifications"
 NOTIFICATION_KEY_STORY_MAP = "story_map_notifications"
 NOTIFICATION_KEY_LANGUAGE = "language"
@@ -99,10 +101,9 @@ def save(self, *args, **kwargs):
 
     def is_landscape_manager(self, landscape_id):
         return (
-            self.memberships.managers_only()
+            self.collaboration_memberships.by_role(landscape_collaboration_roles.ROLE_MANAGER)
             .filter(
-                group__associated_landscapes__is_default_landscape_group=True,
-                group__associated_landscapes__landscape__pk=landscape_id,
+                membership_list__landscape__pk=landscape_id,
             )
             .exists()
         )