fix: event tracking

.deepsource.toml

@@ -1,11 +1,5 @@
 version = 1
 
-exclude_patterns = [  
-  "bin/**",  
-  "**/node_modules/",  
-  "**/*.min.js"  
-]
-
 [[analyzers]]
 name = "shell"
 

apiserver/.env.example

@@ -38,8 +38,7 @@ GPT_ENGINE="gpt-3.5-turbo" # deprecated
 GITHUB_CLIENT_SECRET="" # For fetching release notes
 
 # Settings related to Docker
-DOCKERIZED=1 # deprecated
-
+DOCKERIZED=1
 # set to 1 If using the pre-configured minio setup
 USE_MINIO=1
 

apiserver/bin/takeoff

@@ -15,6 +15,6 @@ if [ "$ENABLE_REGISTRATION" != "0" ]; then
 fi
 
 # Create the default bucket
-python manage.py create_bucket
+python bin/bucket_script.py
 
 exec gunicorn -w $GUNICORN_WORKERS -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:8000 --max-requests 1200 --max-requests-jitter 1000 --access-logfile -

apiserver/plane/analytics/urls.py

@@ -0,0 +1,8 @@
+# from django.contrib import admin
+from django.urls import path
+
+from plane.analytics.views import EventTrackingEndpoint
+
+urlpatterns = [
+    path('track-event/', EventTrackingEndpoint.as_view(), name='event_tracking'),
+]

apiserver/plane/analytics/views/__init__.py

@@ -0,0 +1 @@
+from .event_tacking import EventTrackingEndpoint

apiserver/plane/analytics/views/event_tacking.py

@@ -0,0 +1,52 @@
+# Python imports
+import requests
+import json
+
+# Module imports
+from plane.app.views import BaseAPIView
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+
+# Django imports
+from django.conf import settings
+from django.core.serializers.json import DjangoJSONEncoder
+
+
+class EventTrackingEndpoint(BaseAPIView):
+    permission_class = [
+        IsAuthenticated,
+    ]
+
+    def post(self, request):
+        event_name = request.data.get("event_name", None)
+        extra = request.data.get("extra", None)
+
+        if not event_name or not extra:
+            return Response(
+                {"error": "event name and extra are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        _ = requests.post(
+            settings.ANALYTICS_BASE_API,
+            params={"token": settings.ANALYTICS_SECRET_KEY},
+            json=json.dumps(
+                {
+                    "eventName": event_name,
+                    "extra": extra,
+                    "user": {
+                        "id": str(request.user.id),
+                        "email": str(request.user.email),
+                        "first_name": str(request.user.first_name),
+                        "last_name": str(request.user.last_name),
+                        "last_login_ip": str(request.META.get("REMOTE_ADDR")),
+                        "last_login_uagent": str(request.META.get("HTTP_USER_AGENT"))
+                    },
+                },
+                cls=DjangoJSONEncoder,
+            ),
+        )
+        return Response({"message": "success"}, status=status.HTTP_200_OK)

apiserver/plane/api/middleware/api_authentication.py

@@ -1,47 +0,0 @@
-# Django imports
-from django.utils import timezone
-from django.db.models import Q
-
-# Third party imports
-from rest_framework import authentication
-from rest_framework.exceptions import AuthenticationFailed
-
-# Module imports
-from plane.db.models import APIToken
-
-
-class APIKeyAuthentication(authentication.BaseAuthentication):
-    """
-    Authentication with an API Key
-    """
-
-    www_authenticate_realm = "api"
-    media_type = "application/json"
-    auth_header_name = "X-Api-Key"
-
-    def get_api_token(self, request):
-        return request.headers.get(self.auth_header_name)
-
-    def validate_api_token(self, token):
-        try:
-            api_token = APIToken.objects.get(
-                Q(Q(expired_at__gt=timezone.now()) | Q(expired_at__isnull=True)),
-                token=token,
-                is_active=True,
-            )
-        except APIToken.DoesNotExist:
-            raise AuthenticationFailed("Given API token is not valid")
-
-        # save api token last used
-        api_token.last_used = timezone.now()
-        api_token.save(update_fields=["last_used"])
-        return (api_token.user, api_token.token)
-
-    def authenticate(self, request):
-        token = self.get_api_token(request=request)
-        if not token:
-            return None
-
-        # Validate the API token
-        user, token = self.validate_api_token(token)
-        return user, token

apiserver/plane/api/rate_limit.py

@@ -1,45 +0,0 @@
-from django.utils import timezone
-from rest_framework.throttling import SimpleRateThrottle
-
-
-class ApiKeyRateThrottle(SimpleRateThrottle):
-    scope = 'api_key'
-
-    def get_cache_key(self, request, view):
-        # Retrieve the API key from the request header
-        api_key = request.headers.get('X-Api-Key')
-        if not api_key:
-            return None  # Allow the request if there's no API key
-
-        # Use the API key as part of the cache key
-        return f'{self.scope}:{api_key}'
-
-    def allow_request(self, request, view):
-        # Calculate the current time as a Unix timestamp
-        now = timezone.now().timestamp()
-
-        # Use the parent class's method to check if the request is allowed
-        allowed = super().allow_request(request, view)
-
-        if allowed:
-            # Calculate the remaining limit and reset time
-            history = self.cache.get(self.key, [])
-
-            # Remove old histories
-            while history and history[-1] <= now - self.duration:
-                history.pop()
-            
-            # Calculate the requests
-            num_requests = len(history)
-
-            # Check available requests
-            available = self.num_requests - num_requests
-
-            # Unix timestamp for when the rate limit will reset
-            reset_time = int(now + self.duration)
-
-            # Add headers
-            request.META['X-RateLimit-Remaining'] = max(0, available)
-            request.META['X-RateLimit-Reset'] = reset_time
-
-        return allowed

apiserver/plane/api/serializers/__init__.py

@@ -1,17 +0,0 @@
-from .user import UserLiteSerializer
-from .workspace import WorkspaceLiteSerializer
-from .project import ProjectSerializer, ProjectLiteSerializer
-from .issue import (
-    IssueSerializer,
-    LabelSerializer,
-    IssueLinkSerializer,
-    IssueAttachmentSerializer,
-    IssueCommentSerializer,
-    IssueAttachmentSerializer,
-    IssueActivitySerializer,
-    IssueExpandSerializer,
-)
-from .state import StateLiteSerializer, StateSerializer
-from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
-from .module import ModuleSerializer, ModuleIssueSerializer, ModuleLiteSerializer
-from .inbox import InboxIssueSerializer

apiserver/plane/api/serializers/base.py

@@ -1,105 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-
-class BaseSerializer(serializers.ModelSerializer):
-    id = serializers.PrimaryKeyRelatedField(read_only=True)
-
-    def __init__(self, *args, **kwargs):
-        # If 'fields' is provided in the arguments, remove it and store it separately.
-        # This is done so as not to pass this custom argument up to the superclass.
-        fields = kwargs.pop("fields", [])
-        self.expand = kwargs.pop("expand", []) or []
-
-        # Call the initialization of the superclass.
-        super().__init__(*args, **kwargs)
-
-        # If 'fields' was provided, filter the fields of the serializer accordingly.
-        if fields:
-            self.fields = self._filter_fields(fields=fields)
-
-    def _filter_fields(self, fields):
-        """
-        Adjust the serializer's fields based on the provided 'fields' list.
-
-        :param fields: List or dictionary specifying which fields to include in the serializer.
-        :return: The updated fields for the serializer.
-        """
-        # Check each field_name in the provided fields.
-        for field_name in fields:
-            # If the field is a dictionary (indicating nested fields),
-            # loop through its keys and values.
-            if isinstance(field_name, dict):
-                for key, value in field_name.items():
-                    # If the value of this nested field is a list,
-                    # perform a recursive filter on it.
-                    if isinstance(value, list):
-                        self._filter_fields(self.fields[key], value)
-
-        # Create a list to store allowed fields.
-        allowed = []
-        for item in fields:
-            # If the item is a string, it directly represents a field's name.
-            if isinstance(item, str):
-                allowed.append(item)
-            # If the item is a dictionary, it represents a nested field.
-            # Add the key of this dictionary to the allowed list.
-            elif isinstance(item, dict):
-                allowed.append(list(item.keys())[0])
-
-        # Convert the current serializer's fields and the allowed fields to sets.
-        existing = set(self.fields)
-        allowed = set(allowed)
-
-        # Remove fields from the serializer that aren't in the 'allowed' list.
-        for field_name in existing - allowed:
-            self.fields.pop(field_name)
-
-        return self.fields
-
-    def to_representation(self, instance):
-        response = super().to_representation(instance)
-
-        # Ensure 'expand' is iterable before processing
-        if self.expand:
-            for expand in self.expand:
-                if expand in self.fields:
-                    # Import all the expandable serializers
-                    from . import (
-                        WorkspaceLiteSerializer,
-                        ProjectLiteSerializer,
-                        UserLiteSerializer,
-                        StateLiteSerializer,
-                        IssueSerializer,
-                    )
-
-                    # Expansion mapper
-                    expansion = {
-                        "user": UserLiteSerializer,
-                        "workspace": WorkspaceLiteSerializer,
-                        "project": ProjectLiteSerializer,
-                        "default_assignee": UserLiteSerializer,
-                        "project_lead": UserLiteSerializer,
-                        "state": StateLiteSerializer,
-                        "created_by": UserLiteSerializer,
-                        "issue": IssueSerializer,
-                        "actor": UserLiteSerializer,
-                        "owned_by": UserLiteSerializer,
-                        "members": UserLiteSerializer,
-                    }
-                    # Check if field in expansion  then expand the field
-                    if expand in expansion:
-                        if isinstance(response.get(expand), list):
-                            exp_serializer = expansion[expand](
-                                getattr(instance, expand), many=True
-                            )
-                        else:
-                            exp_serializer = expansion[expand](
-                                getattr(instance, expand)
-                            )
-                            response[expand] = exp_serializer.data
-                    else:
-                        # You might need to handle this case differently
-                        response[expand] = getattr(instance, f"{expand}_id", None)
-
-        return response

apiserver/plane/api/serializers/cycle.py

@@ -1,56 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import Cycle, CycleIssue
-
-
-class CycleSerializer(BaseSerializer):
-    total_issues = serializers.IntegerField(read_only=True)
-    cancelled_issues = serializers.IntegerField(read_only=True)
-    completed_issues = serializers.IntegerField(read_only=True)
-    started_issues = serializers.IntegerField(read_only=True)
-    unstarted_issues = serializers.IntegerField(read_only=True)
-    backlog_issues = serializers.IntegerField(read_only=True)
-    total_estimates = serializers.IntegerField(read_only=True)
-    completed_estimates = serializers.IntegerField(read_only=True)
-    started_estimates = serializers.IntegerField(read_only=True)
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("end_date", None) is not None
-            and data.get("start_date", None) > data.get("end_date", None)
-        ):
-            raise serializers.ValidationError("Start date cannot exceed end date")
-        return data
-
-    class Meta:
-        model = Cycle
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "owned_by",
-        ]
-
-
-class CycleIssueSerializer(BaseSerializer):
-    sub_issues_count = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = CycleIssue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "cycle",
-        ]
-
-
-class CycleLiteSerializer(BaseSerializer):
-
-    class Meta:
-        model = Cycle
-        fields = "__all__"

apiserver/plane/api/serializers/inbox.py

@@ -1,19 +0,0 @@
-# Module improts
-from .base import BaseSerializer
-from plane.db.models import InboxIssue
-
-class InboxIssueSerializer(BaseSerializer):
-
-    class Meta:
-        model = InboxIssue
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]

apiserver/plane/api/serializers/issue.py

@@ -1,352 +0,0 @@
-# Django imports
-from django.utils import timezone
-
-#  Third party imports
-from rest_framework import serializers
-
-# Module imports
-from plane.db.models import (
-    User,
-    Issue,
-    State,
-    IssueAssignee,
-    Label,
-    IssueLabel,
-    IssueLink,
-    IssueComment,
-    IssueAttachment,
-    IssueActivity,
-    ProjectMember,
-)
-from .base import BaseSerializer
-from .cycle import CycleSerializer, CycleLiteSerializer
-from .module import ModuleSerializer, ModuleLiteSerializer
-
-
-class IssueSerializer(BaseSerializer):
-    assignees = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(
-            queryset=User.objects.values_list("id", flat=True)
-        ),
-        write_only=True,
-        required=False,
-    )
-
-    labels = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(
-            queryset=Label.objects.values_list("id", flat=True)
-        ),
-        write_only=True,
-        required=False,
-    )
-
-    class Meta:
-        model = Issue
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("target_date", None) is not None
-            and data.get("start_date", None) > data.get("target_date", None)
-        ):
-            raise serializers.ValidationError("Start date cannot exceed target date")
-
-        # Validate assignees are from project
-        if data.get("assignees", []):
-            data["assignees"] = ProjectMember.objects.filter(
-                project_id=self.context.get("project_id"),
-                is_active=True,
-                member_id__in=data["assignees"],
-            ).values_list("member_id", flat=True)
-
-        # Validate labels are from project
-        if data.get("labels", []):
-            data["labels"] = Label.objects.filter(
-                project_id=self.context.get("project_id"),
-                id__in=data["labels"],
-            ).values_list("id", flat=True)
-
-        # Check state is from the project only else raise validation error
-        if (
-            data.get("state")
-            and not State.objects.filter(
-                project_id=self.context.get("project_id"), pk=data.get("state")
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "State is not valid please pass a valid state_id"
-            )
-
-        # Check parent issue is from workspace as it can be cross workspace
-        if (
-            data.get("parent")
-            and not Issue.objects.filter(
-                workspace_id=self.context.get("workspace_id"), pk=data.get("parent")
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "Parent is not valid issue_id please pass a valid issue_id"
-            )
-
-        return data
-
-    def create(self, validated_data):
-        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels", None)
-
-        project_id = self.context["project_id"]
-        workspace_id = self.context["workspace_id"]
-        default_assignee_id = self.context["default_assignee_id"]
-
-        issue = Issue.objects.create(**validated_data, project_id=project_id)
-
-        # Issue Audit Users
-        created_by_id = issue.created_by_id
-        updated_by_id = issue.updated_by_id
-
-        if assignees is not None and len(assignees):
-            IssueAssignee.objects.bulk_create(
-                [
-                    IssueAssignee(
-                        assignee_id=assignee_id,
-                        issue=issue,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for assignee_id in assignees
-                ],
-                batch_size=10,
-            )
-        else:
-            # Then assign it to default assignee
-            if default_assignee_id is not None:
-                IssueAssignee.objects.create(
-                    assignee_id=default_assignee_id,
-                    issue=issue,
-                    project_id=project_id,
-                    workspace_id=workspace_id,
-                    created_by_id=created_by_id,
-                    updated_by_id=updated_by_id,
-                )
-
-        if labels is not None and len(labels):
-            IssueLabel.objects.bulk_create(
-                [
-                    IssueLabel(
-                        label_id=label_id,
-                        issue=issue,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label_id in labels
-                ],
-                batch_size=10,
-            )
-
-        return issue
-
-    def update(self, instance, validated_data):
-        assignees = validated_data.pop("assignees", None)
-        labels = validated_data.pop("labels", None)
-
-        # Related models
-        project_id = instance.project_id
-        workspace_id = instance.workspace_id
-        created_by_id = instance.created_by_id
-        updated_by_id = instance.updated_by_id
-
-        if assignees is not None:
-            IssueAssignee.objects.filter(issue=instance).delete()
-            IssueAssignee.objects.bulk_create(
-                [
-                    IssueAssignee(
-                        assignee_id=assignee_id,
-                        issue=instance,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for assignee_id in assignees
-                ],
-                batch_size=10,
-            )
-
-        if labels is not None:
-            IssueLabel.objects.filter(issue=instance).delete()
-            IssueLabel.objects.bulk_create(
-                [
-                    IssueLabel(
-                        label_id=label_id,
-                        issue=instance,
-                        project_id=project_id,
-                        workspace_id=workspace_id,
-                        created_by_id=created_by_id,
-                        updated_by_id=updated_by_id,
-                    )
-                    for label_id in labels
-                ],
-                batch_size=10,
-            )
-
-        # Time updation occues even when other related models are updated
-        instance.updated_at = timezone.now()
-        return super().update(instance, validated_data)
-
-    def to_representation(self, instance):
-        data = super().to_representation(instance)
-        if "assignees" in self.fields:
-            if "assignees" in self.expand:
-                from .user import UserLiteSerializer
-
-                data["assignees"] = UserLiteSerializer(
-                    instance.assignees.all(), many=True
-                ).data
-            else:
-                data["assignees"] = [
-                    str(assignee.id) for assignee in instance.assignees.all()
-                ]
-        if "labels" in self.fields:
-            if "labels" in self.expand:
-                data["labels"] = LabelSerializer(instance.labels.all(), many=True).data
-            else:
-                data["labels"] = [str(label.id) for label in instance.labels.all()]
-
-        return data
-
-
-class LabelSerializer(BaseSerializer):
-    class Meta:
-        model = Label
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueLinkSerializer(BaseSerializer):
-    class Meta:
-        model = IssueLink
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    # Validation if url already exists
-    def create(self, validated_data):
-        if IssueLink.objects.filter(
-            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
-        ).exists():
-            raise serializers.ValidationError(
-                {"error": "URL already exists for this Issue"}
-            )
-        return IssueLink.objects.create(**validated_data)
-
-
-class IssueAttachmentSerializer(BaseSerializer):
-    class Meta:
-        model = IssueAttachment
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueCommentSerializer(BaseSerializer):
-    is_member = serializers.BooleanField(read_only=True)
-
-    class Meta:
-        model = IssueComment
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "issue",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-
-class IssueActivitySerializer(BaseSerializer):
-    class Meta:
-        model = IssueActivity
-        exclude = [
-            "created_by",
-            "updated_by",
-        ]
-
-
-class CycleIssueSerializer(BaseSerializer):
-    cycle = CycleSerializer(read_only=True)
-
-    class Meta:
-        fields = [
-            "cycle",
-        ]
-
-
-class ModuleIssueSerializer(BaseSerializer):
-    module = ModuleSerializer(read_only=True)
-
-    class Meta:
-        fields = [
-            "module",
-        ]
-
-
-class IssueExpandSerializer(BaseSerializer):
-    # Serialize the related cycle. It's a OneToOne relation.
-    cycle = CycleLiteSerializer(source="issue_cycle.cycle", read_only=True)
-
-    # Serialize the related module. It's a OneToOne relation.
-    module = ModuleLiteSerializer(source="issue_module.module", read_only=True)
-
-    class Meta:
-        model = Issue
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]

apiserver/plane/api/serializers/module.py

@@ -1,162 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import (
-    User,
-    Module,
-    ModuleLink,
-    ModuleMember,
-    ModuleIssue,
-    ProjectMember,
-)
-
-
-class ModuleSerializer(BaseSerializer):
-    members = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(
-            queryset=User.objects.values_list("id", flat=True)
-        ),
-        write_only=True,
-        required=False,
-    )
-    total_issues = serializers.IntegerField(read_only=True)
-    cancelled_issues = serializers.IntegerField(read_only=True)
-    completed_issues = serializers.IntegerField(read_only=True)
-    started_issues = serializers.IntegerField(read_only=True)
-    unstarted_issues = serializers.IntegerField(read_only=True)
-    backlog_issues = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = Module
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    def to_representation(self, instance):
-        data = super().to_representation(instance)
-        data["members"] = [str(member.id) for member in instance.members.all()]
-        return data
-
-    def validate(self, data):
-        if (
-            data.get("start_date", None) is not None
-            and data.get("target_date", None) is not None
-            and data.get("start_date", None) > data.get("target_date", None)
-        ):
-            raise serializers.ValidationError("Start date cannot exceed target date")
-
-        if data.get("members", []):
-            print(data.get("members"))
-            data["members"] = ProjectMember.objects.filter(
-                project_id=self.context.get("project_id"),
-                member_id__in=data["members"],
-            ).values_list("member_id", flat=True)
-
-        return data
-
-    def create(self, validated_data):
-        members = validated_data.pop("members", None)
-
-        project = self.context["project"]
-
-        module = Module.objects.create(**validated_data, project=project)
-
-        if members is not None:
-            ModuleMember.objects.bulk_create(
-                [
-                    ModuleMember(
-                        module=module,
-                        member=member,
-                        project=project,
-                        workspace=project.workspace,
-                        created_by=module.created_by,
-                        updated_by=module.updated_by,
-                    )
-                    for member in members
-                ],
-                batch_size=10,
-                ignore_conflicts=True,
-            )
-
-        return module
-
-    def update(self, instance, validated_data):
-        members = validated_data.pop("members", None)
-
-        if members is not None:
-            ModuleMember.objects.filter(module=instance).delete()
-            ModuleMember.objects.bulk_create(
-                [
-                    ModuleMember(
-                        module=instance,
-                        member=member,
-                        project=instance.project,
-                        workspace=instance.project.workspace,
-                        created_by=instance.created_by,
-                        updated_by=instance.updated_by,
-                    )
-                    for member in members
-                ],
-                batch_size=10,
-                ignore_conflicts=True,
-            )
-
-        return super().update(instance, validated_data)
-
-
-class ModuleIssueSerializer(BaseSerializer):
-    sub_issues_count = serializers.IntegerField(read_only=True)
-
-    class Meta:
-        model = ModuleIssue
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "module",
-        ]
-
-
-class ModuleLinkSerializer(BaseSerializer):
-    class Meta:
-        model = ModuleLink
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-            "module",
-        ]
-
-    # Validation if url already exists
-    def create(self, validated_data):
-        if ModuleLink.objects.filter(
-            url=validated_data.get("url"), module_id=validated_data.get("module_id")
-        ).exists():
-            raise serializers.ValidationError(
-                {"error": "URL already exists for this Issue"}
-            )
-        return ModuleLink.objects.create(**validated_data)
-    
-
-class ModuleLiteSerializer(BaseSerializer):
-
-    class Meta:
-        model = Module
-        fields = "__all__"

apiserver/plane/api/serializers/project.py

@@ -1,91 +0,0 @@
-# Third party imports
-from rest_framework import serializers
-
-# Module imports
-from plane.db.models import Project, ProjectIdentifier, WorkspaceMember, State, Estimate
-from .base import BaseSerializer
-
-
-class ProjectSerializer(BaseSerializer):
-
-    total_members = serializers.IntegerField(read_only=True)
-    total_cycles = serializers.IntegerField(read_only=True)
-    total_modules = serializers.IntegerField(read_only=True)
-    is_member = serializers.BooleanField(read_only=True)
-    sort_order = serializers.FloatField(read_only=True)
-    member_role = serializers.IntegerField(read_only=True)
-    is_deployed = serializers.BooleanField(read_only=True)
-
-    class Meta:
-        model = Project
-        fields = "__all__"
-        read_only_fields = [
-            "id",
-            "workspace",
-            "created_at",
-            "updated_at",
-            "created_by",
-            "updated_by",
-        ]
-
-    def validate(self, data):
-        # Check project lead should be a member of the workspace
-        if (
-            data.get("project_lead", None) is not None
-            and not WorkspaceMember.objects.filter(
-                workspace_id=self.context["workspace_id"],
-                member_id=data.get("project_lead"),
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "Project lead should be a user in the workspace"
-            )
-
-        # Check default assignee should be a member of the workspace
-        if (
-            data.get("default_assignee", None) is not None
-            and not WorkspaceMember.objects.filter(
-                workspace_id=self.context["workspace_id"],
-                member_id=data.get("default_assignee"),
-            ).exists()
-        ):
-            raise serializers.ValidationError(
-                "Default assignee should be a user in the workspace"
-            )
-
-        return data
-
-    def create(self, validated_data):
-        identifier = validated_data.get("identifier", "").strip().upper()
-        if identifier == "":
-            raise serializers.ValidationError(detail="Project Identifier is required")
-
-        if ProjectIdentifier.objects.filter(
-            name=identifier, workspace_id=self.context["workspace_id"]
-        ).exists():
-            raise serializers.ValidationError(detail="Project Identifier is taken")
-
-        project = Project.objects.create(
-            **validated_data, workspace_id=self.context["workspace_id"]
-        )
-        _ = ProjectIdentifier.objects.create(
-            name=project.identifier,
-            project=project,
-            workspace_id=self.context["workspace_id"],
-        )
-        return project
-
-
-class ProjectLiteSerializer(BaseSerializer):
-    class Meta:
-        model = Project
-        fields = [
-            "id",
-            "identifier",
-            "name",
-            "cover_image",
-            "icon_prop",
-            "emoji",
-            "description",
-        ]
-        read_only_fields = fields

apiserver/plane/api/serializers/state.py

@@ -1,33 +0,0 @@
-# Module imports
-from .base import BaseSerializer
-from plane.db.models import State
-
-
-class StateSerializer(BaseSerializer):
-    def validate(self, data):
-        # If the default is being provided then make all other states default False
-        if data.get("default", False):
-            State.objects.filter(project_id=self.context.get("project_id")).update(
-                default=False
-            )
-        return data
-
-    class Meta:
-        model = State
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "project",
-        ]
-
-
-class StateLiteSerializer(BaseSerializer):
-    class Meta:
-        model = State
-        fields = [
-            "id",
-            "name",
-            "color",
-            "group",
-        ]
-        read_only_fields = fields

apiserver/plane/api/serializers/user.py

@@ -1,20 +0,0 @@
-# Module imports
-from plane.db.models import User
-from .base import BaseSerializer
-
-
-class UserLiteSerializer(BaseSerializer):
-    class Meta:
-        model = User
-        fields = [
-            "id",
-            "first_name",
-            "last_name",
-            "avatar",
-            "is_bot",
-            "display_name",
-        ]
-        read_only_fields = [
-            "id",
-            "is_bot",
-        ]

apiserver/plane/api/serializers/workspace.py

@@ -1,15 +0,0 @@
-# Module imports
-from plane.db.models import Workspace
-from .base import BaseSerializer
-
-
-class WorkspaceLiteSerializer(BaseSerializer):
-    """Lite serializer with only required fields"""
-    class Meta:
-        model = Workspace
-        fields = [
-            "name",
-            "slug",
-            "id",
-        ]
-        read_only_fields = fields

apiserver/plane/api/urls/inbox.py

@@ -1,17 +0,0 @@
-from django.urls import path
-
-from plane.api.views import InboxIssueAPIEndpoint
-
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
-        InboxIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:pk>/",
-        InboxIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-]

apiserver/plane/api/urls/state.py

@@ -1,16 +0,0 @@
-from django.urls import path
-
-from plane.api.views import StateAPIEndpoint
-
-urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/states/",
-        StateAPIEndpoint.as_view(),
-        name="states",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/states/<uuid:state_id>/",
-        StateAPIEndpoint.as_view(),
-        name="states",
-    ),
-]

apiserver/plane/api/views/base.py

@@ -1,176 +0,0 @@
-# Python imports
-import zoneinfo
-import json
-
-# Django imports
-from django.conf import settings
-from django.db import IntegrityError
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
-from django.utils import timezone
-
-# Third party imports
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework.permissions import IsAuthenticated
-from rest_framework import status
-from sentry_sdk import capture_exception
-
-# Module imports
-from plane.api.middleware.api_authentication import APIKeyAuthentication
-from plane.api.rate_limit import ApiKeyRateThrottle
-from plane.utils.paginator import BasePaginator
-from plane.bgtasks.webhook_task import send_webhook
-
-
-class TimezoneMixin:
-    """
-    This enables timezone conversion according
-    to the user set timezone
-    """
-
-    def initial(self, request, *args, **kwargs):
-        super().initial(request, *args, **kwargs)
-        if request.user.is_authenticated:
-            timezone.activate(zoneinfo.ZoneInfo(request.user.user_timezone))
-        else:
-            timezone.deactivate()
-
-
-class WebhookMixin:
-    webhook_event = None
-    bulk = False
-
-    def finalize_response(self, request, response, *args, **kwargs):
-        response = super().finalize_response(request, response, *args, **kwargs)
-
-        # Check for the case should webhook be sent
-        if (
-            self.webhook_event
-            and self.request.method in ["POST", "PATCH", "DELETE"]
-            and response.status_code in [200, 201, 204]
-        ):
-            # Push the object to delay
-            send_webhook.delay(
-                event=self.webhook_event,
-                payload=response.data,
-                kw=self.kwargs,
-                action=self.request.method,
-                slug=self.workspace_slug,
-                bulk=self.bulk,
-            )
-
-        return response
-
-
-class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
-    authentication_classes = [
-        APIKeyAuthentication,
-    ]
-
-    permission_classes = [
-        IsAuthenticated,
-    ]
-
-    throttle_classes = [
-        ApiKeyRateThrottle,
-    ]
-
-    def filter_queryset(self, queryset):
-        for backend in list(self.filter_backends):
-            queryset = backend().filter_queryset(self.request, queryset, self)
-        return queryset
-
-    def handle_exception(self, exc):
-        """
-        Handle any exception that occurs, by returning an appropriate response,
-        or re-raising the error.
-        """
-        try:
-            response = super().handle_exception(exc)
-            return response
-        except Exception as e:
-            if isinstance(e, IntegrityError):
-                return Response(
-                    {"error": "The payload is not valid"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if isinstance(e, ValidationError):
-                return Response(
-                    {
-                        "error": "The provided payload is not valid please try with a valid payload"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if isinstance(e, ObjectDoesNotExist):
-                model_name = str(exc).split(" matching query does not exist.")[0]
-                return Response(
-                    {"error": f"{model_name} does not exist."},
-                    status=status.HTTP_404_NOT_FOUND,
-                )
-
-            if isinstance(e, KeyError):
-                return Response(
-                    {"error": f"key {e} does not exist"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-            if settings.DEBUG:
-                print(e)
-            capture_exception(e)
-            return Response(
-                {"error": "Something went wrong please try again later"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
-
-    def dispatch(self, request, *args, **kwargs):
-        try:
-            response = super().dispatch(request, *args, **kwargs)
-            if settings.DEBUG:
-                from django.db import connection
-
-                print(
-                    f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
-                )
-            return response
-        except Exception as exc:
-            response = self.handle_exception(exc)
-            return exc
-
-    def finalize_response(self, request, response, *args, **kwargs):
-        # Call super to get the default response
-        response = super().finalize_response(request, response, *args, **kwargs)
-
-        # Add custom headers if they exist in the request META
-        ratelimit_remaining = request.META.get("X-RateLimit-Remaining")
-        if ratelimit_remaining is not None:
-            response["X-RateLimit-Remaining"] = ratelimit_remaining
-
-        ratelimit_reset = request.META.get("X-RateLimit-Reset")
-        if ratelimit_reset is not None:
-            response["X-RateLimit-Reset"] = ratelimit_reset
-
-        return response
-
-    @property
-    def workspace_slug(self):
-        return self.kwargs.get("slug", None)
-
-    @property
-    def project_id(self):
-        return self.kwargs.get("project_id", None)
-
-    @property
-    def fields(self):
-        fields = [
-            field for field in self.request.GET.get("fields", "").split(",") if field
-        ]
-        return fields if fields else None
-
-    @property
-    def expand(self):
-        expand = [
-            expand for expand in self.request.GET.get("expand", "").split(",") if expand
-        ]
-        return expand if expand else None

apiserver/plane/api/views/cycle.py

@@ -1,553 +0,0 @@
-# Python imports
-import json
-
-# Django imports
-from django.db.models import Q, Count, Sum, Prefetch, F, OuterRef, Func
-from django.utils import timezone
-from django.core import serializers
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module imports
-from .base import BaseAPIView, WebhookMixin
-from plane.db.models import Cycle, Issue, CycleIssue, IssueLink, IssueAttachment
-from plane.app.permissions import ProjectEntityPermission
-from plane.api.serializers import (
-    CycleSerializer,
-    CycleIssueSerializer,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
-
-
-class CycleAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to cycle.
-
-    """
-
-    serializer_class = CycleSerializer
-    model = Cycle
-    webhook_event = "cycle"
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            Cycle.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("owned_by")
-            .annotate(
-                total_issues=Count(
-                    "issue_cycle",
-                    filter=Q(
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                completed_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="completed",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                cancelled_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="cancelled",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                started_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="started",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                unstarted_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="unstarted",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                backlog_issues=Count(
-                    "issue_cycle__issue__state__group",
-                    filter=Q(
-                        issue_cycle__issue__state__group="backlog",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(total_estimates=Sum("issue_cycle__issue__estimate_point"))
-            .annotate(
-                completed_estimates=Sum(
-                    "issue_cycle__issue__estimate_point",
-                    filter=Q(
-                        issue_cycle__issue__state__group="completed",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                started_estimates=Sum(
-                    "issue_cycle__issue__estimate_point",
-                    filter=Q(
-                        issue_cycle__issue__state__group="started",
-                        issue_cycle__issue__archived_at__isnull=True,
-                        issue_cycle__issue__is_draft=False,
-                    ),
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, pk=None):
-        if pk:
-            queryset = self.get_queryset().get(pk=pk)
-            data = CycleSerializer(
-                queryset,
-                fields=self.fields,
-                expand=self.expand,
-            ).data
-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
-        queryset = self.get_queryset()
-        cycle_view = request.GET.get("cycle_view", "all")
-
-        # Current Cycle
-        if cycle_view == "current":
-            queryset = queryset.filter(
-                start_date__lte=timezone.now(),
-                end_date__gte=timezone.now(),
-            )
-            data = CycleSerializer(
-                queryset, many=True, fields=self.fields, expand=self.expand
-            ).data
-            return Response(data, status=status.HTTP_200_OK)
-
-        # Upcoming Cycles
-        if cycle_view == "upcoming":
-            queryset = queryset.filter(start_date__gt=timezone.now())
-            return self.paginate(
-                request=request,
-                queryset=(queryset),
-                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-
-        # Completed Cycles
-        if cycle_view == "completed":
-            queryset = queryset.filter(end_date__lt=timezone.now())
-            return self.paginate(
-                request=request,
-                queryset=(queryset),
-                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-
-        # Draft Cycles
-        if cycle_view == "draft":
-            queryset = queryset.filter(
-                end_date=None,
-                start_date=None,
-            )
-            return self.paginate(
-                request=request,
-                queryset=(queryset),
-                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-
-        # Incomplete Cycles
-        if cycle_view == "incomplete":
-            queryset = queryset.filter(
-                Q(end_date__gte=timezone.now().date()) | Q(end_date__isnull=True),
-            )
-            return self.paginate(
-                request=request,
-                queryset=(queryset),
-                on_results=lambda cycles: CycleSerializer(
-                    cycles,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-        return self.paginate(
-            request=request,
-            queryset=(queryset),
-            on_results=lambda cycles: CycleSerializer(
-                cycles,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id):
-        if (
-            request.data.get("start_date", None) is None
-            and request.data.get("end_date", None) is None
-        ) or (
-            request.data.get("start_date", None) is not None
-            and request.data.get("end_date", None) is not None
-        ):
-            serializer = CycleSerializer(data=request.data)
-            if serializer.is_valid():
-                serializer.save(
-                    project_id=project_id,
-                    owned_by=request.user,
-                )
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        else:
-            return Response(
-                {
-                    "error": "Both start date and end date are either required or are to be null"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def patch(self, request, slug, project_id, pk):
-        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-
-        request_data = request.data
-
-        if cycle.end_date is not None and cycle.end_date < timezone.now().date():
-            if "sort_order" in request_data:
-                # Can only change sort order
-                request_data = {
-                    "sort_order": request_data.get("sort_order", cycle.sort_order)
-                }
-            else:
-                return Response(
-                    {
-                        "error": "The Cycle has already been completed so it cannot be edited"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-        serializer = CycleSerializer(cycle, data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(self, request, slug, project_id, pk):
-        cycle_issues = list(
-            CycleIssue.objects.filter(cycle_id=self.kwargs.get("pk")).values_list(
-                "issue", flat=True
-            )
-        )
-        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-
-        issue_activity.delay(
-            type="cycle.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "cycle_id": str(pk),
-                    "cycle_name": str(cycle.name),
-                    "issues": [str(issue_id) for issue_id in cycle_issues],
-                }
-            ),
-            actor_id=str(request.user.id),
-            issue_id=None,
-            project_id=str(project_id),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-        )
-        # Delete the cycle
-        cycle.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class CycleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`,
-    and `destroy` actions related to cycle issues.
-
-    """
-
-    serializer_class = CycleIssueSerializer
-    model = CycleIssue
-    webhook_event = "cycle_issue"
-    bulk = True
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            CycleIssue.objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue_id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .filter(cycle_id=self.kwargs.get("cycle_id"))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("cycle")
-            .select_related("issue", "issue__state", "issue__project")
-            .prefetch_related("issue__assignees", "issue__labels")
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, cycle_id):
-        order_by = request.GET.get("order_by", "created_at")
-        issues = (
-            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id)
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(bridge_id=F("issue_cycle__id"))
-            .filter(project_id=project_id)
-            .filter(workspace__slug=slug)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .order_by(order_by)
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-        )
-
-        return self.paginate(
-            request=request,
-            queryset=(issues),
-            on_results=lambda issues: CycleSerializer(
-                issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id, cycle_id):
-        issues = request.data.get("issues", [])
-
-        if not issues:
-            return Response(
-                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        cycle = Cycle.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=cycle_id
-        )
-
-        if cycle.end_date is not None and cycle.end_date < timezone.now().date():
-            return Response(
-                {
-                    "error": "The Cycle has already been completed so no new issues can be added"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        issues = Issue.objects.filter(
-            pk__in=issues, workspace__slug=slug, project_id=project_id
-        ).values_list("id", flat=True)
-
-        # Get all CycleIssues already created
-        cycle_issues = list(CycleIssue.objects.filter(issue_id__in=issues))
-        update_cycle_issue_activity = []
-        record_to_create = []
-        records_to_update = []
-
-        for issue in issues:
-            cycle_issue = [
-                cycle_issue
-                for cycle_issue in cycle_issues
-                if str(cycle_issue.issue_id) in issues
-            ]
-            # Update only when cycle changes
-            if len(cycle_issue):
-                if cycle_issue[0].cycle_id != cycle_id:
-                    update_cycle_issue_activity.append(
-                        {
-                            "old_cycle_id": str(cycle_issue[0].cycle_id),
-                            "new_cycle_id": str(cycle_id),
-                            "issue_id": str(cycle_issue[0].issue_id),
-                        }
-                    )
-                    cycle_issue[0].cycle_id = cycle_id
-                    records_to_update.append(cycle_issue[0])
-            else:
-                record_to_create.append(
-                    CycleIssue(
-                        project_id=project_id,
-                        workspace=cycle.workspace,
-                        created_by=request.user,
-                        updated_by=request.user,
-                        cycle=cycle,
-                        issue_id=issue,
-                    )
-                )
-
-        CycleIssue.objects.bulk_create(
-            record_to_create,
-            batch_size=10,
-            ignore_conflicts=True,
-        )
-        CycleIssue.objects.bulk_update(
-            records_to_update,
-            ["cycle"],
-            batch_size=10,
-        )
-
-        # Capture Issue Activity
-        issue_activity.delay(
-            type="cycle.activity.created",
-            requested_data=json.dumps({"cycles_list": str(issues)}),
-            actor_id=str(self.request.user.id),
-            issue_id=None,
-            project_id=str(self.kwargs.get("project_id", None)),
-            current_instance=json.dumps(
-                {
-                    "updated_cycle_issues": update_cycle_issue_activity,
-                    "created_cycle_issues": serializers.serialize(
-                        "json", record_to_create
-                    ),
-                }
-            ),
-            epoch=int(timezone.now().timestamp()),
-        )
-
-        # Return all Cycle Issues
-        return Response(
-            CycleIssueSerializer(self.get_queryset(), many=True).data,
-            status=status.HTTP_200_OK,
-        )
-
-    def delete(self, request, slug, project_id, cycle_id, issue_id):
-        cycle_issue = CycleIssue.objects.get(
-            issue_id=issue_id, workspace__slug=slug, project_id=project_id, cycle_id=cycle_id
-        )
-        issue_id = cycle_issue.issue_id
-        cycle_issue.delete()
-        issue_activity.delay(
-            type="cycle.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "cycle_id": str(self.kwargs.get("cycle_id")),
-                    "issues": [str(issue_id)],
-                }
-            ),
-            actor_id=str(self.request.user.id),
-            issue_id=str(issue_id),
-            project_id=str(self.kwargs.get("project_id", None)),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class TransferCycleIssueAPIEndpoint(BaseAPIView):
-    """
-    This viewset provides `create` actions for transfering the issues into a particular cycle.
-
-    """
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def post(self, request, slug, project_id, cycle_id):
-        new_cycle_id = request.data.get("new_cycle_id", False)
-
-        if not new_cycle_id:
-            return Response(
-                {"error": "New Cycle Id is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        new_cycle = Cycle.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=new_cycle_id
-        )
-
-        if (
-            new_cycle.end_date is not None
-            and new_cycle.end_date < timezone.now().date()
-        ):
-            return Response(
-                {
-                    "error": "The cycle where the issues are transferred is already completed"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        cycle_issues = CycleIssue.objects.filter(
-            cycle_id=cycle_id,
-            project_id=project_id,
-            workspace__slug=slug,
-            issue__state__group__in=["backlog", "unstarted", "started"],
-        )
-
-        updated_cycles = []
-        for cycle_issue in cycle_issues:
-            cycle_issue.cycle_id = new_cycle_id
-            updated_cycles.append(cycle_issue)
-
-        cycle_issues = CycleIssue.objects.bulk_update(
-            updated_cycles, ["cycle_id"], batch_size=100
-        )
-
-        return Response({"message": "Success"}, status=status.HTTP_200_OK)

apiserver/plane/api/views/inbox.py

@@ -1,352 +0,0 @@
-# Python imports
-import json
-
-# Django improts
-from django.utils import timezone
-from django.db.models import Q
-from django.core.serializers.json import DjangoJSONEncoder
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from .base import BaseAPIView
-from plane.app.permissions import ProjectLitePermission
-from plane.api.serializers import InboxIssueSerializer, IssueSerializer
-from plane.db.models import InboxIssue, Issue, State, ProjectMember, Project, Inbox
-from plane.bgtasks.issue_activites_task import issue_activity
-
-
-class InboxIssueAPIEndpoint(BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to inbox issues.
-
-    """
-
-    permission_classes = [
-        ProjectLitePermission,
-    ]
-
-    serializer_class = InboxIssueSerializer
-    model = InboxIssue
-
-    filterset_fields = [
-        "status",
-    ]
-
-    def get_queryset(self):
-        inbox = Inbox.objects.filter(
-            workspace__slug=self.kwargs.get("slug"),
-            project_id=self.kwargs.get("project_id"),
-        ).first()
-
-        project = Project.objects.get(
-            workspace__slug=self.kwargs.get("slug"), pk=self.kwargs.get("project_id")
-        )
-
-        if inbox is None and not project.inbox_view:
-            return InboxIssue.objects.none()
-
-        return (
-            InboxIssue.objects.filter(
-                Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
-                workspace__slug=self.kwargs.get("slug"),
-                project_id=self.kwargs.get("project_id"),
-                inbox_id=inbox.id,
-            )
-            .select_related("issue", "workspace", "project")
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        )
-
-    def get(self, request, slug, project_id, pk=None):
-        if pk:
-            inbox_issue_queryset = self.get_queryset().get(pk=pk)
-            inbox_issue_data = InboxIssueSerializer(
-                inbox_issue_queryset,
-                fields=self.fields,
-                expand=self.expand,
-            ).data
-            return Response(
-                inbox_issue_data,
-                status=status.HTTP_200_OK,
-            )
-        issue_queryset = self.get_queryset()
-        return self.paginate(
-            request=request,
-            queryset=(issue_queryset),
-            on_results=lambda inbox_issues: InboxIssueSerializer(
-                inbox_issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id):
-        if not request.data.get("issue", {}).get("name", False):
-            return Response(
-                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        inbox = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-
-        project = Project.objects.get(
-            workspace__slug=slug,
-            pk=project_id,
-        )
-
-        # Inbox view
-        if inbox is None and not project.inbox_view:
-            return Response(
-                {
-                    "error": "Inbox is not enabled for this project enable it through the project settings"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Check for valid priority
-        if not request.data.get("issue", {}).get("priority", "none") in [
-            "low",
-            "medium",
-            "high",
-            "urgent",
-            "none",
-        ]:
-            return Response(
-                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        # Create or get state
-        state, _ = State.objects.get_or_create(
-            name="Triage",
-            group="backlog",
-            description="Default state for managing all Inbox Issues",
-            project_id=project_id,
-            color="#ff7700",
-        )
-
-        # create an issue
-        issue = Issue.objects.create(
-            name=request.data.get("issue", {}).get("name"),
-            description=request.data.get("issue", {}).get("description", {}),
-            description_html=request.data.get("issue", {}).get(
-                "description_html", "<p></p>"
-            ),
-            priority=request.data.get("issue", {}).get("priority", "low"),
-            project_id=project_id,
-            state=state,
-        )
-
-        # Create an Issue Activity
-        issue_activity.delay(
-            type="issue.activity.created",
-            requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
-            actor_id=str(request.user.id),
-            issue_id=str(issue.id),
-            project_id=str(project_id),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-        )
-
-        # create an inbox issue
-        inbox_issue = InboxIssue.objects.create(
-            inbox_id=inbox.id,
-            project_id=project_id,
-            issue=issue,
-            source=request.data.get("source", "in-app"),
-        )
-
-        serializer = InboxIssueSerializer(inbox_issue)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def patch(self, request, slug, project_id, pk):
-        inbox = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-
-        project = Project.objects.get(
-            workspace__slug=slug,
-            pk=project_id,
-        )
-
-        # Inbox view
-        if inbox is None and not project.inbox_view:
-            return Response(
-                {
-                    "error": "Inbox is not enabled for this project enable it through the project settings"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get the inbox issue
-        inbox_issue = InboxIssue.objects.get(
-            pk=pk,
-            workspace__slug=slug,
-            project_id=project_id,
-            inbox_id=inbox.id,
-        )
-
-        # Get the project member
-        project_member = ProjectMember.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            member=request.user,
-            is_active=True,
-        )
-
-        # Only project members admins and created_by users can access this endpoint
-        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
-            request.user.id
-        ):
-            return Response(
-                {"error": "You cannot edit inbox issues"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get issue data
-        issue_data = request.data.pop("issue", False)
-
-        if bool(issue_data):
-            issue = Issue.objects.get(
-                pk=inbox_issue.issue_id, workspace__slug=slug, project_id=project_id
-            )
-            # Only allow guests and viewers to edit name and description
-            if project_member.role <= 10:
-                # viewers and guests since only viewers and guests
-                issue_data = {
-                    "name": issue_data.get("name", issue.name),
-                    "description_html": issue_data.get(
-                        "description_html", issue.description_html
-                    ),
-                    "description": issue_data.get("description", issue.description),
-                }
-
-            issue_serializer = IssueSerializer(issue, data=issue_data, partial=True)
-
-            if issue_serializer.is_valid():
-                current_instance = issue
-                # Log all the updates
-                requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
-                if issue is not None:
-                    issue_activity.delay(
-                        type="issue.activity.updated",
-                        requested_data=requested_data,
-                        actor_id=str(request.user.id),
-                        issue_id=str(issue.id),
-                        project_id=str(project_id),
-                        current_instance=json.dumps(
-                            IssueSerializer(current_instance).data,
-                            cls=DjangoJSONEncoder,
-                        ),
-                        epoch=int(timezone.now().timestamp()),
-                    )
-                issue_serializer.save()
-            else:
-                return Response(
-                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
-                )
-
-        # Only project admins and members can edit inbox issue attributes
-        if project_member.role > 10:
-            serializer = InboxIssueSerializer(
-                inbox_issue, data=request.data, partial=True
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                # Update the issue state if the issue is rejected or marked as duplicate
-                if serializer.data["status"] in [-1, 2]:
-                    issue = Issue.objects.get(
-                        pk=inbox_issue.issue_id,
-                        workspace__slug=slug,
-                        project_id=project_id,
-                    )
-                    state = State.objects.filter(
-                        group="cancelled", workspace__slug=slug, project_id=project_id
-                    ).first()
-                    if state is not None:
-                        issue.state = state
-                        issue.save()
-
-                # Update the issue state if it is accepted
-                if serializer.data["status"] in [1]:
-                    issue = Issue.objects.get(
-                        pk=inbox_issue.issue_id,
-                        workspace__slug=slug,
-                        project_id=project_id,
-                    )
-
-                    # Update the issue state only if it is in triage state
-                    if issue.state.name == "Triage":
-                        # Move to default state
-                        state = State.objects.filter(
-                            workspace__slug=slug, project_id=project_id, default=True
-                        ).first()
-                        if state is not None:
-                            issue.state = state
-                            issue.save()
-
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        else:
-            return Response(
-                InboxIssueSerializer(inbox_issue).data, status=status.HTTP_200_OK
-            )
-
-    def delete(self, request, slug, project_id, pk):
-        inbox = Inbox.objects.filter(
-            workspace__slug=slug, project_id=project_id
-        ).first()
-
-        project = Project.objects.get(
-            workspace__slug=slug,
-            pk=project_id,
-        )
-
-        # Inbox view
-        if inbox is None and not project.inbox_view:
-            return Response(
-                {
-                    "error": "Inbox is not enabled for this project enable it through the project settings"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get the inbox issue
-        inbox_issue = InboxIssue.objects.get(
-            pk=pk,
-            workspace__slug=slug,
-            project_id=project_id,
-            inbox_id=inbox.id,
-        )
-
-        # Get the project member
-        project_member = ProjectMember.objects.get(
-            workspace__slug=slug,
-            project_id=project_id,
-            member=request.user,
-            is_active=True,
-        )
-
-        # Check the inbox issue created
-        if project_member.role <= 10 and str(inbox_issue.created_by_id) != str(
-            request.user.id
-        ):
-            return Response(
-                {"error": "You cannot delete inbox issue"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Check the issue status
-        if inbox_issue.status in [-2, -1, 0, 2]:
-            # Delete the issue also
-            Issue.objects.filter(
-                workspace__slug=slug, project_id=project_id, pk=inbox_issue.issue_id
-            ).delete()
-
-        inbox_issue.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/issue.py

@@ -1,600 +0,0 @@
-# Python imports
-import json
-from itertools import chain
-
-# Django imports
-from django.db import IntegrityError
-from django.db.models import (
-    OuterRef,
-    Func,
-    Q,
-    F,
-    Case,
-    When,
-    Value,
-    CharField,
-    Max,
-    Exists,
-)
-from django.core.serializers.json import DjangoJSONEncoder
-from django.utils import timezone
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from .base import BaseAPIView, WebhookMixin
-from plane.app.permissions import (
-    ProjectEntityPermission,
-    ProjectMemberPermission,
-    ProjectLitePermission,
-)
-from plane.db.models import (
-    Issue,
-    IssueAttachment,
-    IssueLink,
-    Project,
-    Label,
-    ProjectMember,
-    IssueComment,
-    IssueActivity,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
-from plane.api.serializers import (
-    IssueSerializer,
-    LabelSerializer,
-    IssueLinkSerializer,
-    IssueCommentSerializer,
-    IssueActivitySerializer,
-)
-
-
-class IssueAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to issue.
-
-    """
-
-    model = Issue
-    webhook_event = "issue"
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    serializer_class = IssueSerializer
-
-    def get_queryset(self):
-        return (
-            Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        ).distinct()
-
-    def get(self, request, slug, project_id, pk=None):
-        if pk:
-            issue = Issue.issue_objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            ).get(workspace__slug=slug, project_id=project_id, pk=pk)
-            return Response(
-                IssueSerializer(
-                    issue,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-                status=status.HTTP_200_OK,
-            )
-
-        # Custom ordering for priority and state
-        priority_order = ["urgent", "high", "medium", "low", "none"]
-        state_order = ["backlog", "unstarted", "started", "completed", "cancelled"]
-
-        order_by_param = request.GET.get("order_by", "-created_at")
-
-        issue_queryset = (
-            self.get_queryset()
-            .annotate(cycle_id=F("issue_cycle__cycle_id"))
-            .annotate(module_id=F("issue_module__module_id"))
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-        )
-
-        # Priority Ordering
-        if order_by_param == "priority" or order_by_param == "-priority":
-            priority_order = (
-                priority_order if order_by_param == "priority" else priority_order[::-1]
-            )
-            issue_queryset = issue_queryset.annotate(
-                priority_order=Case(
-                    *[
-                        When(priority=p, then=Value(i))
-                        for i, p in enumerate(priority_order)
-                    ],
-                    output_field=CharField(),
-                )
-            ).order_by("priority_order")
-
-        # State Ordering
-        elif order_by_param in [
-            "state__name",
-            "state__group",
-            "-state__name",
-            "-state__group",
-        ]:
-            state_order = (
-                state_order
-                if order_by_param in ["state__name", "state__group"]
-                else state_order[::-1]
-            )
-            issue_queryset = issue_queryset.annotate(
-                state_order=Case(
-                    *[
-                        When(state__group=state_group, then=Value(i))
-                        for i, state_group in enumerate(state_order)
-                    ],
-                    default=Value(len(state_order)),
-                    output_field=CharField(),
-                )
-            ).order_by("state_order")
-        # assignee and label ordering
-        elif order_by_param in [
-            "labels__name",
-            "-labels__name",
-            "assignees__first_name",
-            "-assignees__first_name",
-        ]:
-            issue_queryset = issue_queryset.annotate(
-                max_values=Max(
-                    order_by_param[1::]
-                    if order_by_param.startswith("-")
-                    else order_by_param
-                )
-            ).order_by(
-                "-max_values" if order_by_param.startswith("-") else "max_values"
-            )
-        else:
-            issue_queryset = issue_queryset.order_by(order_by_param)
-
-        return self.paginate(
-            request=request,
-            queryset=(issue_queryset),
-            on_results=lambda issues: IssueSerializer(
-                issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id):
-        project = Project.objects.get(pk=project_id)
-
-        serializer = IssueSerializer(
-            data=request.data,
-            context={
-                "project_id": project_id,
-                "workspace_id": project.workspace_id,
-                "default_assignee_id": project.default_assignee_id,
-            },
-        )
-
-        if serializer.is_valid():
-            serializer.save()
-
-            # Track the issue
-            issue_activity.delay(
-                type="issue.activity.created",
-                requested_data=json.dumps(self.request.data, cls=DjangoJSONEncoder),
-                actor_id=str(request.user.id),
-                issue_id=str(serializer.data.get("id", None)),
-                project_id=str(project_id),
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-            )
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def patch(self, request, slug, project_id, pk=None):
-        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-        current_instance = json.dumps(
-            IssueSerializer(issue).data, cls=DjangoJSONEncoder
-        )
-        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
-        serializer = IssueSerializer(issue, data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            issue_activity.delay(
-                type="issue.activity.updated",
-                requested_data=requested_data,
-                actor_id=str(request.user.id),
-                issue_id=str(pk),
-                project_id=str(project_id),
-                current_instance=current_instance,
-                epoch=int(timezone.now().timestamp()),
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(self, request, slug, project_id, pk=None):
-        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-        current_instance = json.dumps(
-            IssueSerializer(issue).data, cls=DjangoJSONEncoder
-        )
-        issue.delete()
-        issue_activity.delay(
-            type="issue.activity.deleted",
-            requested_data=json.dumps({"issue_id": str(pk)}),
-            actor_id=str(request.user.id),
-            issue_id=str(pk),
-            project_id=str(project_id),
-            current_instance=current_instance,
-            epoch=int(timezone.now().timestamp()),
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class LabelAPIEndpoint(BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to the labels.
-
-    """
-
-    serializer_class = LabelSerializer
-    model = Label
-    permission_classes = [
-        ProjectMemberPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            Label.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("parent")
-            .distinct()
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        )
-
-    def post(self, request, slug, project_id):
-        try:
-            serializer = LabelSerializer(data=request.data)
-            if serializer.is_valid():
-                serializer.save(project_id=project_id)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError:
-            return Response(
-                {"error": "Label with the same name already exists in the project"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-    def get(self, request, slug, project_id, pk=None):
-        if pk is None:
-            return self.paginate(
-                request=request,
-                queryset=(self.get_queryset()),
-                on_results=lambda labels: LabelSerializer(
-                    labels,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-        label = self.get_queryset().get(pk=pk)
-        serializer = LabelSerializer(label, fields=self.fields, expand=self.expand,)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def patch(self, request, slug, project_id, pk=None):
-        label = self.get_queryset().get(pk=pk)
-        serializer = LabelSerializer(label, data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    
-
-    def delete(self, request, slug, project_id, pk=None):
-        label = self.get_queryset().get(pk=pk)
-        label.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class IssueLinkAPIEndpoint(BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to the links of the particular issue.
-
-    """
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    model = IssueLink
-    serializer_class = IssueLinkSerializer
-
-    def get_queryset(self):
-        return (
-            IssueLink.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(issue_id=self.kwargs.get("issue_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, issue_id, pk=None):
-        if pk is None:
-            issue_links = self.get_queryset()
-            serializer = IssueLinkSerializer(
-                issue_links,
-                fields=self.fields,
-                expand=self.expand,
-            )
-            return self.paginate(
-                request=request,
-                queryset=(self.get_queryset()),
-                on_results=lambda issue_links: IssueLinkSerializer(
-                    issue_links,
-                    many=True,
-                    fields=self.fields,
-                    expand=self.expand,
-                ).data,
-            )
-        issue_link = self.get_queryset().get(pk=pk)
-        serializer = IssueLinkSerializer(
-            issue_link,
-            fields=self.fields,
-            expand=self.expand,
-        )
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def post(self, request, slug, project_id, issue_id):
-        serializer = IssueLinkSerializer(data=request.data)
-        if serializer.is_valid():
-            serializer.save(
-                project_id=project_id,
-                issue_id=issue_id,
-            )
-            issue_activity.delay(
-                type="link.activity.created",
-                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
-                actor_id=str(self.request.user.id),
-                issue_id=str(self.kwargs.get("issue_id")),
-                project_id=str(self.kwargs.get("project_id")),
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-            )
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def patch(self, request, slug, project_id, issue_id, pk):
-        issue_link = IssueLink.objects.get(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
-        )
-        requested_data = json.dumps(request.data, cls=DjangoJSONEncoder)
-        current_instance = json.dumps(
-            IssueLinkSerializer(issue_link).data,
-            cls=DjangoJSONEncoder,
-        )
-        serializer = IssueLinkSerializer(issue_link, data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            issue_activity.delay(
-                type="link.activity.updated",
-                requested_data=requested_data,
-                actor_id=str(request.user.id),
-                issue_id=str(issue_id),
-                project_id=str(project_id),
-                current_instance=current_instance,
-                epoch=int(timezone.now().timestamp()),
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(self, request, slug, project_id, issue_id, pk):
-        issue_link = IssueLink.objects.get(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
-        )
-        current_instance = json.dumps(
-            IssueLinkSerializer(issue_link).data,
-            cls=DjangoJSONEncoder,
-        )
-        issue_activity.delay(
-            type="link.activity.deleted",
-            requested_data=json.dumps({"link_id": str(pk)}),
-            actor_id=str(request.user.id),
-            issue_id=str(issue_id),
-            project_id=str(project_id),
-            current_instance=current_instance,
-            epoch=int(timezone.now().timestamp()),
-        )
-        issue_link.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class IssueCommentAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to comments of the particular issue.
-
-    """
-
-    serializer_class = IssueCommentSerializer
-    model = IssueComment
-    webhook_event = "issue_comment"
-    permission_classes = [
-        ProjectLitePermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            IssueComment.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(issue_id=self.kwargs.get("issue_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("issue")
-            .select_related("actor")
-            .annotate(
-                is_member=Exists(
-                    ProjectMember.objects.filter(
-                        workspace__slug=self.kwargs.get("slug"),
-                        project_id=self.kwargs.get("project_id"),
-                        member_id=self.request.user.id,
-                        is_active=True,
-                    )
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, issue_id, pk=None):
-        if pk:
-            issue_comment = self.get_queryset().get(pk=pk)
-            serializer = IssueCommentSerializer(
-                issue_comment,
-                fields=self.fields,
-                expand=self.expand,
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return self.paginate(
-            request=request,
-            queryset=(self.get_queryset()),
-            on_results=lambda issue_comment: IssueCommentSerializer(
-                issue_comment,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id, issue_id):
-        serializer = IssueCommentSerializer(data=request.data)
-        if serializer.is_valid():
-            serializer.save(
-                project_id=project_id,
-                issue_id=issue_id,
-                actor=request.user,
-            )
-            issue_activity.delay(
-                type="comment.activity.created",
-                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
-                actor_id=str(self.request.user.id),
-                issue_id=str(self.kwargs.get("issue_id")),
-                project_id=str(self.kwargs.get("project_id")),
-                current_instance=None,
-                epoch=int(timezone.now().timestamp()),
-            )
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def patch(self, request, slug, project_id, issue_id, pk):
-        issue_comment = IssueComment.objects.get(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
-        )
-        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
-        current_instance = json.dumps(
-            IssueCommentSerializer(issue_comment).data,
-            cls=DjangoJSONEncoder,
-        )
-        serializer = IssueCommentSerializer(
-            issue_comment, data=request.data, partial=True
-        )
-        if serializer.is_valid():
-            serializer.save()
-            issue_activity.delay(
-                type="comment.activity.updated",
-                requested_data=requested_data,
-                actor_id=str(request.user.id),
-                issue_id=str(issue_id),
-                project_id=str(project_id),
-                current_instance=current_instance,
-                epoch=int(timezone.now().timestamp()),
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def delete(self, request, slug, project_id, issue_id, pk):
-        issue_comment = IssueComment.objects.get(
-            workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
-        )
-        current_instance = json.dumps(
-            IssueCommentSerializer(issue_comment).data,
-            cls=DjangoJSONEncoder,
-        )
-        issue_comment.delete()
-        issue_activity.delay(
-            type="comment.activity.deleted",
-            requested_data=json.dumps({"comment_id": str(pk)}),
-            actor_id=str(request.user.id),
-            issue_id=str(issue_id),
-            project_id=str(project_id),
-            current_instance=current_instance,
-            epoch=int(timezone.now().timestamp()),
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class IssueActivityAPIEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get(self, request, slug, project_id, issue_id, pk=None):
-        issue_activities = (
-            IssueActivity.objects.filter(
-                issue_id=issue_id, workspace__slug=slug, project_id=project_id
-            )
-            .filter(
-                ~Q(field__in=["comment", "vote", "reaction", "draft"]),
-                project__project_projectmember__member=self.request.user,
-            )
-            .select_related("actor", "workspace", "issue", "project")
-        ).order_by(request.GET.get("order_by", "created_at"))
- 
-        if pk:
-            issue_activities = issue_activities.get(pk=pk)
-            serializer = IssueActivitySerializer(issue_activities)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-
-        return self.paginate(
-            request=request,
-            queryset=(issue_activities),
-            on_results=lambda issue_activity: IssueActivitySerializer(
-                issue_activity,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )

apiserver/plane/api/views/module.py

@@ -1,374 +0,0 @@
-# Python imports
-import json
-
-# Django imports
-from django.db.models import Count, Prefetch, Q, F, Func, OuterRef
-from django.utils import timezone
-from django.core import serializers
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-
-# Module imports
-from .base import BaseAPIView, WebhookMixin
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import (
-    Project,
-    Module,
-    ModuleLink,
-    Issue,
-    ModuleIssue,
-    IssueAttachment,
-    IssueLink,
-)
-from plane.api.serializers import (
-    ModuleSerializer,
-    ModuleIssueSerializer,
-    IssueSerializer,
-)
-from plane.bgtasks.issue_activites_task import issue_activity
-
-
-class ModuleAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to module.
-
-    """
-
-    model = Module
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-    serializer_class = ModuleSerializer
-    webhook_event = "module"
-
-    def get_queryset(self):
-        return (
-            Module.objects.filter(project_id=self.kwargs.get("project_id"))
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("lead")
-            .prefetch_related("members")
-            .prefetch_related(
-                Prefetch(
-                    "link_module",
-                    queryset=ModuleLink.objects.select_related("module", "created_by"),
-                )
-            )
-            .annotate(
-                total_issues=Count(
-                    "issue_module",
-                    filter=Q(
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                ),
-            )
-            .annotate(
-                completed_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="completed",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                cancelled_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="cancelled",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                started_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="started",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                unstarted_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="unstarted",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .annotate(
-                backlog_issues=Count(
-                    "issue_module__issue__state__group",
-                    filter=Q(
-                        issue_module__issue__state__group="backlog",
-                        issue_module__issue__archived_at__isnull=True,
-                        issue_module__issue__is_draft=False,
-                    ),
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-        )
-
-    def post(self, request, slug, project_id):
-        project = Project.objects.get(workspace__slug=slug, pk=project_id)
-        serializer = ModuleSerializer(data=request.data, context={"project": project})
-        if serializer.is_valid():
-            serializer.save()
-            module = Module.objects.get(pk=serializer.data["id"])
-            serializer = ModuleSerializer(module)
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    
-    def patch(self, request, slug, project_id, pk):
-        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
-        serializer = ModuleSerializer(module, data=request.data)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def get(self, request, slug, project_id, pk=None):
-        if pk:
-            queryset = self.get_queryset().get(pk=pk)
-            data = ModuleSerializer(
-                queryset,
-                fields=self.fields,
-                expand=self.expand,
-            ).data
-            return Response(
-                data,
-                status=status.HTTP_200_OK,
-            )
-        return self.paginate(
-            request=request,
-            queryset=(self.get_queryset()),
-            on_results=lambda modules: ModuleSerializer(
-                modules,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def delete(self, request, slug, project_id, pk):
-        module = Module.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
-        module_issues = list(
-            ModuleIssue.objects.filter(module_id=pk).values_list("issue", flat=True)
-        )
-        issue_activity.delay(
-            type="module.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "module_id": str(pk),
-                    "module_name": str(module.name),
-                    "issues": [str(issue_id) for issue_id in module_issues],
-                }
-            ),
-            actor_id=str(request.user.id),
-            issue_id=None,
-            project_id=str(project_id),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-        )
-        module.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class ModuleIssueAPIEndpoint(WebhookMixin, BaseAPIView):
-    """
-    This viewset automatically provides `list`, `create`, `retrieve`,
-    `update` and `destroy` actions related to module issues.
-
-    """
-
-    serializer_class = ModuleIssueSerializer
-    model = ModuleIssue
-    webhook_event = "module_issue"
-    bulk = True
-
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            ModuleIssue.objects.annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(module_id=self.kwargs.get("module_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("module")
-            .select_related("issue", "issue__state", "issue__project")
-            .prefetch_related("issue__assignees", "issue__labels")
-            .prefetch_related("module__members")
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id, module_id):
-        order_by = request.GET.get("order_by", "created_at")
-        issues = (
-            Issue.issue_objects.filter(issue_module__module_id=module_id)
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(bridge_id=F("issue_module__id"))
-            .filter(project_id=project_id)
-            .filter(workspace__slug=slug)
-            .select_related("project")
-            .select_related("workspace")
-            .select_related("state")
-            .select_related("parent")
-            .prefetch_related("assignees")
-            .prefetch_related("labels")
-            .order_by(order_by)
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-        )
-        return self.paginate(
-            request=request,
-            queryset=(issues),
-            on_results=lambda issues: IssueSerializer(
-                issues,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def post(self, request, slug, project_id, module_id):
-        issues = request.data.get("issues", [])
-        if not len(issues):
-            return Response(
-                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
-            )
-        module = Module.objects.get(
-            workspace__slug=slug, project_id=project_id, pk=module_id
-        )
-
-        issues = Issue.objects.filter(
-            workspace__slug=slug, project_id=project_id, pk__in=issues
-        ).values_list("id", flat=True)
-
-        module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
-
-        update_module_issue_activity = []
-        records_to_update = []
-        record_to_create = []
-
-        for issue in issues:
-            module_issue = [
-                module_issue
-                for module_issue in module_issues
-                if str(module_issue.issue_id) in issues
-            ]
-
-            if len(module_issue):
-                if module_issue[0].module_id != module_id:
-                    update_module_issue_activity.append(
-                        {
-                            "old_module_id": str(module_issue[0].module_id),
-                            "new_module_id": str(module_id),
-                            "issue_id": str(module_issue[0].issue_id),
-                        }
-                    )
-                    module_issue[0].module_id = module_id
-                    records_to_update.append(module_issue[0])
-            else:
-                record_to_create.append(
-                    ModuleIssue(
-                        module=module,
-                        issue_id=issue,
-                        project_id=project_id,
-                        workspace=module.workspace,
-                        created_by=request.user,
-                        updated_by=request.user,
-                    )
-                )
-
-        ModuleIssue.objects.bulk_create(
-            record_to_create,
-            batch_size=10,
-            ignore_conflicts=True,
-        )
-
-        ModuleIssue.objects.bulk_update(
-            records_to_update,
-            ["module"],
-            batch_size=10,
-        )
-
-        # Capture Issue Activity
-        issue_activity.delay(
-            type="module.activity.created",
-            requested_data=json.dumps({"modules_list": str(issues)}),
-            actor_id=str(self.request.user.id),
-            issue_id=None,
-            project_id=str(self.kwargs.get("project_id", None)),
-            current_instance=json.dumps(
-                {
-                    "updated_module_issues": update_module_issue_activity,
-                    "created_module_issues": serializers.serialize(
-                        "json", record_to_create
-                    ),
-                }
-            ),
-            epoch=int(timezone.now().timestamp()),
-        )
-
-        return Response(
-            ModuleIssueSerializer(self.get_queryset(), many=True).data,
-            status=status.HTTP_200_OK,
-        )
-
-    def delete(self, request, slug, project_id, module_id, issue_id):
-        module_issue = ModuleIssue.objects.get(
-            workspace__slug=slug, project_id=project_id, module_id=module_id, issue_id=issue_id
-        )
-        module_issue.delete()
-        issue_activity.delay(
-            type="module.activity.deleted",
-            requested_data=json.dumps(
-                {
-                    "module_id": str(module_id),
-                    "issues": [str(module_issue.issue_id)],
-                }
-            ),
-            actor_id=str(request.user.id),
-            issue_id=str(issue_id),
-            project_id=str(project_id),
-            current_instance=None,
-            epoch=int(timezone.now().timestamp()),
-        )
-        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/project.py

@@ -1,288 +0,0 @@
-# Django imports
-from django.db import IntegrityError
-from django.db.models import Exists, OuterRef, Q, F, Func, Subquery, Prefetch
-
-# Third party imports
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.serializers import ValidationError
-
-# Module imports
-from plane.db.models import (
-    Workspace,
-    Project,
-    ProjectFavorite,
-    ProjectMember,
-    ProjectDeployBoard,
-    State,
-    Cycle,
-    Module,
-    IssueProperty,
-    Inbox,
-)
-from plane.app.permissions import ProjectBasePermission
-from plane.api.serializers import ProjectSerializer
-from .base import BaseAPIView, WebhookMixin
-
-
-class ProjectAPIEndpoint(WebhookMixin, BaseAPIView):
-    """Project Endpoints to create, update, list, retrieve and delete endpoint"""
-
-    serializer_class = ProjectSerializer
-    model = Project
-    webhook_event = "project"
-
-    permission_classes = [
-        ProjectBasePermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            Project.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(Q(project_projectmember__member=self.request.user) | Q(network=2))
-            .select_related(
-                "workspace", "workspace__owner", "default_assignee", "project_lead"
-            )
-            .annotate(
-                is_member=Exists(
-                    ProjectMember.objects.filter(
-                        member=self.request.user,
-                        project_id=OuterRef("pk"),
-                        workspace__slug=self.kwargs.get("slug"),
-                        is_active=True,
-                    )
-                )
-            )
-            .annotate(
-                total_members=ProjectMember.objects.filter(
-                    project_id=OuterRef("id"),
-                    member__is_bot=False,
-                    is_active=True,
-                )
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                total_cycles=Cycle.objects.filter(project_id=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                total_modules=Module.objects.filter(project_id=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                member_role=ProjectMember.objects.filter(
-                    project_id=OuterRef("pk"),
-                    member_id=self.request.user.id,
-                    is_active=True,
-                ).values("role")
-            )
-            .annotate(
-                is_deployed=Exists(
-                    ProjectDeployBoard.objects.filter(
-                        project_id=OuterRef("pk"),
-                        workspace__slug=self.kwargs.get("slug"),
-                    )
-                )
-            )
-            .order_by(self.kwargs.get("order_by", "-created_at"))
-            .distinct()
-        )
-
-    def get(self, request, slug, project_id=None):
-        if project_id is None:
-            sort_order_query = ProjectMember.objects.filter(
-                member=request.user,
-                project_id=OuterRef("pk"),
-                workspace__slug=self.kwargs.get("slug"),
-                is_active=True,
-            ).values("sort_order")
-            projects = (
-                self.get_queryset()
-                .annotate(sort_order=Subquery(sort_order_query))
-                .prefetch_related(
-                    Prefetch(
-                        "project_projectmember",
-                        queryset=ProjectMember.objects.filter(
-                            workspace__slug=slug,
-                            is_active=True,
-                        ).select_related("member"),
-                    )
-                )
-                .order_by(request.GET.get("order_by", "sort_order"))
-            )
-            return self.paginate(
-                request=request,
-                queryset=(projects),
-                on_results=lambda projects: ProjectSerializer(
-                    projects, many=True, fields=self.fields, expand=self.expand,
-                ).data,
-            )
-        project = self.get_queryset().get(workspace__slug=slug, pk=project_id)
-        serializer = ProjectSerializer(project, fields=self.fields, expand=self.expand,)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-    def post(self, request, slug):
-        try:
-            workspace = Workspace.objects.get(slug=slug)
-            serializer = ProjectSerializer(
-                data={**request.data}, context={"workspace_id": workspace.id}
-            )
-            if serializer.is_valid():
-                serializer.save()
-
-                # Add the user as Administrator to the project
-                project_member = ProjectMember.objects.create(
-                    project_id=serializer.data["id"], member=request.user, role=20
-                )
-                # Also create the issue property for the user
-                _ = IssueProperty.objects.create(
-                    project_id=serializer.data["id"],
-                    user=request.user,
-                )
-
-                if serializer.data["project_lead"] is not None and str(
-                    serializer.data["project_lead"]
-                ) != str(request.user.id):
-                    ProjectMember.objects.create(
-                        project_id=serializer.data["id"],
-                        member_id=serializer.data["project_lead"],
-                        role=20,
-                    )
-                    # Also create the issue property for the user
-                    IssueProperty.objects.create(
-                        project_id=serializer.data["id"],
-                        user_id=serializer.data["project_lead"],
-                    )
-
-                # Default states
-                states = [
-                    {
-                        "name": "Backlog",
-                        "color": "#A3A3A3",
-                        "sequence": 15000,
-                        "group": "backlog",
-                        "default": True,
-                    },
-                    {
-                        "name": "Todo",
-                        "color": "#3A3A3A",
-                        "sequence": 25000,
-                        "group": "unstarted",
-                    },
-                    {
-                        "name": "In Progress",
-                        "color": "#F59E0B",
-                        "sequence": 35000,
-                        "group": "started",
-                    },
-                    {
-                        "name": "Done",
-                        "color": "#16A34A",
-                        "sequence": 45000,
-                        "group": "completed",
-                    },
-                    {
-                        "name": "Cancelled",
-                        "color": "#EF4444",
-                        "sequence": 55000,
-                        "group": "cancelled",
-                    },
-                ]
-
-                State.objects.bulk_create(
-                    [
-                        State(
-                            name=state["name"],
-                            color=state["color"],
-                            project=serializer.instance,
-                            sequence=state["sequence"],
-                            workspace=serializer.instance.workspace,
-                            group=state["group"],
-                            default=state.get("default", False),
-                            created_by=request.user,
-                        )
-                        for state in states
-                    ]
-                )
-
-                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
-                serializer = ProjectSerializer(project)
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(
-                serializer.errors,
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"name": "The project name is already taken"},
-                    status=status.HTTP_410_GONE,
-                )
-        except Workspace.DoesNotExist as e:
-            return Response(
-                {"error": "Workspace does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except ValidationError as e:
-            return Response(
-                {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
-            )
-
-    def patch(self, request, slug, project_id=None):
-        try:
-            workspace = Workspace.objects.get(slug=slug)
-            project = Project.objects.get(pk=project_id)
-
-            serializer = ProjectSerializer(
-                project,
-                data={**request.data},
-                context={"workspace_id": workspace.id},
-                partial=True,
-            )
-
-            if serializer.is_valid():
-                serializer.save()
-                if serializer.data["inbox_view"]:
-                    Inbox.objects.get_or_create(
-                        name=f"{project.name} Inbox", project=project, is_default=True
-                    )
-
-                    # Create the triage state in Backlog group
-                    State.objects.get_or_create(
-                        name="Triage",
-                        group="backlog",
-                        description="Default state for managing all Inbox Issues",
-                        project_id=project_id,
-                        color="#ff7700",
-                    )
-
-                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
-                serializer = ProjectSerializer(project)
-                return Response(serializer.data, status=status.HTTP_200_OK)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except IntegrityError as e:
-            if "already exists" in str(e):
-                return Response(
-                    {"name": "The project name is already taken"},
-                    status=status.HTTP_410_GONE,
-                )
-        except (Project.DoesNotExist, Workspace.DoesNotExist):
-            return Response(
-                {"error": "Project does not exist"}, status=status.HTTP_404_NOT_FOUND
-            )
-        except ValidationError as e:
-            return Response(
-                {"identifier": "The project identifier is already taken"},
-                status=status.HTTP_410_GONE,
-            )
-
-    def delete(self, request, slug, project_id):
-        project = Project.objects.get(pk=project_id, workspace__slug=slug)
-        project.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/state.py

@@ -1,87 +0,0 @@
-# Python imports
-from itertools import groupby
-
-# Django imports
-from django.db.models import Q
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-
-# Module imports
-from .base import BaseAPIView
-from plane.api.serializers import StateSerializer
-from plane.app.permissions import ProjectEntityPermission
-from plane.db.models import State, Issue
-
-
-class StateAPIEndpoint(BaseAPIView):
-    serializer_class = StateSerializer
-    model = State
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get_queryset(self):
-        return (
-            State.objects.filter(workspace__slug=self.kwargs.get("slug"))
-            .filter(project_id=self.kwargs.get("project_id"))
-            .filter(project__project_projectmember__member=self.request.user)
-            .filter(~Q(name="Triage"))
-            .select_related("project")
-            .select_related("workspace")
-            .distinct()
-        )
-
-    def post(self, request, slug, project_id):
-        serializer = StateSerializer(data=request.data, context={"project_id": project_id})
-        if serializer.is_valid():
-            serializer.save(project_id=project_id)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-    def get(self, request, slug, project_id, state_id=None):
-        if state_id:
-            serializer = StateSerializer(self.get_queryset().get(pk=state_id))
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return self.paginate(
-            request=request,
-            queryset=(self.get_queryset()),
-            on_results=lambda states: StateSerializer(
-                states,
-                many=True,
-                fields=self.fields,
-                expand=self.expand,
-            ).data,
-        )
-
-    def delete(self, request, slug, project_id, state_id):
-        state = State.objects.get(
-            ~Q(name="Triage"),
-            pk=state_id,
-            project_id=project_id,
-            workspace__slug=slug,
-        )
-
-        if state.default:
-            return Response({"error": "Default state cannot be deleted"}, status=False)
-
-        # Check for any issues in the state
-        issue_exist = Issue.issue_objects.filter(state=state_id).exists()
-
-        if issue_exist:
-            return Response(
-                {"error": "The state is not empty, only empty states can be deleted"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        state.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    def patch(self, request, slug, project_id, state_id=None):
-        state = State.objects.get(workspace__slug=slug, project_id=project_id, pk=state_id)
-        serializer = StateSerializer(state, data=request.data, partial=True)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/app/apps.py

@@ -1,5 +1,5 @@
 from django.apps import AppConfig
 
 
-class AppApiConfig(AppConfig):
+class AppConfig(AppConfig):
     name = "plane.app"

apiserver/plane/app/serializers/issue.py

@@ -225,7 +225,6 @@ class IssueActivitySerializer(BaseSerializer):
     actor_detail = UserLiteSerializer(read_only=True, source="actor")
     issue_detail = IssueFlatSerializer(read_only=True, source="issue")
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
 
     class Meta:
         model = IssueActivity

apiserver/plane/app/serializers/project.py

@@ -214,4 +214,4 @@ class ProjectPublicMemberSerializer(BaseSerializer):
             "workspace",
             "project",
             "member",
-        ]
+        ]

apiserver/plane/app/serializers/state.py

@@ -25,4 +25,4 @@ class StateLiteSerializer(BaseSerializer):
             "color",
             "group",
         ]
-        read_only_fields = fields
+        read_only_fields = fields

apiserver/plane/app/serializers/user.py

@@ -59,7 +59,6 @@ class UserMeSerializer(BaseSerializer):
             "username",
             "theme",
             "last_workspace_id",
-            "use_case",
         ]
         read_only_fields = fields
 
@@ -155,16 +154,6 @@ class ChangePasswordSerializer(serializers.Serializer):
     """
     old_password = serializers.CharField(required=True)
     new_password = serializers.CharField(required=True)
-    confirm_password = serializers.CharField(required=True)
-
-    def validate(self, data):
-        if data.get("old_password") == data.get("new_password"):
-            raise serializers.ValidationError({"error": "New password cannot be same as old password."})
-
-        if data.get("new_password") != data.get("confirm_password"):
-            raise serializers.ValidationError({"error": "Confirm password should be same as the new password."})
-
-        return data
 
 
 class ResetPasswordSerializer(serializers.Serializer):

apiserver/plane/app/serializers/webhook.py

@@ -1,9 +1,3 @@
-# Python imports
-import urllib
-import socket
-import ipaddress
-from urllib.parse import urlparse
-
 # Third party imports
 from rest_framework import serializers
 
@@ -15,42 +9,6 @@ from plane.db.models.webhook import validate_domain, validate_schema
 class WebhookSerializer(DynamicBaseSerializer):
     url = serializers.URLField(validators=[validate_schema, validate_domain])
 
-    def validate(self, data):
-        url = data.get("url", None)
-
-        # Extract the hostname from the URL
-        hostname = urlparse(url).hostname
-        if not hostname:
-            raise serializers.ValidationError({"url": "Invalid URL: No hostname found."})
-
-        # Resolve the hostname to IP addresses
-        try:
-            ip_addresses = socket.getaddrinfo(hostname, None)
-        except socket.gaierror:
-            raise serializers.ValidationError({"url": "Hostname could not be resolved."})
-
-        if not ip_addresses:
-            raise serializers.ValidationError({"url": "No IP addresses found for the hostname."})
-
-        for addr in ip_addresses:
-            ip = ipaddress.ip_address(addr[4][0])
-            if ip.is_private or ip.is_loopback:
-                raise serializers.ValidationError({"url": "URL resolves to a blocked IP address."})
-
-        # Additional validation for multiple request domains and their subdomains
-        request = self.context.get('request')
-        disallowed_domains = ['plane.so',]  # Add your disallowed domains here
-        if request:
-            request_host = request.get_host().split(':')[0]  # Remove port if present
-            disallowed_domains.append(request_host)
-
-        # Check if hostname is a subdomain or exact match of any disallowed domain
-        if any(hostname == domain or hostname.endswith('.' + domain) for domain in disallowed_domains):
-            raise serializers.ValidationError({"url": "URL domain or its subdomain is not allowed."})
-
-        return data
-
-
     class Meta:
         model = Webhook
         fields = "__all__"

apiserver/plane/app/serializers/workspace.py

@@ -21,22 +21,6 @@ class WorkSpaceSerializer(BaseSerializer):
     total_members = serializers.IntegerField(read_only=True)
     total_issues = serializers.IntegerField(read_only=True)
 
-    def validated(self, data):
-        if data.get("slug") in [
-            "404",
-            "accounts",
-            "api",
-            "create-workspace",
-            "god-mode",
-            "installations",
-            "invitations",
-            "onboarding",
-            "profile",
-            "spaces",
-            "workspace-invitations",
-        ]:
-            raise serializers.ValidationError({"slug": "Slug is not valid"})
-
     class Meta:
         model = Workspace
         fields = "__all__"

apiserver/plane/app/urls/__init__.py

@@ -45,4 +45,4 @@ urlpatterns = [
     *workspace_urls,
     *api_urls,
     *webhook_urls,
-]
+]

apiserver/plane/app/urls/asset.py

@@ -4,7 +4,6 @@ from django.urls import path
 from plane.app.views import (
     FileAssetEndpoint,
     UserAssetsEndpoint,
-    FileAssetViewSet,
 )
 
 
@@ -29,13 +28,4 @@ urlpatterns = [
         UserAssetsEndpoint.as_view(),
         name="user-file-assets",
     ),
-    path(
-        "workspaces/file-assets/<uuid:workspace_id>/<str:asset_key>/restore/",
-        FileAssetViewSet.as_view(
-            {
-                "post": "restore",
-            }
-        ),
-        name="file-assets-restore",
-    ),
 ]

apiserver/plane/app/urls/project.py

@@ -65,7 +65,7 @@ urlpatterns = [
         name="project-member-invite",
     ),
     path(
-        "users/me/workspaces/<str:slug>/projects/invitations/",
+        "users/me/invitations/projects/",
         UserProjectInvitationsViewset.as_view(
             {
                 "get": "list",
@@ -75,7 +75,7 @@ urlpatterns = [
         name="user-project-invitations",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/join/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/join/",
         ProjectJoinEndpoint.as_view(),
         name="project-join",
     ),
@@ -169,4 +169,4 @@ urlpatterns = [
         ),
         name="project-deploy-board",
     ),
-]
+]

apiserver/plane/app/urls/user.py

@@ -63,7 +63,7 @@ urlpatterns = [
         name="user-tour",
     ),
     path(
-        "users/me/activities/",
+        "users/workspaces/<str:slug>/activities/",
         UserActivityEndpoint.as_view(),
         name="user-activities",
     ),

apiserver/plane/app/urls/workspace.py

@@ -18,7 +18,6 @@ from plane.app.views import (
     WorkspaceUserProfileEndpoint,
     WorkspaceUserProfileIssuesEndpoint,
     WorkspaceLabelsEndpoint,
-    WorkspaceUserProfileIssuesGroupedEndpoint
 )
 
 
@@ -190,11 +189,6 @@ urlpatterns = [
         WorkspaceUserProfileIssuesEndpoint.as_view(),
         name="workspace-user-profile-issues",
     ),
-    path(
-        "v3/workspaces/<str:slug>/user-issues/<uuid:user_id>/",
-        WorkspaceUserProfileIssuesGroupedEndpoint.as_view(),
-        name="workspace-user-profile-issues",
-    ),
     path(
         "workspaces/<str:slug>/labels/",
         WorkspaceLabelsEndpoint.as_view(),

apiserver/plane/app/views/__init__.py

@@ -44,7 +44,6 @@ from .workspace import (
     WorkspaceUserProfileEndpoint,
     WorkspaceUserProfileIssuesEndpoint,
     WorkspaceLabelsEndpoint,
-    WorkspaceUserProfileIssuesGroupedEndpoint
 )
 from .state import StateViewSet
 from .view import (
@@ -61,7 +60,7 @@ from .cycle import (
     TransferCycleIssueEndpoint,
     CycleIssueGroupedEndpoint,
 )
-from .asset import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
+from .asset import FileAssetEndpoint, UserAssetsEndpoint
 from .issue import (
     IssueViewSet,
     IssueListEndpoint,
@@ -169,4 +168,4 @@ from .exporter import ExportIssuesEndpoint
 
 from .config import ConfigurationEndpoint
 
-from .webhook import WebhookEndpoint, WebhookLogsEndpoint, WebhookSecretRegenerateEndpoint
+from .webhook import WebhookEndpoint, WebhookLogsEndpoint, WebhookSecretRegenerateEndpoint

apiserver/plane/app/views/asset.py

@@ -1,16 +1,16 @@
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
-from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
+from rest_framework.parsers import MultiPartParser, FormParser
 
 # Module imports
-from .base import BaseAPIView, BaseViewSet
+from .base import BaseAPIView
 from plane.db.models import FileAsset, Workspace
 from plane.app.serializers import FileAssetSerializer
 
 
 class FileAssetEndpoint(BaseAPIView):
-    parser_classes = (MultiPartParser, FormParser, JSONParser,)
+    parser_classes = (MultiPartParser, FormParser)
 
     """
     A viewset for viewing and editing task instances.
@@ -25,6 +25,7 @@ class FileAssetEndpoint(BaseAPIView):
         else:
             return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
 
+
     def post(self, request, slug):
         serializer = FileAssetSerializer(data=request.data)
         if serializer.is_valid():
@@ -33,22 +34,15 @@ class FileAssetEndpoint(BaseAPIView):
             serializer.save(workspace_id=workspace.id)
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    
+
+
     def delete(self, request, workspace_id, asset_key):
         asset_key = str(workspace_id) + "/" + asset_key
         file_asset = FileAsset.objects.get(asset=asset_key)
-        file_asset.is_deleted = True
-        file_asset.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class FileAssetViewSet(BaseViewSet):
-
-    def restore(self, request, workspace_id, asset_key):
-        asset_key = str(workspace_id) + "/" + asset_key
-        file_asset = FileAsset.objects.get(asset=asset_key)
-        file_asset.is_deleted = False
-        file_asset.save()
+        # Delete the file from storage
+        file_asset.asset.delete(save=False)
+        # Delete the file object
+        file_asset.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
@@ -56,23 +50,25 @@ class UserAssetsEndpoint(BaseAPIView):
     parser_classes = (MultiPartParser, FormParser)
 
     def get(self, request, asset_key):
-        files = FileAsset.objects.filter(asset=asset_key, created_by=request.user)
-        if files.exists():
-            serializer = FileAssetSerializer(files, context={"request": request})
-            return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
-        else:
-            return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
+            files = FileAsset.objects.filter(asset=asset_key, created_by=request.user)
+            if files.exists():
+                serializer = FileAssetSerializer(files, context={"request": request})
+                return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
+            else:
+                return Response({"error": "Asset key does not exist", "status": False}, status=status.HTTP_200_OK)
 
     def post(self, request):
-        serializer = FileAssetSerializer(data=request.data)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+            serializer = FileAssetSerializer(data=request.data)
+            if serializer.is_valid():
+                serializer.save()
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
 
     def delete(self, request, asset_key):
-        file_asset = FileAsset.objects.get(asset=asset_key, created_by=request.user)
-        file_asset.is_deleted = True
-        file_asset.save()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+            file_asset = FileAsset.objects.get(asset=asset_key, created_by=request.user)
+            # Delete the file from storage
+            file_asset.asset.delete(save=False)
+            # Delete the file object
+            file_asset.delete()
+            return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/auth_extended.py

@@ -131,13 +131,21 @@ class ChangePasswordEndpoint(BaseAPIView):
 
         user = User.objects.get(pk=request.user.id)
         if serializer.is_valid():
-            if not user.check_password(serializer.data.get("old_password")):
+            # Check old password
+            if not user.object.check_password(serializer.data.get("old_password")):
                 return Response(
-                    {"error": "Old password is not correct"},
+                    {"old_password": ["Wrong password."]},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
             # set_password also hashes the password that the user will get
-            user.set_password(serializer.data.get("new_password"))
-            user.save()
-            return Response({"message": "Password updated successfully"}, status=status.HTTP_200_OK)
+            self.object.set_password(serializer.data.get("new_password"))
+            self.object.save()
+            response = {
+                "status": "success",
+                "code": status.HTTP_200_OK,
+                "message": "Password updated successfully",
+            }
+
+            return Response(response)
+
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/app/views/authentication.py

@@ -1,5 +1,4 @@
 # Python imports
-import os
 import uuid
 import random
 import string
@@ -33,8 +32,7 @@ from plane.db.models import (
 )
 from plane.settings.redis import redis_instance
 from plane.bgtasks.magic_link_code_task import magic_link
-from plane.license.models import InstanceConfiguration
-from plane.license.utils.instance_value import get_configuration_value
+
 
 def get_tokens_for_user(user):
     refresh = RefreshToken.for_user(user)
@@ -48,17 +46,7 @@ class SignUpEndpoint(BaseAPIView):
     permission_classes = (AllowAny,)
 
     def post(self, request):
-        instance_configuration = InstanceConfiguration.objects.values("key", "value")
-        if (
-            not get_configuration_value(
-                instance_configuration,
-                "ENABLE_SIGNUP",
-                os.environ.get("ENABLE_SIGNUP", "0"),
-            )
-            and not WorkspaceMemberInvite.objects.filter(
-                email=request.user.email
-            ).exists()
-        ):
+        if not settings.ENABLE_SIGNUP:
             return Response(
                 {
                     "error": "New account creation is disabled. Please contact your site administrator"
@@ -236,9 +224,15 @@ class SignInEndpoint(BaseAPIView):
                 },
                 status=status.HTTP_403_FORBIDDEN,
             )
+        if not user.is_active:
+            return Response(
+                {
+                    "error": "Your account has been deactivated. Please contact your site administrator."
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
 
         # settings last active for the user
-        user.is_active = True
         user.last_active = timezone.now()
         user.last_login_time = timezone.now()
         user.last_login_ip = request.META.get("REMOTE_ADDR")
@@ -366,24 +360,6 @@ class MagicSignInGenerateEndpoint(BaseAPIView):
     def post(self, request):
         email = request.data.get("email", False)
 
-        instance_configuration = InstanceConfiguration.objects.values("key", "value")
-        if (
-            not get_configuration_value(
-                instance_configuration,
-                "ENABLE_MAGIC_LINK_LOGIN",
-                os.environ.get("ENABLE_MAGIC_LINK_LOGIN"),
-            )
-            and not WorkspaceMemberInvite.objects.filter(
-                email=request.user.email
-            ).exists()
-        ):
-            return Response(
-                {
-                    "error": "New account creation is disabled. Please contact your site administrator"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
         if not email:
             return Response(
                 {"error": "Please provide a valid email address"},
@@ -467,6 +443,13 @@ class MagicSignInEndpoint(BaseAPIView):
             if str(token) == str(user_token):
                 if User.objects.filter(email=email).exists():
                     user = User.objects.get(email=email)
+                    if not user.is_active:
+                        return Response(
+                            {
+                                "error": "Your account has been deactivated. Please contact your site administrator."
+                            },
+                            status=status.HTTP_403_FORBIDDEN,
+                        )
                     try:
                         # Send event to Jitsu for tracking
                         if settings.ANALYTICS_BASE_API:
@@ -523,7 +506,6 @@ class MagicSignInEndpoint(BaseAPIView):
                     except RequestException as e:
                         capture_exception(e)
 
-                user.is_active = True
                 user.last_active = timezone.now()
                 user.last_login_time = timezone.now()
                 user.last_login_ip = request.META.get("REMOTE_ADDR")

apiserver/plane/app/views/base.py

@@ -25,7 +25,7 @@ from django_filters.rest_framework import DjangoFilterBackend
 # Module imports
 from plane.utils.paginator import BasePaginator
 from plane.bgtasks.webhook_task import send_webhook
-
+from plane.bgtasks.track_events import track_event
 
 class TimezoneMixin:
     """
@@ -43,30 +43,49 @@ class TimezoneMixin:
 
 class WebhookMixin:
     webhook_event = None
-    bulk = False
 
-    def finalize_response(self, request, response, *args, **kwargs):
-        response = super().finalize_response(request, response, *args, **kwargs)
+    def initial_request(self, request, response, *args, **kwargs):
+        response = super().initial_request(request, response, *args, **kwargs)
 
-        # Check for the case should webhook be sent
         if (
             self.webhook_event
             and self.request.method in ["POST", "PATCH", "DELETE"]
             and response.status_code in [200, 201, 204]
         ):
-            # Push the object to delay
             send_webhook.delay(
                 event=self.webhook_event,
-                payload=response.data,
-                kw=self.kwargs,
+                event_data=json.dumps(response.data, cls=DjangoJSONEncoder),
                 action=self.request.method,
                 slug=self.workspace_slug,
-                bulk=self.bulk,
             )
 
         return response
 
 
+class AnalyticsMixin:
+    analytic_event = None
+    print("did it come here or not")
+
+    def initial(self, request, *args, **kwargs):
+        super().initial(request, *args, **kwargs)
+        print("hieieie")
+        print(self.workspace_slug,"workspace_slug")
+        # if (
+        #     self.analytic_event
+        #     and self.request.method in ["POST", "PATCH", "DELETE"]
+        #     and response.status_code in [200, 201, 204]
+        # ):
+        #     print(self.workspace_slug,"workspace_slug")
+        #     track_event.delay(
+        #         event_name=self.analytic_event,
+        #         slug=self.workspace_slug,
+        #         project_id=self.project_id,
+        #         user_id=self.request.user.id,
+        #     )
+
+        # return response
+    
+
 class BaseViewSet(TimezoneMixin, ModelViewSet, BasePaginator):
     model = None
 

apiserver/plane/app/views/config.py

@@ -45,23 +45,22 @@ class ConfigurationEndpoint(BaseAPIView):
                 get_configuration_value(
                     instance_configuration,
                     "EMAIL_HOST_USER",
-                    os.environ.get("EMAIL_HOST_USER", None),
+                    os.environ.get("GITHUB_APP_NAME", None),
                 ),
             )
             and bool(
                 get_configuration_value(
                     instance_configuration,
                     "EMAIL_HOST_PASSWORD",
-                    os.environ.get("EMAIL_HOST_PASSWORD", None),
+                    os.environ.get("GITHUB_APP_NAME", None),
                 )
             )
         ) and get_configuration_value(
-            instance_configuration, "ENABLE_MAGIC_LINK_LOGIN", "1"
+            instance_configuration, "ENABLE_MAGIC_LINK_LOGIN", "0"
         ) == "1"
-
         data["email_password_login"] = (
             get_configuration_value(
-                instance_configuration, "ENABLE_EMAIL_PASSWORD", "1"
+                instance_configuration, "ENABLE_EMAIL_PASSWORD", "0"
             )
             == "1"
         )
@@ -93,15 +92,4 @@ class ConfigurationEndpoint(BaseAPIView):
             )
         )
 
-        # Open AI settings
-        data["has_openai_configured"] = bool(
-            get_configuration_value(
-                instance_configuration,
-                "OPENAI_API_KEY",
-                os.environ.get("OPENAI_API_KEY", None),
-            )
-        )
-
-        data["file_size_limit"] = float(os.environ.get("FILE_SIZE_LIMIT", 5242880))
-
         return Response(data, status=status.HTTP_200_OK)

apiserver/plane/app/views/cycle.py

@@ -502,10 +502,7 @@ class CycleViewSet(WebhookMixin, BaseViewSet):
 class CycleIssueViewSet(WebhookMixin, BaseViewSet):
     serializer_class = CycleIssueSerializer
     model = CycleIssue
-
-    webhook_event = "cycle_issue"
-    bulk = True
-
+    webhook_event = "cycle"
     permission_classes = [
         ProjectEntityPermission,
     ]
@@ -691,6 +688,7 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
             pk=pk, workspace__slug=slug, project_id=project_id, cycle_id=cycle_id
         )
         issue_id = cycle_issue.issue_id
+        cycle_issue.delete()
         issue_activity.delay(
             type="cycle.activity.deleted",
             requested_data=json.dumps(
@@ -700,12 +698,11 @@ class CycleIssueViewSet(WebhookMixin, BaseViewSet):
                 }
             ),
             actor_id=str(self.request.user.id),
-            issue_id=str(cycle_issue.issue_id),
+            issue_id=str(self.kwargs.get("pk", None)),
             project_id=str(self.kwargs.get("project_id", None)),
             current_instance=None,
             epoch=int(timezone.now().timestamp()),
         )
-        cycle_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
@@ -871,4 +868,4 @@ class TransferCycleIssueEndpoint(BaseAPIView):
             updated_cycles, ["cycle_id"], batch_size=100
         )
 
-        return Response({"message": "Success"}, status=status.HTTP_200_OK)
+        return Response({"message": "Success"}, status=status.HTTP_200_OK)

apiserver/plane/app/views/external.py

@@ -1,6 +1,6 @@
 # Python imports
 import requests
-import os
+
 # Third party imports
 from openai import OpenAI
 from rest_framework.response import Response
@@ -27,8 +27,8 @@ class GPTIntegrationEndpoint(BaseAPIView):
 
         # Get the configuration value
         instance_configuration = InstanceConfiguration.objects.values("key", "value")
-        api_key = get_configuration_value(instance_configuration, "OPENAI_API_KEY", os.environ.get("OPENAI_API_KEY"))
-        gpt_engine = get_configuration_value(instance_configuration, "GPT_ENGINE", os.environ.get("GPT_ENGINE", "gpt-3.5-turbo"))
+        api_key = get_configuration_value(instance_configuration, "OPENAI_API_KEY")
+        gpt_engine = get_configuration_value(instance_configuration, "GPT_ENGINE")
 
         # Check the keys
         if not api_key or not gpt_engine:
@@ -47,6 +47,10 @@ class GPTIntegrationEndpoint(BaseAPIView):
 
         final_text = task + "\n" + prompt
 
+        instance_configuration = InstanceConfiguration.objects.values("key", "value")
+        
+        gpt_engine = get_configuration_value(instance_configuration, "GPT_ENGINE")
+
         client = OpenAI(
             api_key=api_key,
         )
@@ -81,22 +85,14 @@ class ReleaseNotesEndpoint(BaseAPIView):
 class UnsplashEndpoint(BaseAPIView):
 
     def get(self, request):
-        instance_configuration = InstanceConfiguration.objects.values("key", "value")
-        unsplash_access_key = get_configuration_value(instance_configuration, "UNSPLASH_ACCESS_KEY", os.environ.get("UNSPLASH_ACCESS_KEY"))
-
-        # Check unsplash access key
-        if not unsplash_access_key:
-            return Response([], status=status.HTTP_200_OK)
-
-        # Query parameters
         query = request.GET.get("query", False)
         page = request.GET.get("page", 1)
         per_page = request.GET.get("per_page", 20)
 
         url = (
-            f"https://api.unsplash.com/search/photos/?client_id={unsplash_access_key}&query={query}&page=${page}&per_page={per_page}"
+            f"https://api.unsplash.com/search/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
             if query
-            else f"https://api.unsplash.com/photos/?client_id={unsplash_access_key}&page={page}&per_page={per_page}"
+            else f"https://api.unsplash.com/photos/?client_id={settings.UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
         )
 
         headers = {

apiserver/plane/app/views/inbox.py

@@ -356,3 +356,4 @@ class InboxIssueViewSet(BaseViewSet):
         inbox_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
+

apiserver/plane/app/views/issue.py

@@ -596,7 +596,7 @@ class IssueActivityEndpoint(BaseAPIView):
 class IssueCommentViewSet(WebhookMixin, BaseViewSet):
     serializer_class = IssueCommentSerializer
     model = IssueComment
-    webhook_event = "issue_comment"
+    webhook_event = "issue-comment"
     permission_classes = [
         ProjectLitePermission,
     ]
@@ -1750,4 +1750,4 @@ class IssueDraftViewSet(BaseViewSet):
             current_instance=current_instance,
             epoch=int(timezone.now().timestamp()),
         )
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/module.py

@@ -283,12 +283,9 @@ class ModuleViewSet(WebhookMixin, BaseViewSet):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
-class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
+class ModuleIssueViewSet(BaseViewSet):
     serializer_class = ModuleIssueSerializer
     model = ModuleIssue
-    webhook_event = "module_issue"
-    bulk = True
-
 
     filterset_fields = [
         "issue__labels__id",
@@ -464,6 +461,7 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
         module_issue = ModuleIssue.objects.get(
             workspace__slug=slug, project_id=project_id, module_id=module_id, pk=pk
         )
+        module_issue.delete()
         issue_activity.delay(
             type="module.activity.deleted",
             requested_data=json.dumps(
@@ -473,12 +471,11 @@ class ModuleIssueViewSet(WebhookMixin, BaseViewSet):
                 }
             ),
             actor_id=str(request.user.id),
-            issue_id=str(module_issue.issue_id),
+            issue_id=str(pk),
             project_id=str(project_id),
             current_instance=None,
             epoch=int(timezone.now().timestamp()),
         )
-        module_issue.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
@@ -586,4 +583,4 @@ class ModuleFavoriteViewSet(BaseViewSet):
             module_id=module_id,
         )
         module_favorite.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/oauth.py

@@ -30,8 +30,6 @@ from plane.db.models import (
     ProjectMember,
 )
 from .base import BaseAPIView
-from plane.license.models import InstanceConfiguration
-from plane.license.utils.instance_value import get_configuration_value
 
 
 def get_tokens_for_user(user):
@@ -139,30 +137,6 @@ class OauthEndpoint(BaseAPIView):
             id_token = request.data.get("credential", False)
             client_id = request.data.get("clientId", False)
 
-            instance_configuration = InstanceConfiguration.objects.values(
-                "key", "value"
-            )
-            if (
-                not get_configuration_value(
-                    instance_configuration,
-                    "GOOGLE_CLIENT_ID",
-                    os.environ.get("GOOGLE_CLIENT_ID"),
-                )
-                or not get_configuration_value(
-                    instance_configuration,
-                    "GITHUB_CLIENT_ID",
-                    os.environ.get("GITHUB_CLIENT_ID"),
-                )
-            ) and not WorkspaceMemberInvite.objects.filter(
-                email=request.user.email
-            ).exists():
-                return Response(
-                    {
-                        "error": "New account creation is disabled. Please contact your site administrator"
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
             if not medium or not id_token:
                 return Response(
                     {
@@ -200,7 +174,15 @@ class OauthEndpoint(BaseAPIView):
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            user.is_active = True
+            ## Login Case
+            if not user.is_active:
+                return Response(
+                    {
+                        "error": "Your account has been deactivated. Please contact your site administrator."
+                    },
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
             user.last_active = timezone.now()
             user.last_login_time = timezone.now()
             user.last_login_ip = request.META.get("REMOTE_ADDR")
@@ -257,8 +239,7 @@ class OauthEndpoint(BaseAPIView):
                         else 15,
                         member=user,
                         created_by_id=project_member_invite.created_by_id,
-                    )
-                    for project_member_invite in project_member_invites
+                    ) for project_member_invite in project_member_invites
                 ],
                 ignore_conflicts=True,
             )
@@ -392,8 +373,7 @@ class OauthEndpoint(BaseAPIView):
                         else 15,
                         member=user,
                         created_by_id=project_member_invite.created_by_id,
-                    )
-                    for project_member_invite in project_member_invites
+                    ) for project_member_invite in project_member_invites
                 ],
                 ignore_conflicts=True,
             )

apiserver/plane/app/views/page.py

@@ -136,9 +136,7 @@ class PageViewSet(BaseViewSet):
             )
 
     def lock(self, request, slug, project_id, page_id):
-        page = Page.objects.filter(
-            pk=page_id, workspace__slug=slug, project_id=project_id
-        ).first()
+        page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)
 
         # only the owner can lock the page
         if request.user.id != page.owned_by_id:
@@ -151,9 +149,7 @@ class PageViewSet(BaseViewSet):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def unlock(self, request, slug, project_id, page_id):
-        page = Page.objects.filter(
-            pk=page_id, workspace__slug=slug, project_id=project_id
-        ).first()
+        page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)
 
         # only the owner can unlock the page
         if request.user.id != page.owned_by_id:
@@ -168,8 +164,66 @@ class PageViewSet(BaseViewSet):
 
     def list(self, request, slug, project_id):
         queryset = self.get_queryset().filter(archived_at__isnull=True)
+        page_view = request.GET.get("page_view", False)
+
+        if not page_view:
+            return Response(
+                {"error": "Page View parameter is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # All Pages
+        if page_view == "all":
+            return Response(
+                PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            )
+
+        # Recent pages
+        if page_view == "recent":
+            current_time = date.today()
+            day_before = current_time - timedelta(days=1)
+            todays_pages = queryset.filter(updated_at__date=date.today())
+            yesterdays_pages = queryset.filter(updated_at__date=day_before)
+            earlier_this_week = queryset.filter(
+                updated_at__date__range=(
+                    (timezone.now() - timedelta(days=7)),
+                    (timezone.now() - timedelta(days=2)),
+                )
+            )
+            return Response(
+                {
+                    "today": PageSerializer(todays_pages, many=True).data,
+                    "yesterday": PageSerializer(yesterdays_pages, many=True).data,
+                    "earlier_this_week": PageSerializer(
+                        earlier_this_week, many=True
+                    ).data,
+                },
+                status=status.HTTP_200_OK,
+            )
+
+        # Favorite Pages
+        if page_view == "favorite":
+            queryset = queryset.filter(is_favorite=True)
+            return Response(
+                PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            )
+
+        # My pages
+        if page_view == "created_by_me":
+            queryset = queryset.filter(owned_by=request.user)
+            return Response(
+                PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            )
+
+        # Created by other Pages
+        if page_view == "created_by_other":
+            queryset = queryset.filter(~Q(owned_by=request.user), access=0)
+            return Response(
+                PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            )
+
         return Response(
-            PageSerializer(queryset, many=True).data, status=status.HTTP_200_OK
+            {"error": "No matching view found"}, status=status.HTTP_400_BAD_REQUEST
         )
 
     def archive(self, request, slug, project_id, page_id):
@@ -183,7 +237,7 @@ class PageViewSet(BaseViewSet):
 
         unarchive_archive_page_and_descendants(page_id, datetime.now())
 
-        return Response(status=status.HTTP_400_BAD_REQUEST)
+        return Response(status=status.HTTP_204_NO_CONTENT)
 
     def unarchive(self, request, slug, project_id, page_id):
         page = Page.objects.get(pk=page_id, workspace__slug=slug, project_id=project_id)
@@ -193,44 +247,29 @@ class PageViewSet(BaseViewSet):
                 {"error": "Only the owner of the page can unarchive a page"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-
+        
         # if parent page is archived then the page will be un archived breaking the hierarchy
         if page.parent_id and page.parent.archived_at:
             page.parent = None
-            page.save(update_fields=["parent"])
+            page.save(update_fields=['parent'])
 
         unarchive_archive_page_and_descendants(page_id, None)
 
         return Response(status=status.HTTP_204_NO_CONTENT)
 
     def archive_list(self, request, slug, project_id):
-        pages = Page.objects.filter(
-            project_id=project_id,
-            workspace__slug=slug,
-        ).filter(archived_at__isnull=False)
+        pages = (
+            Page.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+            )
+            .filter(archived_at__isnull=False)
+        )
 
         return Response(
             PageSerializer(pages, many=True).data, status=status.HTTP_200_OK
         )
 
-    def destroy(self, request, slug, project_id, pk):
-        page = Page.objects.get(pk=pk, workspace__slug=slug, project_id=project_id)
-
-        if page.archived_at is None:
-            return Response(
-                {"error": "The page should be archived before deleting"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # remove parent from all the children
-        _ = Page.objects.filter(
-            parent_id=pk, project_id=project_id, workspace__slug=slug
-        ).update(parent=None)
-
-
-        page.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
 
 class PageFavoriteViewSet(BaseViewSet):
     permission_classes = [
@@ -267,7 +306,6 @@ class PageFavoriteViewSet(BaseViewSet):
         page_favorite.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-
 class PageLogEndpoint(BaseAPIView):
     permission_classes = [
         ProjectEntityPermission,
@@ -359,4 +397,4 @@ class SubPagesEndpoint(BaseAPIView):
         )
         return Response(
             SubPageSerializer(pages, many=True).data, status=status.HTTP_200_OK
-        )
+        )

apiserver/plane/app/views/project.py

@@ -26,7 +26,7 @@ from rest_framework import serializers
 from rest_framework.permissions import AllowAny
 
 # Module imports
-from .base import BaseViewSet, BaseAPIView, WebhookMixin
+from .base import BaseViewSet, BaseAPIView, WebhookMixin, AnalyticsMixin
 from plane.app.serializers import (
     ProjectSerializer,
     ProjectListSerializer,
@@ -64,10 +64,11 @@ from plane.db.models import (
 from plane.bgtasks.project_invitation_task import project_invitation
 
 
-class ProjectViewSet(WebhookMixin, BaseViewSet):
+class ProjectViewSet(WebhookMixin, AnalyticsMixin, BaseViewSet):
     serializer_class = ProjectSerializer
     model = Project
     webhook_event = "project"
+    analytic_event = "project"
 
     permission_classes = [
         ProjectBasePermission,
@@ -388,7 +389,7 @@ class ProjectInvitationsViewset(BaseViewSet):
                 {"error": "You cannot invite a user with higher role"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-
+        
         workspace = Workspace.objects.get(slug=slug)
 
         project_invitations = []
@@ -424,7 +425,7 @@ class ProjectInvitationsViewset(BaseViewSet):
         project_invitations = ProjectMemberInvite.objects.bulk_create(
             project_invitations, batch_size=10, ignore_conflicts=True
         )
-        current_site = request.META.get("HTTP_ORIGIN")
+        current_site = request.META.get('HTTP_ORIGIN')
 
         # Send invitations
         for invitation in project_invitations:
@@ -469,13 +470,6 @@ class UserProjectInvitationsViewset(BaseViewSet):
         workspace_role = workspace_member.role
         workspace = workspace_member.workspace
 
-        # If the user was already part of workspace
-        _ = ProjectMember.objects.filter(
-            workspace__slug=slug,
-            project_id__in=project_ids,
-            member=request.user,
-        ).update(is_active=True)
-
         ProjectMember.objects.bulk_create(
             [
                 ProjectMember(
@@ -982,7 +976,7 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
             aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
         )
         params = {
-            "Bucket": settings.AWS_STORAGE_BUCKET_NAME,
+            "Bucket": settings.AWS_S3_BUCKET_NAME,
             "Prefix": "static/project-cover/",
         }
 
@@ -994,7 +988,7 @@ class ProjectPublicCoverImagesEndpoint(BaseAPIView):
                     "/"
                 ):  # This line ensures we're only getting files, not "sub-folders"
                     files.append(
-                        f"https://{settings.AWS_STORAGE_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
+                        f"https://{settings.AWS_S3_BUCKET_NAME}.s3.{settings.AWS_REGION}.amazonaws.com/{content['Key']}"
                     )
 
         return Response(files, status=status.HTTP_200_OK)
@@ -1047,4 +1041,4 @@ class ProjectDeployBoardViewSet(BaseViewSet):
         project_deploy_board.save()
 
         serializer = ProjectDeployBoardSerializer(project_deploy_board)
-        return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.data, status=status.HTTP_200_OK)

apiserver/plane/app/views/state.py

@@ -89,4 +89,4 @@ class StateViewSet(BaseViewSet):
             )
 
         state.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/user.py

@@ -12,14 +12,11 @@ from plane.app.serializers import (
 )
 
 from plane.app.views.base import BaseViewSet, BaseAPIView
-from plane.db.models import User, IssueActivity, WorkspaceMember, ProjectMember
+from plane.db.models import User, IssueActivity, WorkspaceMember
 from plane.license.models import Instance, InstanceAdmin
 from plane.utils.paginator import BasePaginator
 
 
-from django.db.models import Q, F, Count, Case, When, Value, IntegerField
-
-
 class UserEndpoint(BaseViewSet):
     serializer_class = UserSerializer
     model = User
@@ -48,68 +45,13 @@ class UserEndpoint(BaseViewSet):
     def deactivate(self, request):
         # Check all workspace user is active
         user = self.get_object()
-
-        projects_to_deactivate = []
-        workspaces_to_deactivate = []
-
-        
-        projects = ProjectMember.objects.filter(
-            member=request.user, is_active=True
-        ).annotate(
-            other_admin_exists=Count(
-                Case(
-                    When(Q(role=20, is_active=True) & ~Q(member=request.user), then=1),
-                    default=0,
-                    output_field=IntegerField(),
-                )
-            ),
-            total_members=Count("id"),
-        )
-
-        for project in projects:
-            if project.other_admin_exists > 0 or (project.total_members == 1):
-                project.is_active = False
-                projects_to_deactivate.append(project)
-            else:
-                return Response(
-                    {
-                        "error": "You cannot deactivate account as you are the only admin in some projects."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-        workspaces = WorkspaceMember.objects.filter(
-            member=request.user, is_active=True
-        ).annotate(
-            other_admin_exists=Count(
-                Case(
-                    When(Q(role=20, is_active=True) & ~Q(member=request.user), then=1),
-                    default=0,
-                    output_field=IntegerField(),
-                )
-            ),
-            total_members=Count("id"),
-        )
-
-        for workspace in workspaces:
-            if workspace.other_admin_exists > 0 or (workspace.total_members == 1):
-                workspace.is_active = False
-                workspaces_to_deactivate.append(workspace)
-            else:
-                return Response(
-                    {
-                        "error": "You cannot deactivate account as you are the only admin in some workspaces."
-                    },
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
-        ProjectMember.objects.bulk_update(
-            projects_to_deactivate, ["is_active"], batch_size=100
-        )
-
-        WorkspaceMember.objects.bulk_update(
-            workspaces_to_deactivate, ["is_active"], batch_size=100
-        )
+        if WorkspaceMember.objects.filter(member=request.user, is_active=True).exists():
+            return Response(
+                {
+                    "error": "User cannot deactivate account as user is active in some workspaces"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
 
         # Deactivate the user
         user.is_active = False
@@ -134,9 +76,9 @@ class UpdateUserTourCompletedEndpoint(BaseAPIView):
 
 
 class UserActivityEndpoint(BaseAPIView, BasePaginator):
-    def get(self, request):
+    def get(self, request, slug):
         queryset = IssueActivity.objects.filter(
-            actor=request.user
+            actor=request.user, workspace__slug=slug
         ).select_related("actor", "workspace", "issue", "project")
 
         return self.paginate(

apiserver/plane/app/views/view.py

@@ -257,4 +257,4 @@ class IssueViewFavoriteViewSet(BaseViewSet):
             view_id=view_id,
         )
         view_favourite.delete()
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/app/views/webhook.py

@@ -20,10 +20,9 @@ class WebhookEndpoint(BaseAPIView):
 
     def post(self, request, slug):
         workspace = Workspace.objects.get(slug=slug)
+
         try:
-            serializer = WebhookSerializer(
-                data=request.data, context={"request": request}
-            )
+            serializer = WebhookSerializer(data=request.data)
             if serializer.is_valid():
                 serializer.save(workspace_id=workspace.id)
                 return Response(serializer.data, status=status.HTTP_201_CREATED)
@@ -80,7 +79,6 @@ class WebhookEndpoint(BaseAPIView):
         serializer = WebhookSerializer(
             webhook,
             data=request.data,
-            context={request: request},
             partial=True,
             fields=(
                 "id",

apiserver/plane/app/views/workspace.py

@@ -590,7 +590,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
                 member_with_role=Count(
                     "project_projectmember",
                     filter=Q(
-                        project_projectmember__member_id=workspace_member.id,
+                        project_projectmember__member_id=request.user.id,
                         project_projectmember__role=20,
                     ),
                 ),
@@ -600,7 +600,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         ):
             return Response(
                 {
-                    "error": "User is a part of some projects where they are the only admin, they should either leave that project or promote another user to admin."
+                    "error": "User is part of some projects where they are the only admin you should leave that project first"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
@@ -635,7 +635,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         ):
             return Response(
                 {
-                    "error": "You cannot leave the workspace as you are the only admin of the workspace you will have to either delete the workspace or promote another user to admin."
+                    "error": "You cannot leave the workspace as your the only admin of the workspace you will have to either delete the workspace or create an another admin"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
@@ -656,7 +656,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         ):
             return Response(
                 {
-                    "error": "You are a part of some projects where you are the only admin, you should either leave the project or promote another user to admin."
+                    "error": "User is part of some projects where they are the only admin you should leave that project first"
                 },
                 status=status.HTTP_400_BAD_REQUEST,
             )
@@ -1313,62 +1313,6 @@ class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
         return Response(issues, status=status.HTTP_200_OK)
 
 
-
-class WorkspaceUserProfileIssuesGroupedEndpoint(BaseAPIView):
-
-    permission_classes = [
-        WorkspaceViewerPermission,
-    ]
-
-    def get(self, request, slug, user_id):
-        filters = issue_filters(request.query_params, "GET")
-        fields = [field for field in request.GET.get("fields", "").split(",") if field]
-
-        issue_queryset = (
-            Issue.issue_objects.filter(
-                Q(assignees__in=[user_id])
-                | Q(created_by_id=user_id)
-                | Q(issue_subscribers__subscriber_id=user_id),
-                workspace__slug=slug,
-                project__project_projectmember__member=request.user,
-            )
-            .filter(**filters)
-            .annotate(
-                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .select_related("project", "workspace", "state", "parent")
-            .prefetch_related("assignees", "labels")
-            .prefetch_related(
-                Prefetch(
-                    "issue_reactions",
-                    queryset=IssueReaction.objects.select_related("actor"),
-                )
-            )
-            .order_by("-created_at")
-            .annotate(
-                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-            .annotate(
-                attachment_count=IssueAttachment.objects.filter(issue=OuterRef("id"))
-                .order_by()
-                .annotate(count=Func(F("id"), function="Count"))
-                .values("count")
-            )
-        ).distinct()
-
-        issues = IssueLiteSerializer(issue_queryset, many=True, fields=fields if fields else None).data
-        issue_dict = {str(issue["id"]): issue for issue in issues}
-        return Response(
-            issue_dict,
-            status=status.HTTP_200_OK,
-        )
-
 class WorkspaceLabelsEndpoint(BaseAPIView):
     permission_classes = [
         WorkspaceViewerPermission,

apiserver/plane/authentication/apps.py

@@ -2,4 +2,4 @@ from django.apps import AppConfig
 
 
 class ApiConfig(AppConfig):
-    name = "plane.api"
+    name = "plane.authentication"

apiserver/plane/bgtasks/analytic_plot_export.py

@@ -1,7 +1,6 @@
 # Python imports
 import csv
 import io
-import os
 
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
@@ -33,7 +32,7 @@ row_mapping = {
     "priority": "Priority",
     "estimate": "Estimate",
     "issue_cycle__cycle_id": "Cycle",
-    "issue_module__module_id": "Module",
+    "issue_module__module_id": "Module"
 }
 
 ASSIGNEE_ID = "assignees__id"
@@ -52,48 +51,17 @@ def send_export_email(email, slug, csv_buffer):
     csv_buffer.seek(0)
 
     # Configure email connection from the database
-    instance_configuration = InstanceConfiguration.objects.filter(
-        key__startswith="EMAIL_"
-    ).values("key", "value")
+    instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
     connection = get_connection(
-        host=get_configuration_value(
-            instance_configuration, "EMAIL_HOST", os.environ.get("EMAIL_HOST")
-        ),
-        port=int(
-            get_configuration_value(
-                instance_configuration, "EMAIL_PORT", os.environ.get("EMAIL_PORT")
-            )
-        ),
-        username=get_configuration_value(
-            instance_configuration,
-            "EMAIL_HOST_USER",
-            os.environ.get("EMAIL_HOST_USER"),
-        ),
-        password=get_configuration_value(
-            instance_configuration,
-            "EMAIL_HOST_PASSWORD",
-            os.environ.get("EMAIL_HOST_PASSWORD"),
-        ),
-        use_tls=bool(
-            get_configuration_value(
-                instance_configuration,
-                "EMAIL_USE_TLS",
-                os.environ.get("EMAIL_USE_TLS", "1"),
-            )
-        ),
+        host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
+        port=int(get_configuration_value(instance_configuration, "EMAIL_PORT", "587")),
+        username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
+        password=get_configuration_value(instance_configuration, "EMAIL_HOST_PASSWORD"),
+        use_tls=bool(get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")),
+        use_ssl=bool(get_configuration_value(instance_configuration, "EMAIL_USE_SSL", "0")),
     )
 
-    msg = EmailMultiAlternatives(
-        subject=subject,
-        body=text_content,
-        from_email=get_configuration_value(
-            instance_configuration,
-            "EMAIL_FROM",
-            os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
-        ),
-        to=[email],
-        connection=connection,
-    )
+    msg = EmailMultiAlternatives(subject=subject, body=text_content, from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
     msg.attach(f"{slug}-analytics.csv", csv_buffer.getvalue())
     msg.send(fail_silently=False)
 

apiserver/plane/bgtasks/email_verification_task.py

@@ -1,6 +1,3 @@
-# Python imports
-import os
-
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
 from django.template.loader import render_to_string
@@ -17,13 +14,15 @@ from sentry_sdk import capture_exception
 from plane.license.models import InstanceConfiguration
 from plane.license.utils.instance_value import get_configuration_value
 
-
 @shared_task
 def email_verification(first_name, email, token, current_site):
+
     try:
         realtivelink = "/request-email-verification/" + "?token=" + str(token)
         abs_url = current_site + realtivelink
 
+        from_email_string = settings.EMAIL_FROM
+
         subject = "Verify your Email!"
 
         context = {
@@ -36,49 +35,17 @@ def email_verification(first_name, email, token, current_site):
         text_content = strip_tags(html_content)
 
         # Configure email connection from the database
-        instance_configuration = InstanceConfiguration.objects.filter(
-            key__startswith="EMAIL_"
-        ).values("key", "value")
+        instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
         connection = get_connection(
-            host=get_configuration_value(
-                instance_configuration, "EMAIL_HOST", os.environ.get("EMAIL_HOST")
-            ),
-            port=int(
-                get_configuration_value(
-                    instance_configuration, "EMAIL_PORT", os.environ.get("EMAIL_PORT")
-                )
-            ),
-            username=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_USER",
-                os.environ.get("EMAIL_HOST_USER"),
-            ),
-            password=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_PASSWORD",
-                os.environ.get("EMAIL_HOST_PASSWORD"),
-            ),
-            use_tls=bool(
-                get_configuration_value(
-                    instance_configuration,
-                    "EMAIL_USE_TLS",
-                    os.environ.get("EMAIL_USE_TLS", "1"),
-                )
-            ),
+            host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
+            port=int(get_configuration_value(instance_configuration, "EMAIL_PORT", "587")),
+            username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
+            password=get_configuration_value(instance_configuration, "EMAIL_HOST_PASSWORD"),
+            use_tls=bool(get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")),
         )
 
         # Initiate email alternatives
-        msg = EmailMultiAlternatives(
-            subject=subject,
-            body=text_content,
-            from_email=get_configuration_value(
-                instance_configuration,
-                "EMAIL_FROM",
-                os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
-            ),
-            to=[email],
-            connection=connection,
-        )
+        msg = EmailMultiAlternatives(subject=subject, body=text_content, from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
         msg.attach_alternative(html_content, "text/html")
         msg.send()
         return

apiserver/plane/bgtasks/export_task.py

@@ -71,7 +71,7 @@ def upload_to_s3(zip_file, workspace_id, token_id, slug):
     file_name = f"{workspace_id}/export-{slug}-{token_id[:6]}-{timezone.now()}.zip"
     expires_in = 7 * 24 * 60 * 60
 
-    if settings.USE_MINIO:
+    if settings.DOCKERIZED and settings.USE_MINIO:
         s3 = boto3.client(
             "s3",
             endpoint_url=settings.AWS_S3_ENDPOINT_URL,
@@ -105,14 +105,14 @@ def upload_to_s3(zip_file, workspace_id, token_id, slug):
         )
         s3.upload_fileobj(
             zip_file,
-            settings.AWS_STORAGE_BUCKET_NAME,
+            settings.AWS_S3_BUCKET_NAME,
             file_name,
             ExtraArgs={"ACL": "public-read", "ContentType": "application/zip"},
         )
 
         presigned_url = s3.generate_presigned_url(
             "get_object",
-            Params={"Bucket": settings.AWS_STORAGE_BUCKET_NAME, "Key": file_name},
+            Params={"Bucket": settings.AWS_S3_BUCKET_NAME, "Key": file_name},
             ExpiresIn=expires_in,
         )
 

apiserver/plane/bgtasks/exporter_expired_task.py

@@ -21,7 +21,7 @@ def delete_old_s3_link():
     expired_exporter_history = ExporterHistory.objects.filter(
         Q(url__isnull=False) & Q(created_at__lte=timezone.now() - timedelta(days=8))
     ).values_list("key", "id")
-    if settings.USE_MINIO:
+    if settings.DOCKERIZED and settings.USE_MINIO:
         s3 = boto3.client(
             "s3",
             endpoint_url=settings.AWS_S3_ENDPOINT_URL,
@@ -41,9 +41,9 @@ def delete_old_s3_link():
     for file_name, exporter_id in expired_exporter_history:
         # Delete object from S3
         if file_name:
-            if settings.USE_MINIO:
+            if settings.DOCKERIZED and settings.USE_MINIO:
                 s3.delete_object(Bucket=settings.AWS_STORAGE_BUCKET_NAME, Key=file_name)
             else:
-                s3.delete_object(Bucket=settings.AWS_STORAGE_BUCKET_NAME, Key=file_name)
+                s3.delete_object(Bucket=settings.AWS_S3_BUCKET_NAME, Key=file_name)
 
         ExporterHistory.objects.filter(id=exporter_id).update(url=None)

apiserver/plane/bgtasks/file_asset_task.py

@@ -1,29 +0,0 @@
-# Python imports
-from datetime import timedelta
-
-# Django imports
-from django.utils import timezone
-from django.db.models import Q
-
-# Third party imports
-from celery import shared_task
-
-# Module imports
-from plane.db.models import FileAsset
-
-
-@shared_task
-def delete_file_asset():
-
-    # file assets to delete
-    file_assets_to_delete = FileAsset.objects.filter(
-        Q(is_deleted=True) & Q(updated_at__lte=timezone.now() - timedelta(days=7))
-    )
-
-    # Delete the file from storage and the file object from the database
-    for file_asset in file_assets_to_delete:
-        # Delete the file from storage
-        file_asset.asset.delete(save=False)
-        # Delete the file object
-        file_asset.delete()
-

apiserver/plane/bgtasks/forgot_password_task.py

@@ -1,6 +1,3 @@
-# Python import
-import os
-
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
 from django.template.loader import render_to_string
@@ -22,6 +19,8 @@ def forgot_password(first_name, email, uidb64, token, current_site):
         realtivelink = f"/accounts/reset-password/?uidb64={uidb64}&token={token}"
         abs_url = current_site + realtivelink
 
+        from_email_string = settings.EMAIL_FROM
+
         subject = "Reset Your Password - Plane"
 
         context = {
@@ -35,44 +34,14 @@ def forgot_password(first_name, email, uidb64, token, current_site):
 
         instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
         connection = get_connection(
-            host=get_configuration_value(
-                instance_configuration, "EMAIL_HOST", os.environ.get("EMAIL_HOST")
-            ),
-            port=int(
-                get_configuration_value(
-                    instance_configuration, "EMAIL_PORT", os.environ.get("EMAIL_PORT")
-                )
-            ),
-            username=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_USER",
-                os.environ.get("EMAIL_HOST_USER"),
-            ),
-            password=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_PASSWORD",
-                os.environ.get("EMAIL_HOST_PASSWORD"),
-            ),
-            use_tls=bool(
-                get_configuration_value(
-                    instance_configuration,
-                    "EMAIL_USE_TLS",
-                    os.environ.get("EMAIL_USE_TLS", "1"),
-                )
-            ),
-        )
-
-        msg = EmailMultiAlternatives(
-            subject=subject,
-            body=text_content,
-            from_email=get_configuration_value(
-                instance_configuration,
-                "EMAIL_FROM",
-                os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
-            ),
-            to=[email],
-            connection=connection,
+            host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
+            port=int(get_configuration_value(instance_configuration, "EMAIL_PORT", "587")),
+            username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
+            password=get_configuration_value(instance_configuration, "EMAIL_HOST_PASSWORD"),
+            use_tls=bool(get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")),
         )
+        # Initiate email alternatives
+        msg = EmailMultiAlternatives(subject=subject, body=text_content, from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
         msg.attach_alternative(html_content, "text/html")
         msg.send()
         return

apiserver/plane/bgtasks/issue_automation_task.py

@@ -12,7 +12,7 @@ from celery import shared_task
 from sentry_sdk import capture_exception
 
 # Module imports
-from plane.db.models import Issue, Project, State
+from plane.db.models import Issue, Project, State, Page
 from plane.bgtasks.issue_activites_task import issue_activity
 
 
@@ -20,6 +20,7 @@ from plane.bgtasks.issue_activites_task import issue_activity
 def archive_and_close_old_issues():
     archive_old_issues()
     close_old_issues()
+    delete_archived_pages()
 
 
 def archive_old_issues():
@@ -165,4 +166,21 @@ def close_old_issues():
         if settings.DEBUG:
             print(e)
         capture_exception(e)
-        return
+        return
+
+
+def delete_archived_pages():
+    try:
+        pages_to_delete = Page.objects.filter(
+            archived_at__isnull=False,
+            archived_at__lte=(timezone.now() - timedelta(days=30)),
+        )
+
+        pages_to_delete._raw_delete(pages_to_delete.db)
+        return 
+    except Exception as e:
+        if settings.DEBUG:
+            print(e)
+        capture_exception(e)
+        return
+

apiserver/plane/bgtasks/magic_link_code_task.py

@@ -1,6 +1,3 @@
-# Python imports
-import os
-
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
 from django.template.loader import render_to_string
@@ -15,7 +12,6 @@ from sentry_sdk import capture_exception
 from plane.license.models import InstanceConfiguration
 from plane.license.utils.instance_value import get_configuration_value
 
-
 @shared_task
 def magic_link(email, key, token, current_site):
     try:
@@ -30,48 +26,17 @@ def magic_link(email, key, token, current_site):
 
         text_content = strip_tags(html_content)
 
-        instance_configuration = InstanceConfiguration.objects.filter(
-            key__startswith="EMAIL_"
-        ).values("key", "value")
+        instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
         connection = get_connection(
-            host=get_configuration_value(
-                instance_configuration, "EMAIL_HOST", os.environ.get("EMAIL_HOST")
-            ),
-            port=int(
-                get_configuration_value(
-                    instance_configuration, "EMAIL_PORT", os.environ.get("EMAIL_PORT")
-                )
-            ),
-            username=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_USER",
-                os.environ.get("EMAIL_HOST_USER"),
-            ),
-            password=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_PASSWORD",
-                os.environ.get("EMAIL_HOST_PASSWORD"),
-            ),
-            use_tls=bool(
-                get_configuration_value(
-                    instance_configuration,
-                    "EMAIL_USE_TLS",
-                    os.environ.get("EMAIL_USE_TLS", "1"),
-                )
-            ),
+            host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
+            port=int(get_configuration_value(instance_configuration, "EMAIL_PORT", "587")),
+            username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
+            password=get_configuration_value(instance_configuration, "EMAIL_HOST_PASSWORD"),
+            use_tls=bool(get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")),
         )
 
-        msg = EmailMultiAlternatives(
-            subject=subject,
-            body=text_content,
-            from_email=get_configuration_value(
-                instance_configuration,
-                "EMAIL_FROM",
-                os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
-            ),
-            to=[email],
-            connection=connection,
-        )
+        # Initiate email alternatives
+        msg = EmailMultiAlternatives(subject=subject, body=text_content, from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
         msg.attach_alternative(html_content, "text/html")
         msg.send()
         return

apiserver/plane/bgtasks/notification_task.py

@@ -190,7 +190,6 @@ def notifications(type, issue_id, project_id, actor_id, subscriber, issue_activi
             issue_activities_created) if issue_activities_created is not None else None
     )
     if type not in [
-        "issue.activity.deleted",
         "cycle.activity.created",
         "cycle.activity.deleted",
         "module.activity.created",

apiserver/plane/bgtasks/project_invitation_task.py

@@ -1,6 +1,3 @@
-# Python import
-import os
-
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
 from django.template.loader import render_to_string
@@ -28,6 +25,8 @@ def project_invitation(email, project_id, token, current_site, invitor):
         relativelink = f"/project-invitations/?invitation_id={project_member_invite.id}&email={email}&slug={project.workspace.slug}&project_id={str(project_id)}"
         abs_url = current_site + relativelink
 
+        from_email_string = settings.EMAIL_FROM
+
         subject = f"{user.first_name or user.display_name or user.email} invited you to join {project.name} on Plane"
 
         context = {
@@ -49,45 +48,14 @@ def project_invitation(email, project_id, token, current_site, invitor):
         # Configure email connection from the database
         instance_configuration = InstanceConfiguration.objects.filter(key__startswith='EMAIL_').values("key", "value")
         connection = get_connection(
-            host=get_configuration_value(
-                instance_configuration, "EMAIL_HOST", os.environ.get("EMAIL_HOST")
-            ),
-            port=int(
-                get_configuration_value(
-                    instance_configuration, "EMAIL_PORT", os.environ.get("EMAIL_PORT")
-                )
-            ),
-            username=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_USER",
-                os.environ.get("EMAIL_HOST_USER"),
-            ),
-            password=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_PASSWORD",
-                os.environ.get("EMAIL_HOST_PASSWORD"),
-            ),
-            use_tls=bool(
-                get_configuration_value(
-                    instance_configuration,
-                    "EMAIL_USE_TLS",
-                    os.environ.get("EMAIL_USE_TLS", "1"),
-                )
-            ),
+            host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
+            port=int(get_configuration_value(instance_configuration, "EMAIL_PORT", "587")),
+            username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
+            password=get_configuration_value(instance_configuration, "EMAIL_HOST_PASSWORD"),
+            use_tls=bool(get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")),
         )
-
-        msg = EmailMultiAlternatives(
-            subject=subject,
-            body=text_content,
-            from_email=get_configuration_value(
-                instance_configuration,
-                "EMAIL_FROM",
-                os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
-            ),
-            to=[email],
-            connection=connection,
-        )
-
+        # Initiate email alternatives
+        msg = EmailMultiAlternatives(subject=subject, body=text_content, from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"), to=[email], connection=connection)
         msg.attach_alternative(html_content, "text/html")
         msg.send()
         return

apiserver/plane/bgtasks/track_events.py

@@ -0,0 +1,55 @@
+import requests
+import json
+
+# Django imports
+from django.conf import settings
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Module imports
+from plane.db.models import Workspace, Project, User
+
+# Third party imports
+from celery import shared_task
+from sentry_sdk import capture_exception
+
+
+@shared_task
+def track_event(event_name, slug, project_id, user_id):
+    try:
+        workspace = Workspace.objects.get(slug=slug)
+        project = Project.objects.get(slug=slug, id=project_id)
+        user = User.objects.get(id=user_id)
+
+        extra = {
+            "projectId": str(project.id),
+            "projectIdentifier": str(project.identifier),
+            "projectName": str(project.name),
+            "workspaceId": str(workspace.id),
+            "workspaceName": str(workspace.name),
+            "workspaceSlug": str(workspace.slug),
+        }
+
+        _ = requests.post(
+            settings.ANALYTICS_BASE_API,
+            params={"token": settings.ANALYTICS_SECRET_KEY},
+            json=json.dumps(
+                {
+                    "eventName": event_name,
+                    "extra": extra,
+                    "user": {
+                        "id": str(user.id),
+                        "email": str(user.email),
+                        "first_name": str(user.first_name),
+                        "last_name": str(user.last_name),
+                        "last_login_ip": str(user.last_login_ip),
+                        "last_login_uagent": str(user.last_login_uagent),
+                    },
+                },
+                cls=DjangoJSONEncoder,
+            ),
+        )
+    except Exception as e:
+        if settings.DEBUG:
+            print(e)
+        capture_exception(e)
+        return

apiserver/plane/bgtasks/webhook_task.py

@@ -2,67 +2,15 @@ import requests
 import uuid
 import hashlib
 import json
-import hmac
 
 # Django imports
 from django.conf import settings
-from django.core.serializers.json import DjangoJSONEncoder
 
 # Third party imports
 from celery import shared_task
 from sentry_sdk import capture_exception
 
-from plane.db.models import (
-    Webhook,
-    WebhookLog,
-    Project,
-    Issue,
-    Cycle,
-    Module,
-    ModuleIssue,
-    CycleIssue,
-    IssueComment,
-)
-from plane.api.serializers import (
-    ProjectSerializer,
-    IssueSerializer,
-    CycleSerializer,
-    ModuleSerializer,
-    CycleIssueSerializer,
-    ModuleIssueSerializer,
-    IssueCommentSerializer,
-    IssueExpandSerializer,
-)
-
-SERIALIZER_MAPPER = {
-    "project": ProjectSerializer,
-    "issue": IssueExpandSerializer,
-    "cycle": CycleSerializer,
-    "module": ModuleSerializer,
-    "cycle_issue": CycleIssueSerializer,
-    "module_issue": ModuleIssueSerializer,
-    "issue_comment": IssueCommentSerializer,
-}
-
-MODEL_MAPPER = {
-    "project": Project,
-    "issue": Issue,
-    "cycle": Cycle,
-    "module": Module,
-    "cycle_issue": CycleIssue,
-    "module_issue": ModuleIssue,
-    "issue_comment": IssueComment,
-}
-
-
-def get_model_data(event, event_id, many=False):
-    model = MODEL_MAPPER.get(event)
-    if many:
-        queryset = model.objects.filter(pk__in=event_id)
-    else:
-        queryset = model.objects.get(pk=event_id)
-    serializer = SERIALIZER_MAPPER.get(event)
-    return serializer(queryset, many=many).data
+from plane.db.models import Webhook, WebhookLog
 
 
 @shared_task(
@@ -83,24 +31,19 @@ def webhook_task(self, webhook, slug, event, event_data, action):
             "X-Plane-Event": event,
         }
 
-        # # Your secret key
-        event_data = (
-            json.loads(json.dumps(event_data, cls=DjangoJSONEncoder))
-            if event_data is not None
-            else None
-        )
-
-        # Use HMAC for generating signature
+        # Your secret key
         if webhook.secret_key:
-            event_data_json = json.dumps(event_data) if event_data is not None else "{}"
-            hmac_signature = hmac.new(
-                webhook.secret_key.encode("utf-8"),
-                event_data_json.encode("utf-8"),
-                hashlib.sha256,
-            )
-            signature = hmac_signature.hexdigest()
+            # Concatenate the data and the secret key
+            message = event_data + webhook.secret_key
+
+            # Create a SHA-256 hash of the message
+            sha256 = hashlib.sha256()
+            sha256.update(message.encode("utf-8"))
+            signature = sha256.hexdigest()
             headers["X-Plane-Signature"] = signature
 
+        event_data = json.loads(event_data) if event_data is not None else None
+
         action = {
             "POST": "create",
             "PATCH": "update",
@@ -153,6 +96,10 @@ def webhook_task(self, webhook, slug, event, event_data, action):
             retry_count=str(self.request.retries),
         )
 
+        # Retry logic
+        if self.request.retries >= self.max_retries:
+            Webhook.objects.filter(pk=webhook.id).update(is_active=False)
+            return
         raise requests.RequestException()
 
     except Exception as e:
@@ -163,7 +110,7 @@ def webhook_task(self, webhook, slug, event, event_data, action):
 
 
 @shared_task()
-def send_webhook(event, payload, kw, action, slug, bulk):
+def send_webhook(event, event_data, action, slug):
     try:
         webhooks = Webhook.objects.filter(workspace__slug=slug, is_active=True)
 
@@ -173,48 +120,17 @@ def send_webhook(event, payload, kw, action, slug, bulk):
         if event == "issue":
             webhooks = webhooks.filter(issue=True)
 
-        if event == "module" or event == "module_issue":
+        if event == "module":
             webhooks = webhooks.filter(module=True)
 
-        if event == "cycle" or event == "cycle_issue":
+        if event == "cycle":
             webhooks = webhooks.filter(cycle=True)
 
-        if event == "issue_comment":
+        if event == "issue-comment":
             webhooks = webhooks.filter(issue_comment=True)
 
-        if webhooks:
-            if action in ["POST", "PATCH"]:
-                if bulk and event in ["cycle_issue", "module_issue"]:
-                    event_data = IssueExpandSerializer(
-                        Issue.objects.filter(
-                            pk__in=[
-                                str(event.get("issue")) for event in payload
-                            ]
-                        ).prefetch_related("issue_cycle", "issue_module"), many=True
-                    ).data
-                    event = "issue"
-                    action = "PATCH"
-                else:
-                    event_data = [
-                        get_model_data(
-                            event=event,
-                            event_id=payload.get("id") if isinstance(payload, dict) else None,
-                            many=False,
-                        )
-                    ]
-
-            if action == "DELETE":
-                event_data = [{"id": kw.get("pk")}]
-
-            for webhook in webhooks:
-                for data in event_data:
-                    webhook_task.delay(
-                        webhook=webhook.id,
-                        slug=slug,
-                        event=event,
-                        event_data=data,
-                        action=action,
-                    )
+        for webhook in webhooks:
+            webhook_task.delay(webhook.id, slug, event, event_data, action)
 
     except Exception as e:
         if settings.DEBUG:

apiserver/plane/bgtasks/workspace_invitation_task.py

@@ -1,6 +1,3 @@
-# Python imports
-import os
-
 # Django imports
 from django.core.mail import EmailMultiAlternatives, get_connection
 from django.template.loader import render_to_string
@@ -35,6 +32,9 @@ def workspace_invitation(email, workspace_id, token, current_site, invitor):
         # The complete url including the domain
         abs_url = current_site + relative_link
 
+        # The email from
+        from_email_string = settings.EMAIL_FROM
+
         # Subject of the email
         subject = f"{user.first_name or user.display_name or user.email} invited you to join {workspace.name} on Plane"
 
@@ -58,41 +58,23 @@ def workspace_invitation(email, workspace_id, token, current_site, invitor):
             key__startswith="EMAIL_"
         ).values("key", "value")
         connection = get_connection(
-            host=get_configuration_value(
-                instance_configuration, "EMAIL_HOST", os.environ.get("EMAIL_HOST")
-            ),
+            host=get_configuration_value(instance_configuration, "EMAIL_HOST"),
             port=int(
-                get_configuration_value(
-                    instance_configuration, "EMAIL_PORT", os.environ.get("EMAIL_PORT")
-                )
-            ),
-            username=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_USER",
-                os.environ.get("EMAIL_HOST_USER"),
+                get_configuration_value(instance_configuration, "EMAIL_PORT", "587")
             ),
+            username=get_configuration_value(instance_configuration, "EMAIL_HOST_USER"),
             password=get_configuration_value(
-                instance_configuration,
-                "EMAIL_HOST_PASSWORD",
-                os.environ.get("EMAIL_HOST_PASSWORD"),
+                instance_configuration, "EMAIL_HOST_PASSWORD"
             ),
             use_tls=bool(
-                get_configuration_value(
-                    instance_configuration,
-                    "EMAIL_USE_TLS",
-                    os.environ.get("EMAIL_USE_TLS", "1"),
-                )
+                get_configuration_value(instance_configuration, "EMAIL_USE_TLS", "1")
             ),
         )
-
+        # Initiate email alternatives
         msg = EmailMultiAlternatives(
             subject=subject,
             body=text_content,
-            from_email=get_configuration_value(
-                instance_configuration,
-                "EMAIL_FROM",
-                os.environ.get("EMAIL_FROM", "Team Plane <team@mailer.plane.so>"),
-            ),
+            from_email=get_configuration_value(instance_configuration, "EMAIL_FROM"),
             to=[email],
             connection=connection,
         )

apiserver/plane/celery.py

@@ -24,10 +24,6 @@ app.conf.beat_schedule = {
         "task": "plane.bgtasks.exporter_expired_task.delete_old_s3_link",
         "schedule": crontab(hour=0, minute=0),
     },
-    "check-every-day-to-delete-file-asset": {
-        "task": "plane.bgtasks.file_asset_task.delete_file_asset",
-        "schedule": crontab(hour=0, minute=0),
-    },
 }
 
 # Load task modules from all registered Django app configs.

apiserver/plane/db/migrations/0051_fileasset_is_deleted.py

@@ -1,18 +0,0 @@
-# Generated by Django 4.2.7 on 2023-11-20 08:26
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('db', '0050_user_use_case_alter_workspace_organization_size'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='fileasset',
-            name='is_deleted',
-            field=models.BooleanField(default=False),
-        ),
-    ]

apiserver/plane/db/migrations/0052_alter_workspace_slug.py

@@ -1,19 +0,0 @@
-# Generated by Django 4.2.5 on 2023-11-23 14:57
-
-from django.db import migrations, models
-import plane.db.models.workspace
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('db', '0051_fileasset_is_deleted'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='workspace',
-            name='slug',
-            field=models.SlugField(max_length=48, unique=True, validators=[plane.db.models.workspace.slug_validator]),
-        ),
-    ]

apiserver/plane/db/models/asset.py

@@ -36,7 +36,6 @@ class FileAsset(BaseModel):
     workspace = models.ForeignKey(
         "db.Workspace", on_delete=models.CASCADE, null=True, related_name="assets"
     )
-    is_deleted = models.BooleanField(default=False)
 
     class Meta:
         verbose_name = "File Asset"

apiserver/plane/db/models/issue.py

@@ -133,7 +133,6 @@ class Issue(ProjectBaseModel):
             except ImportError:
                 pass
 
-
         if self._state.adding:
             # Get the maximum display_id value from the database
             last_id = IssueSequence.objects.filter(project=self.project).aggregate(

apiserver/plane/db/models/module.py

@@ -51,9 +51,9 @@ class Module(ProjectBaseModel):
 
     def save(self, *args, **kwargs):
         if self._state.adding:
-            smallest_sort_order = Module.objects.filter(project=self.project).aggregate(
-                smallest=models.Min("sort_order")
-            )["smallest"]
+            smallest_sort_order = Module.objects.filter(
+                project=self.project
+            ).aggregate(smallest=models.Min("sort_order"))["smallest"]
 
             if smallest_sort_order is not None:
                 self.sort_order = smallest_sort_order - 10000

apiserver/plane/db/models/webhook.py

@@ -16,6 +16,7 @@ def generate_token():
 
 def validate_schema(value):
     parsed_url = urlparse(value)
+    print(parsed_url)
     if parsed_url.scheme not in ["http", "https"]:
         raise ValidationError("Invalid schema. Only HTTP and HTTPS are allowed.")
 

apiserver/plane/db/models/workspace.py

@@ -1,7 +1,6 @@
 # Django imports
 from django.db import models
 from django.conf import settings
-from django.core.exceptions import ValidationError
 
 # Module imports
 from . import BaseModel
@@ -51,7 +50,7 @@ def get_default_props():
             "state": True,
             "sub_issue_count": True,
             "updated_on": True,
-        },
+        }
     }
 
 
@@ -64,23 +63,6 @@ def get_issue_props():
     }
 
 
-def slug_validator(value):
-    if value in [
-        "404",
-        "accounts",
-        "api",
-        "create-workspace",
-        "god-mode",
-        "installations",
-        "invitations",
-        "onboarding",
-        "profile",
-        "spaces",
-        "workspace-invitations",
-    ]:
-        raise ValidationError("Slug is not valid")
-
-
 class Workspace(BaseModel):
     name = models.CharField(max_length=80, verbose_name="Workspace Name")
     logo = models.URLField(verbose_name="Logo", blank=True, null=True)
@@ -89,7 +71,7 @@ class Workspace(BaseModel):
         on_delete=models.CASCADE,
         related_name="owner_workspace",
     )
-    slug = models.SlugField(max_length=48, db_index=True, unique=True, validators=[slug_validator,])
+    slug = models.SlugField(max_length=48, db_index=True, unique=True)
     organization_size = models.CharField(max_length=20, blank=True, null=True)
 
     def __str__(self):

apiserver/plane/license/api/views/instance.py

@@ -230,18 +230,13 @@ class InstanceConfigurationEndpoint(BaseAPIView):
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     def patch(self, request):
-        configurations = InstanceConfiguration.objects.filter(key__in=request.data.keys())
-
-        bulk_configurations = []
-        for configuration in configurations:
-            configuration.value = request.data.get(configuration.key, configuration.value)
-            bulk_configurations.append(configuration)
-
-        InstanceConfiguration.objects.bulk_update(
-            bulk_configurations,
-            ["value"],
-            batch_size=100
-        )
-
-        serializer = InstanceConfigurationSerializer(configurations, many=True)
+        key = request.data.get("key", False)
+        if not key:
+            return Response(
+                {"error": "Key is required"}, status=status.HTTP_400_BAD_REQUEST
+            )
+        configuration = InstanceConfiguration.objects.get(key=key)
+        configuration.value = request.data.get("value")
+        configuration.save()
+        serializer = InstanceConfigurationSerializer(configuration)
         return Response(serializer.data, status=status.HTTP_200_OK)

apiserver/plane/license/management/commands/configure_instance.py

@@ -15,7 +15,6 @@ class Command(BaseCommand):
         config_keys = {
             # Authentication Settings
             "GOOGLE_CLIENT_ID": os.environ.get("GOOGLE_CLIENT_ID"),
-            "GOOGLE_CLIENT_SECRET": os.environ.get("GOOGLE_CLIENT_SECRET"),
             "GITHUB_CLIENT_ID": os.environ.get("GITHUB_CLIENT_ID"),
             "GITHUB_CLIENT_SECRET": os.environ.get("GITHUB_CLIENT_SECRET"),
             "ENABLE_SIGNUP": os.environ.get("ENABLE_SIGNUP", "1"),
@@ -30,11 +29,9 @@ class Command(BaseCommand):
             "EMAIL_USE_TLS": os.environ.get("EMAIL_USE_TLS", "1"),
             "EMAIL_USE_SSL": os.environ.get("EMAIL_USE_SSL", "0"),
             # Open AI Settings
-            "OPENAI_API_BASE": os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
-            "OPENAI_API_KEY": os.environ.get("OPENAI_API_KEY", ""),
+            "OPENAI_API_BASE": os.environ.get("", "https://api.openai.com/v1"),
+            "OPENAI_API_KEY": os.environ.get("OPENAI_API_KEY", "sk-"),
             "GPT_ENGINE": os.environ.get("GPT_ENGINE", "gpt-3.5-turbo"),
-            # Unsplash Access Key
-            "UNSPLASH_ACCESS_KEY": os.environ.get("UNSPLASH_ACESS_KEY", "")
         }
 
         for key, value in config_keys.items():

apiserver/plane/license/management/commands/register_instance.py

@@ -45,7 +45,7 @@ class Command(BaseCommand):
             # If the user does not exist create the user and add him to the database
             if user is None:
                 user = User.objects.create(email=admin_email, username=uuid.uuid4().hex)
-                user.set_password(admin_email)
+                user.set_password(uuid.uuid4().hex)
                 user.save()
 
             license_engine_base_url = os.environ.get("LICENSE_ENGINE_BASE_URL")
@@ -61,7 +61,7 @@ class Command(BaseCommand):
             }
 
             response = requests.post(
-                f"{license_engine_base_url}/api/instances/",
+                f"{license_engine_base_url}/api/instances",
                 headers=headers,
                 data=json.dumps(payload),
             )
@@ -88,11 +88,13 @@ class Command(BaseCommand):
 
                 self.stdout.write(
                     self.style.SUCCESS(
-                        f"Instance successfully registered with owner: {instance.primary_owner.email}"
+                        f"Instance succesfully registered with owner: {instance.primary_owner.email}"
                     )
                 )
                 return
-            raise CommandError("Instance could not be registered")
+
+            self.stdout.write(self.style.WARNING("Instance could not be registered"))
+            return
         else:
             self.stdout.write(
                 self.style.SUCCESS(

apiserver/plane/proxy/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class ProxyConfig(AppConfig):
+    name = "plane.proxy"

apiserver/plane/proxy/urls/__init__.py

@@ -1,15 +1,13 @@
-from .project import urlpatterns as project_patterns
-from .state import urlpatterns as state_patterns
-from .issue import urlpatterns as issue_patterns
 from .cycle import urlpatterns as cycle_patterns
-from .module import urlpatterns as module_patterns
 from .inbox import urlpatterns as inbox_patterns
+from .issue import urlpatterns as issue_patterns
+from .module import urlpatterns as module_patterns
+from .project import urlpatterns as project_patterns
 
 urlpatterns = [
-    *project_patterns,
-    *state_patterns,
-    *issue_patterns,
     *cycle_patterns,
-    *module_patterns,
     *inbox_patterns,
-]
+    *issue_patterns,
+    *module_patterns,
+    *project_patterns,
+]

apiserver/plane/proxy/urls/cycle.py

@@ -1,6 +1,6 @@
 from django.urls import path
 
-from plane.api.views.cycle import (
+from plane.proxy.views.cycle import (
     CycleAPIEndpoint,
     CycleIssueAPIEndpoint,
     TransferCycleIssueAPIEndpoint,
@@ -13,7 +13,7 @@ urlpatterns = [
         name="cycles",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/",
         CycleAPIEndpoint.as_view(),
         name="cycles",
     ),
@@ -23,7 +23,7 @@ urlpatterns = [
         name="cycle-issues",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:issue_id>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:pk>/",
         CycleIssueAPIEndpoint.as_view(),
         name="cycle-issues",
     ),
@@ -32,4 +32,4 @@ urlpatterns = [
         TransferCycleIssueAPIEndpoint.as_view(),
         name="transfer-issues",
     ),
-]
+]

apiserver/plane/proxy/urls/inbox.py

@@ -0,0 +1,17 @@
+from django.urls import path
+
+from plane.proxy.views import InboxIssueAPIEndpoint
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/",
+        InboxIssueAPIEndpoint.as_view(),
+        name="inbox-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:inbox_id>/inbox-issues/<uuid:pk>/",
+        InboxIssueAPIEndpoint.as_view(),
+        name="inbox-issue",
+    ),
+]

apiserver/plane/proxy/urls/issue.py

@@ -1,62 +1,51 @@
 from django.urls import path
 
-from plane.api.views import (
+from plane.proxy.views import (
     IssueAPIEndpoint,
     LabelAPIEndpoint,
     IssueLinkAPIEndpoint,
     IssueCommentAPIEndpoint,
-    IssueActivityAPIEndpoint,
 )
 
 urlpatterns = [
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
         IssueAPIEndpoint.as_view(),
-        name="issue",
+        name="issues",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/",
         IssueAPIEndpoint.as_view(),
-        name="issue",
+        name="issues",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/labels/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/",
         LabelAPIEndpoint.as_view(),
-        name="label",
+        name="labels",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/labels/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/<uuid:pk>/",
         LabelAPIEndpoint.as_view(),
-        name="label",
+        name="labels",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/links/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/",
         IssueLinkAPIEndpoint.as_view(),
-        name="link",
+        name="issue-links",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/links/<uuid:pk>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/<uuid:pk>/",
         IssueLinkAPIEndpoint.as_view(),
-        name="link",
+        name="issue-links",
     ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/",
-        IssueCommentAPIEndpoint.as_view(),
-        name="comment",
+        IssueCommentAPIEndpoint.as_view(), 
+        name="project-issue-comment",
     ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/<uuid:pk>/",
         IssueCommentAPIEndpoint.as_view(),
-        name="comment",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activities/",
-        IssueActivityAPIEndpoint.as_view(),
-        name="activity",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/activities/<uuid:pk>/",
-        IssueActivityAPIEndpoint.as_view(),
-        name="activity",
+        name="project-issue-comment",
     ),
 ]

apiserver/plane/proxy/urls/module.py

@@ -1,6 +1,6 @@
 from django.urls import path
 
-from plane.api.views import ModuleAPIEndpoint, ModuleIssueAPIEndpoint
+from plane.proxy.views import ModuleAPIEndpoint, ModuleIssueAPIEndpoint
 
 urlpatterns = [
     path(
@@ -19,8 +19,8 @@ urlpatterns = [
         name="module-issues",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:issue_id>/",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-issues/<uuid:pk>/",
         ModuleIssueAPIEndpoint.as_view(),
         name="module-issues",
     ),
-]
+]

apiserver/plane/proxy/urls/project.py

@@ -1,6 +1,6 @@
 from django.urls import path
 
-from plane.api.views import ProjectAPIEndpoint
+from plane.proxy.views import ProjectAPIEndpoint
 
 urlpatterns = [
         path(
@@ -9,8 +9,8 @@ urlpatterns = [
         name="project",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/",
+        "workspaces/<str:slug>/projects/<uuid:pk>/",
         ProjectAPIEndpoint.as_view(),
         name="project",
     ),
-]
+]

apiserver/plane/proxy/views/__init__.py

@@ -1,13 +1,10 @@
 from .project import ProjectAPIEndpoint
 
-from .state import StateAPIEndpoint
-
 from .issue import (
     IssueAPIEndpoint,
     LabelAPIEndpoint,
     IssueLinkAPIEndpoint,
     IssueCommentAPIEndpoint,
-    IssueActivityAPIEndpoint,
 )
 
 from .cycle import (

apiserver/plane/proxy/views/base.py

@@ -0,0 +1,101 @@
+# Python imports
+import re
+import json
+import requests
+
+# Django imports
+from django.conf import settings
+
+# Third party imports
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+from rest_framework_simplejwt.tokens import RefreshToken
+
+# Module imports
+from plane.authentication.api_authentication import APIKeyAuthentication
+from plane.proxy.rate_limit import ApiKeyRateThrottle
+
+
+class BaseAPIView(APIView):
+    authentication_classes = [
+        APIKeyAuthentication,
+    ]
+
+    permission_classes = [
+        IsAuthenticated,
+    ]
+
+    throttle_classes = [
+        ApiKeyRateThrottle,
+    ]
+
+    def _get_jwt_token(self, request):
+        refresh = RefreshToken.for_user(request.user)
+        return str(refresh.access_token)
+
+    def _get_url_path(self, request):
+        match = re.search(r"/v1/(.*)", request.path)
+        return match.group(1) if match else ""
+
+    def _get_headers(self, request):
+        return {
+            "Authorization": f"Bearer {self._get_jwt_token(request=request)}",
+            "Content-Type": request.headers.get("Content-Type", "application/json"),
+        }
+
+    def _get_url(self, request):
+        path = self._get_url_path(request=request)
+        url = request.build_absolute_uri("/api/" + path)
+        return url
+
+    def _get_query_params(self, request):
+        query_params = request.GET
+        return query_params
+
+    def _get_payload(self, request):
+        content_type = request.headers.get("Content-Type", "application/json")
+        if content_type.startswith("multipart/form-data"):
+            files_dict = {k: v[0] for k, v in request.FILES.lists()}
+            return (None, files_dict)
+        else:
+            return (json.dumps(request.data), None)
+
+    def _make_request(self, request, method="GET"):
+        data_payload, files_payload = self._get_payload(request=request)
+        response = requests.request(
+            method=method,
+            url=self._get_url(request=request),
+            headers=self._get_headers(request=request),
+            params=self._get_query_params(request=request),
+            data=data_payload,
+            files=files_payload,
+        )
+        return response.json(), response.status_code
+
+    def finalize_response(self, request, response, *args, **kwargs):
+        # Call super to get the default response
+        response = super().finalize_response(request, response, *args, **kwargs)
+
+        # Add custom headers if they exist in the request META
+        ratelimit_remaining = request.META.get('X-RateLimit-Remaining')
+        if ratelimit_remaining is not None:
+            response['X-RateLimit-Remaining'] = ratelimit_remaining
+
+        ratelimit_reset = request.META.get('X-RateLimit-Reset')
+        if ratelimit_reset is not None:
+            response['X-RateLimit-Reset'] = ratelimit_reset
+
+        return response
+
+    def get(self, request, *args, **kwargs):
+        response, status_code = self._make_request(request=request, method="GET")
+        return Response(response, status=status_code)
+
+    def post(self, request, *args, **kwargs):
+        response, status_code = self._make_request(request=request, method="POST")
+        return Response(response, status=status_code)
+
+    def partial_update(self, request, *args, **kwargs):
+        response, status_code = self._make_request(request=request, method="PATCH")
+        return Response(response, status=status_code)

apiserver/plane/proxy/views/cycle.py

@@ -0,0 +1,30 @@
+from .base import BaseAPIView
+
+
+class CycleAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to cycle.
+
+    """
+
+    pass
+
+
+class CycleIssueAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to cycle issues.
+
+    """
+
+    pass
+
+
+class TransferCycleIssueAPIEndpoint(BaseAPIView):
+    """
+    This viewset provides `create` actions for transfering the issues into a particular cycle.
+
+    """
+
+    pass

apiserver/plane/proxy/views/inbox.py

@@ -0,0 +1,10 @@
+from .base import BaseAPIView
+
+
+class InboxIssueAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to inbox issues.
+
+    """
+    pass

apiserver/plane/proxy/views/issue.py

@@ -0,0 +1,37 @@
+from .base import BaseAPIView
+
+
+class IssueAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to issue.
+
+    """
+    pass
+
+
+class LabelAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to the labels.
+
+    """
+    pass
+
+
+class IssueLinkAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to the links of the particular issue.
+
+    """
+    pass
+
+
+class IssueCommentAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to comments of the particular issue.
+
+    """
+    pass