Decouple app collaboration from visibility

Author: ajhai

apps/apis.py

@@ -111,8 +111,9 @@ def get(self, request, uid=None):
             app = get_object_or_404(
                 App,
                 Q(uuid=uuid.UUID(uid), owner=request.user) |
-                Q(uuid=uuid.UUID(uid), accessible_by__contains=[
-                  request.user.email], visibility=AppVisibility.PRIVATE, is_published=True),
+                Q(uuid=uuid.UUID(uid), read_accessible_by__contains=[
+                  request.user.email], is_published=True) | Q(uuid=uuid.UUID(uid), write_accessible_by__contains=[
+                      request.user.email], is_published=True),
             )
             serializer = AppSerializer(
                 instance=app, fields=fields, request_user=request.user,
@@ -131,9 +132,8 @@ def getShared(self, request):
             fields = fields.split(',')
 
         queryset = App.objects.all().filter(
-            accessible_by__contains=[
-                request.user.email,
-            ], visibility=AppVisibility.PRIVATE, is_published=True,
+            Q(read_accessible_by__contains=[request.user.email,]) |
+            Q(write_accessible_by__contains=[request.user.email,]), is_published=True,
         ).order_by('-last_updated_at')
         serializer = AppSerializer(
             queryset, many=True, fields=fields, request_user=request.user,
@@ -149,8 +149,8 @@ def versions(self, request, uid=None, version=None):
         app = get_object_or_404(
             App,
             Q(uuid=uuid.UUID(uid), owner=request.user) |
-            Q(uuid=uuid.UUID(uid), accessible_by__contains=[
-                request.user.email], visibility=AppVisibility.PRIVATE, is_published=True),
+            Q(uuid=uuid.UUID(uid), write_accessible_by__contains=[
+                request.user.email], is_published=True),
         )
 
         if version:
@@ -182,8 +182,8 @@ def getByPublishedUUID(self, request, published_uuid):
                     (app.visibility == AppVisibility.PUBLIC or app.visibility == AppVisibility.UNLISTED) or \
                 (
                         request.user.is_authenticated and ((app.visibility == AppVisibility.ORGANIZATION and Profile.objects.get(user=app.owner).organization == Profile.objects.get(user=request.user).organization) or
-                                                           (app.visibility == AppVisibility.PRIVATE and request.user.email in app.accessible_by))
-                ):
+                                                           (request.user.email in app.read_accessible_by or request.user.email in app.write_accessible_by))
+                    ):
                 serializer = AppSerializer(
                     instance=app, request_user=request.user,
                 )
@@ -279,40 +279,52 @@ def publish(self, request, uid):
                 app.visibility = AppVisibility.ORGANIZATION
             elif request.data['visibility'] == 0 and (flag_enabled('CAN_PUBLISH_PRIVATE_APPS', request=request) or app.visibility == AppVisibility.PRIVATE):
                 app.visibility = AppVisibility.PRIVATE
-                if 'accessible_by' in request.data:
-                    # Filter out invalid email addresses from accessible_by
-                    valid_emails = []
-                    for email in request.data['accessible_by']:
-                        try:
-                            validate_email(email)
-                            valid_emails.append(email)
-                        except ValidationError:
-                            pass
-
-                    # Only allow a maximum of 20 users to be shared with. Trim the list if it is more than 20
-                    if len(valid_emails) > 20:
-                        valid_emails = valid_emails[:20]
-
-                    new_emails = list(
-                        set(valid_emails) -
-                        set(app.accessible_by),
-                    )
-                    app.accessible_by = valid_emails
-                    app.access_permission = request.data[
-                        'access_permission'
-                    ] if 'access_permission' in request.data else AppAccessPermission.READ
-
-                    # Send email to new users
-                    # TODO: Use multisend to send emails in bulk
-                    for new_email in new_emails:
-                        email_template_cls = EmailTemplateFactory.get_template_by_name(
-                            'app_shared'
-                        )
-                        share_email = email_template_cls(
-                            uuid=app.uuid, published_uuid=app.published_uuid, app_name=app.name, owner_first_name=app.owner.first_name, owner_email=app.owner.email, can_edit=app.access_permission == AppAccessPermission.WRITE, share_to=new_email
-                        )
-                        share_email_sender = EmailSender(share_email)
-                        share_email_sender.send()
+
+        if flag_enabled('CAN_PUBLISH_PRIVATE_APPS', request=request) or app.visibility == AppVisibility.PRIVATE:
+            new_emails = []
+            old_read_accessible_by = app.read_accessible_by or []
+            old_write_accessible_by = app.write_accessible_by or []
+            if 'read_accessible_by' in request.data:
+                # Filter out invalid email addresses from read_accessible_by
+                valid_emails = []
+                for email in request.data['read_accessible_by']:
+                    try:
+                        validate_email(email)
+                        valid_emails.append(email)
+                    except ValidationError:
+                        pass
+
+                app.read_accessible_by = valid_emails[:20]
+
+            if 'write_accessible_by' in request.data:
+                # Filter out invalid email addresses from write_accessible_by
+                valid_emails = []
+                for email in request.data['write_accessible_by']:
+                    try:
+                        validate_email(email)
+                        valid_emails.append(email)
+                    except ValidationError:
+                        pass
+
+                app.write_accessible_by = valid_emails[:20]
+
+            new_emails = list(
+                set(app.read_accessible_by).union(set(app.write_accessible_by)) -
+                set(old_read_accessible_by).union(
+                    set(old_write_accessible_by)),
+            )
+
+            # Send email to new users
+            # TODO: Use multisend to send emails in bulk
+            for new_email in new_emails:
+                email_template_cls = EmailTemplateFactory.get_template_by_name(
+                    'app_shared'
+                )
+                share_email = email_template_cls(
+                    uuid=app.uuid, published_uuid=app.published_uuid, app_name=app.name, owner_first_name=app.owner.first_name, owner_email=app.owner.email, can_edit=app.access_permission == AppAccessPermission.WRITE, share_to=new_email
+                )
+                share_email_sender = EmailSender(share_email)
+                share_email_sender.send()
 
         app_newly_published = not app.is_published
         app.is_published = True
@@ -379,9 +391,8 @@ def patch(self, request, uid):
         app = get_object_or_404(App, uuid=uuid.UUID(uid))
         app_owner_profile = get_object_or_404(Profile, user=app.owner)
         if app.owner != request.user and not (
-            app.visibility == AppVisibility.PRIVATE
-            and app.access_permission == AppAccessPermission.WRITE
-            and request.user.email in app.accessible_by
+            app.is_published == True
+            and request.user.email in app.write_accessible_by
         ):
             return DRFResponse(status=403)
 

apps/handlers/app_runnner.py

@@ -109,7 +109,7 @@ def _is_app_accessible(self):
         if self.app.visibility == AppVisibility.ORGANIZATION and self.app_owner_profile.organization != Profile.objects.get(user=self.app_run_request_user).organization:
             raise Exception('App not found')
 
-        if self.app.visibility == AppVisibility.PRIVATE and self.app_run_request_user != self.app.owner and self.app_run_request_user.email not in self.app.accessible_by:
+        if self.app.visibility == AppVisibility.PRIVATE and self.app_run_request_user != self.app.owner and self.app_run_request_user.email not in self.app.read_accessible_by and self.app_run_request_user.email not in self.app.write_accessible_by:
             raise Exception('App not found')
 
     def _get_processor_actor_configs(self):

apps/migrations/0006_app_read_accessible_by_app_write_accessible_by.py

@@ -0,0 +1,24 @@
+# Generated by Django 4.2.1 on 2023-09-07 03:18
+
+import django.contrib.postgres.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('apps', '0005_appdata_version'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='app',
+            name='read_accessible_by',
+            field=django.contrib.postgres.fields.ArrayField(base_field=models.CharField(max_length=320), blank=True, default=list, help_text='List of user emails or domains who can access the app', size=None),
+        ),
+        migrations.AddField(
+            model_name='app',
+            name='write_accessible_by',
+            field=django.contrib.postgres.fields.ArrayField(base_field=models.CharField(max_length=320), blank=True, default=list, help_text='List of user emails or domains who can modify the app', size=None),
+        ),
+    ]

apps/migrations/0007_migrate_access_permissions.py

@@ -0,0 +1,27 @@
+# Generated by Django 4.2.1 on 2023-09-07 06:57
+
+from django.db import migrations
+
+from apps.models import AppAccessPermission
+
+
+class Migration(migrations.Migration):
+
+    def create_permissions_from_accessible_by(apps, schema_editor):
+        App = apps.get_model('apps', 'App')
+        for app in App.objects.all():
+            if app.accessible_by and len(app.accessible_by) > 0:
+                if app.access_permission == AppAccessPermission.READ and not app.read_accessible_by:
+                    app.read_accessible_by = app.accessible_by
+                elif app.access_permission == AppAccessPermission.WRITE and not app.write_accessible_by:
+                    app.write_accessible_by = app.accessible_by
+                app.save()
+
+    dependencies = [
+        ('apps', '0006_app_read_accessible_by_app_write_accessible_by'),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            create_permissions_from_accessible_by, migrations.RunPython.noop),
+    ]

apps/models.py

@@ -187,6 +187,12 @@ class App(models.Model):
     accessible_by = ArrayField(
         models.CharField(max_length=320), default=list, help_text='List of user emails or domains who can access the app', blank=True,
     )
+    read_accessible_by = ArrayField(
+        models.CharField(max_length=320), default=list, help_text='List of user emails or domains who can access the app', blank=True,
+    )
+    write_accessible_by = ArrayField(
+        models.CharField(max_length=320), default=list, help_text='List of user emails or domains who can modify the app', blank=True,
+    )
     access_permission = models.PositiveSmallIntegerField(
         default=AppAccessPermission.READ, choices=AppAccessPermission.choices, help_text='Permission for users who can access the app',
     )
@@ -235,7 +241,7 @@ def has_write_permission(self, user):
         if not user or not user.is_authenticated:
             return False
 
-        return self.owner == user or (self.access_permission == AppAccessPermission.WRITE and user.email in self.accessible_by)
+        return self.owner == user or (self.is_published == True and user.email in self.write_accessible_by)
 
     def __str__(self) -> str:
         return self.name + ' - ' + self.owner.username

apps/serializers.py

@@ -109,6 +109,8 @@ class Meta:
     web_config = serializers.SerializerMethodField()
     access_permission = serializers.SerializerMethodField()
     accessible_by = serializers.SerializerMethodField()
+    read_accessible_by = serializers.SerializerMethodField()
+    write_accessible_by = serializers.SerializerMethodField()
     last_modified_by_email = serializers.SerializerMethodField()
     template = serializers.SerializerMethodField()
     visibility = serializers.SerializerMethodField()
@@ -202,6 +204,12 @@ def get_access_permission(self, obj):
     def get_accessible_by(self, obj):
         return obj.accessible_by if obj.has_write_permission(self._request_user) else None
 
+    def get_read_accessible_by(self, obj):
+        return obj.read_accessible_by if obj.has_write_permission(self._request_user) else None
+
+    def get_write_accessible_by(self, obj):
+        return obj.write_accessible_by if obj.has_write_permission(self._request_user) else None
+
     def get_last_modified_by_email(self, obj):
         return obj.last_modified_by.email if (obj.last_modified_by and obj.has_write_permission(self._request_user)) else None
 
@@ -229,6 +237,7 @@ class Meta:
             'logo', 'is_shareable', 'has_footer', 'domain', 'visibility', 'accessible_by',
             'access_permission', 'last_modified_by_email', 'owner_email', 'web_config',
             'slack_config', 'discord_config', 'app_type_name', 'processors', 'template',
+            'read_accessible_by', 'write_accessible_by'
         ]