fix: replaced next_path with app_slug

.dockerignore

@@ -2,7 +2,6 @@
 *.pyc
 .env
 venv
-.venv
 node_modules/
 **/node_modules/
 npm-debug.log
@@ -15,4 +14,4 @@ build/
 out/
 **/out/
 dist/
-**/dist/
+**/dist/

.github/workflows/build-branch.yml

@@ -290,6 +290,5 @@ jobs:
             ${{ github.workspace }}/deploy/selfhost/setup.sh
             ${{ github.workspace }}/deploy/selfhost/swarm.sh
             ${{ github.workspace }}/deploy/selfhost/restore.sh
-            ${{ github.workspace }}/deploy/selfhost/restore-airgapped.sh
             ${{ github.workspace }}/deploy/selfhost/docker-compose.yml
             ${{ github.workspace }}/deploy/selfhost/variables.env

.gitignore

@@ -53,8 +53,6 @@ mediafiles
 .env
 .DS_Store
 logs/
-htmlcov/
-.coverage
 
 node_modules/
 assets/dist/

CONTRIBUTING.md

@@ -69,14 +69,14 @@ chmod +x setup.sh
 docker compose -f docker-compose-local.yml up
 ```
 
-4. Start web apps:
+5. Start web apps:
 
 ```bash
 yarn dev
 ```
 
-5. Open your browser to http://localhost:3001/god-mode/ and register yourself as instance admin
-6. Open up your browser to http://localhost:3000 then log in using the same credentials from the previous step
+6. Open your browser to http://localhost:3001/god-mode/ and register yourself as instance admin
+7. Open up your browser to http://localhost:3000 then log in using the same credentials from the previous step
 
 That’s it! You’re all set to begin coding. Remember to refresh your browser if changes don’t auto-reload. Happy contributing! 🎉
 

admin/app/ai/form.tsx

@@ -26,16 +26,16 @@ export const InstanceAIForm: FC<IInstanceAIForm> = (props) => {
     formState: { errors, isSubmitting },
   } = useForm<AIFormValues>({
     defaultValues: {
-      LLM_API_KEY: config["LLM_API_KEY"],
-      LLM_MODEL: config["LLM_MODEL"],
+      OPENAI_API_KEY: config["OPENAI_API_KEY"],
+      GPT_ENGINE: config["GPT_ENGINE"],
     },
   });
 
   const aiFormFields: TControllerInputFormField[] = [
     {
-      key: "LLM_MODEL",
+      key: "GPT_ENGINE",
       type: "text",
-      label: "LLM Model",
+      label: "GPT_ENGINE",
       description: (
         <>
           Choose an OpenAI engine.{" "}
@@ -49,12 +49,12 @@ export const InstanceAIForm: FC<IInstanceAIForm> = (props) => {
           </a>
         </>
       ),
-      placeholder: "gpt-4o-mini",
-      error: Boolean(errors.LLM_MODEL),
+      placeholder: "gpt-3.5-turbo",
+      error: Boolean(errors.GPT_ENGINE),
       required: false,
     },
     {
-      key: "LLM_API_KEY",
+      key: "OPENAI_API_KEY",
       type: "password",
       label: "API key",
       description: (
@@ -71,7 +71,7 @@ export const InstanceAIForm: FC<IInstanceAIForm> = (props) => {
         </>
       ),
       placeholder: "sk-asddassdfasdefqsdfasd23das3dasdcasd",
-      error: Boolean(errors.LLM_API_KEY),
+      error: Boolean(errors.OPENAI_API_KEY),
       required: false,
     },
   ];

admin/app/authentication/github/form.tsx

@@ -98,7 +98,11 @@ export const InstanceGithubConfigForm: FC<Props> = (props) => {
       key: "GITHUB_ORGANIZATION_ID",
       type: "text",
       label: "Organization ID",
-      description: <>The organization github ID.</>,
+      description: (
+        <>
+          The organization github ID.
+        </>
+      ),
       placeholder: "123456789",
       error: Boolean(errors.GITHUB_ORGANIZATION_ID),
       required: false,

admin/core/components/admin-sidebar/sidebar-dropdown.tsx

@@ -7,7 +7,7 @@ import { LogOut, UserCog2, Palette } from "lucide-react";
 import { Menu, Transition } from "@headlessui/react";
 // plane internal packages
 import { API_BASE_URL } from "@plane/constants";
-import { AuthService } from "@plane/services";
+import  {AuthService } from "@plane/services";
 import { Avatar } from "@plane/ui";
 import { getFileURL, cn } from "@plane/utils";
 // hooks

admin/core/store/instance.store.ts

@@ -2,7 +2,7 @@ import set from "lodash/set";
 import { observable, action, computed, makeObservable, runInAction } from "mobx";
 // plane internal packages
 import { EInstanceStatus, TInstanceStatus } from "@plane/constants";
-import { InstanceService } from "@plane/services";
+import {InstanceService} from "@plane/services";
 import {
   IInstance,
   IInstanceAdmin,

admin/ee/components/authentication/authentication-modes.tsx

@@ -1 +1 @@
-export * from "ce/components/authentication/authentication-modes";
+export * from "ce/components/authentication/authentication-modes";

admin/package.json

@@ -1,7 +1,7 @@
 {
   "name": "admin",
   "description": "Admin UI for Plane",
-  "version": "0.26.1",
+  "version": "0.26.0",
   "license": "AGPL-3.0",
   "private": true,
   "scripts": {
@@ -10,7 +10,6 @@
     "build": "next build",
     "preview": "next build && next start",
     "start": "next start",
-    "format": "prettier --write .",
     "lint": "eslint . --ext .ts,.tsx",
     "lint:errors": "eslint . --ext .ts,.tsx --quiet"
   },
@@ -31,7 +30,7 @@
     "lucide-react": "^0.469.0",
     "mobx": "^6.12.0",
     "mobx-react": "^9.1.1",
-    "next": "^14.2.29",
+    "next": "^14.2.28",
     "next-themes": "^0.2.1",
     "postcss": "^8.4.38",
     "react": "^18.3.1",

admin/tsconfig.json

@@ -1,19 +1,14 @@
 {
   "extends": "@plane/typescript-config/nextjs.json",
   "compilerOptions": {
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ],
+    "plugins": [{ "name": "next" }],
     "baseUrl": ".",
     "paths": {
       "@/*": ["core/*"],
       "@/public/*": ["public/*"],
       "@/plane-admin/*": ["ce/*"],
       "@/styles/*": ["styles/*"]
-    },
-    "strictNullChecks": true
+    }
   },
   "include": ["next-env.d.ts", "next.config.js", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
   "exclude": ["node_modules"]

apiserver/.coveragerc

@@ -1,25 +0,0 @@
-[run]
-source = plane
-omit =
-    */tests/*
-    */migrations/*
-    */settings/*
-    */wsgi.py
-    */asgi.py
-    */urls.py
-    manage.py
-    */admin.py
-    */apps.py
-
-[report]
-exclude_lines =
-    pragma: no cover
-    def __repr__
-    if self.debug:
-    raise NotImplementedError
-    if __name__ == .__main__.
-    pass
-    raise ImportError
-
-[html]
-directory = htmlcov 

apiserver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plane-api",
-  "version": "0.26.1",
+  "version": "0.26.0",
   "license": "AGPL-3.0",
   "private": true,
   "description": "API server powering Plane's backend"

apiserver/plane/api/serializers/__init__.py

@@ -15,4 +15,4 @@ from .state import StateLiteSerializer, StateSerializer
 from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
 from .module import ModuleSerializer, ModuleIssueSerializer, ModuleLiteSerializer
 from .intake import IntakeIssueSerializer
-from .estimate import EstimatePointSerializer
+from .estimate import EstimatePointSerializer

apiserver/plane/api/serializers/issue.py

@@ -160,15 +160,12 @@ class IssueSerializer(BaseSerializer):
         else:
             try:
                 # Then assign it to default assignee, if it is a valid assignee
-                if (
-                    default_assignee_id is not None
-                    and ProjectMember.objects.filter(
-                        member_id=default_assignee_id,
-                        project_id=project_id,
-                        role__gte=15,
-                        is_active=True,
-                    ).exists()
-                ):
+                if default_assignee_id is not None and ProjectMember.objects.filter(
+                    member_id=default_assignee_id,
+                    project_id=project_id,
+                    role__gte=15,
+                    is_active=True
+                ).exists():
                     IssueAssignee.objects.create(
                         assignee_id=default_assignee_id,
                         issue=issue,

apiserver/plane/api/views/issue.py

@@ -58,7 +58,7 @@ from plane.bgtasks.storage_metadata_task import get_asset_object_metadata
 from .base import BaseAPIView
 from plane.utils.host import base_host
 from plane.bgtasks.webhook_task import model_activity
-from plane.bgtasks.work_item_link_task import crawl_work_item_link_title
+
 
 class WorkspaceIssueAPIEndpoint(BaseAPIView):
     """
@@ -692,9 +692,6 @@ class IssueLinkAPIEndpoint(BaseAPIView):
         serializer = IssueLinkSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(project_id=project_id, issue_id=issue_id)
-            crawl_work_item_link_title.delay(
-                serializer.data.get("id"), serializer.data.get("url")
-            )
 
             link = IssueLink.objects.get(pk=serializer.data["id"])
             link.created_by_id = request.data.get("created_by", request.user.id)
@@ -722,9 +719,6 @@ class IssueLinkAPIEndpoint(BaseAPIView):
         serializer = IssueLinkSerializer(issue_link, data=request.data, partial=True)
         if serializer.is_valid():
             serializer.save()
-            crawl_work_item_link_title.delay(
-                serializer.data.get("id"), serializer.data.get("url")
-            )
             issue_activity.delay(
                 type="link.activity.updated",
                 requested_data=requested_data,

apiserver/plane/app/serializers/favorite.py

@@ -53,7 +53,6 @@ def get_entity_model_and_serializer(entity_type):
     }
     return entity_map.get(entity_type, (None, None))
 
-
 class UserFavoriteSerializer(serializers.ModelSerializer):
     entity_data = serializers.SerializerMethodField()
 

apiserver/plane/app/serializers/project.py

@@ -148,13 +148,10 @@ class ProjectMemberAdminSerializer(BaseSerializer):
         fields = "__all__"
 
 
-class ProjectMemberRoleSerializer(DynamicBaseSerializer): 
-    original_role = serializers.IntegerField(source='role', read_only=True)
-
+class ProjectMemberRoleSerializer(DynamicBaseSerializer):
     class Meta:
         model = ProjectMember
-        fields = ("id", "role", "member", "project", "original_role", "created_at")
-        read_only_fields = ["original_role", "created_at"]
+        fields = ("id", "role", "member", "project")
 
 
 class ProjectMemberInviteSerializer(BaseSerializer):

apiserver/plane/app/serializers/user.py

@@ -3,22 +3,11 @@ from rest_framework import serializers
 
 # Module import
 from plane.db.models import Account, Profile, User, Workspace, WorkspaceMemberInvite
-from plane.utils.url import contains_url
 
 from .base import BaseSerializer
 
 
 class UserSerializer(BaseSerializer):
-    def validate_first_name(self, value):
-        if contains_url(value):
-            raise serializers.ValidationError("First name cannot contain a URL.")
-        return value
-
-    def validate_last_name(self, value):
-        if contains_url(value):
-            raise serializers.ValidationError("Last name cannot contain a URL.")
-        return value
-
     class Meta:
         model = User
         # Exclude password field from the serializer
@@ -110,16 +99,11 @@ class UserMeSettingsSerializer(BaseSerializer):
                 workspace_member__member=obj.id,
                 workspace_member__is_active=True,
             ).first()
-            logo_asset_url = workspace.logo_asset.asset_url if workspace.logo_asset is not None else ""
             return {
                 "last_workspace_id": profile.last_workspace_id,
                 "last_workspace_slug": (
                     workspace.slug if workspace is not None else ""
                 ),
-                "last_workspace_name": (
-                    workspace.name if workspace is not None else ""
-                ),
-                "last_workspace_logo": (logo_asset_url),
                 "fallback_workspace_id": profile.last_workspace_id,
                 "fallback_workspace_slug": (
                     workspace.slug if workspace is not None else ""

apiserver/plane/app/serializers/workspace.py

@@ -25,12 +25,10 @@ from plane.db.models import (
     WorkspaceUserPreference,
 )
 from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
-from plane.utils.url import contains_url
 
 # Django imports
 from django.core.validators import URLValidator
 from django.core.exceptions import ValidationError
-import re
 
 
 class WorkSpaceSerializer(DynamicBaseSerializer):
@@ -38,21 +36,10 @@ class WorkSpaceSerializer(DynamicBaseSerializer):
     logo_url = serializers.CharField(read_only=True)
     role = serializers.IntegerField(read_only=True)
 
-    def validate_name(self, value):
-        # Check if the name contains a URL
-        if contains_url(value):
-            raise serializers.ValidationError("Name must not contain URLs")
-        return value
-
     def validate_slug(self, value):
         # Check if the slug is restricted
         if value in RESTRICTED_WORKSPACE_SLUGS:
             raise serializers.ValidationError("Slug is not valid")
-        # Slug should only contain alphanumeric characters, hyphens, and underscores
-        if not re.match(r"^[a-zA-Z0-9_-]+$", value):
-            raise serializers.ValidationError(
-                "Slug can only contain letters, numbers, hyphens (-), and underscores (_)"
-            )
         return value
 
     class Meta:
@@ -161,6 +148,7 @@ class WorkspaceUserLinkSerializer(BaseSerializer):
 
         return value
 
+
     def create(self, validated_data):
         # Filtering the WorkspaceUserLink with the given url to check if the link already exists.
 
@@ -169,7 +157,7 @@ class WorkspaceUserLinkSerializer(BaseSerializer):
         workspace_user_link = WorkspaceUserLink.objects.filter(
             url=url,
             workspace_id=validated_data.get("workspace_id"),
-            owner_id=validated_data.get("owner_id"),
+            owner_id=validated_data.get("owner_id")
         )
 
         if workspace_user_link.exists():
@@ -185,8 +173,10 @@ class WorkspaceUserLinkSerializer(BaseSerializer):
         url = validated_data.get("url")
 
         workspace_user_link = WorkspaceUserLink.objects.filter(
-            url=url, workspace_id=instance.workspace_id, owner=instance.owner
-        )
+                url=url,
+                workspace_id=instance.workspace_id,
+                owner=instance.owner
+            )
 
         if workspace_user_link.exclude(pk=instance.id).exists():
             raise serializers.ValidationError(
@@ -195,7 +185,6 @@ class WorkspaceUserLinkSerializer(BaseSerializer):
 
         return super().update(instance, validated_data)
 
-
 class IssueRecentVisitSerializer(serializers.ModelSerializer):
     project_identifier = serializers.SerializerMethodField()
 

apiserver/plane/app/urls/analytic.py

@@ -11,9 +11,7 @@ from plane.app.views import (
     AdvanceAnalyticsChartEndpoint,
     DefaultAnalyticsEndpoint,
     ProjectStatsEndpoint,
-    ProjectAdvanceAnalyticsEndpoint,
-    ProjectAdvanceAnalyticsStatsEndpoint,
-    ProjectAdvanceAnalyticsChartEndpoint,
+    AdvanceAnalyticsExportEndpoint,
 )
 
 
@@ -71,18 +69,8 @@ urlpatterns = [
         name="advance-analytics-chart",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/advance-analytics/",
-        ProjectAdvanceAnalyticsEndpoint.as_view(),
-        name="project-advance-analytics",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/advance-analytics-stats/",
-        ProjectAdvanceAnalyticsStatsEndpoint.as_view(),
-        name="project-advance-analytics-stats",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/advance-analytics-charts/",
-        ProjectAdvanceAnalyticsChartEndpoint.as_view(),
-        name="project-advance-analytics-chart",
+        "workspaces/<str:slug>/advance-analytics-export/",
+        AdvanceAnalyticsExportEndpoint.as_view(),
+        name="advance-analytics-export",
     ),
 ]

apiserver/plane/app/urls/asset.py

@@ -12,7 +12,6 @@ from plane.app.views import (
     AssetRestoreEndpoint,
     ProjectAssetEndpoint,
     ProjectBulkAssetEndpoint,
-    AssetCheckEndpoint,
 )
 
 
@@ -82,11 +81,5 @@ urlpatterns = [
     path(
         "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/<uuid:entity_id>/bulk/",
         ProjectBulkAssetEndpoint.as_view(),
-        name="bulk-asset-update",
-    ),
-    path(
-        "assets/v2/workspaces/<str:slug>/check/<uuid:asset_id>/",
-        AssetCheckEndpoint.as_view(),
-        name="asset-check",
     ),
 ]

apiserver/plane/app/views/__init__.py

@@ -106,7 +106,6 @@ from .asset.v2 import (
     AssetRestoreEndpoint,
     ProjectAssetEndpoint,
     ProjectBulkAssetEndpoint,
-    AssetCheckEndpoint,
 )
 from .issue.base import (
     IssueListEndpoint,
@@ -204,12 +203,7 @@ from .analytic.advance import (
     AdvanceAnalyticsEndpoint,
     AdvanceAnalyticsStatsEndpoint,
     AdvanceAnalyticsChartEndpoint,
-)
-
-from .analytic.project_analytics import (
-    ProjectAdvanceAnalyticsEndpoint,
-    ProjectAdvanceAnalyticsStatsEndpoint,
-    ProjectAdvanceAnalyticsChartEndpoint,
+    AdvanceAnalyticsExportEndpoint,
 )
 
 from .notification.base import (

apiserver/plane/app/views/analytic/advance.py

@@ -1,10 +1,10 @@
 from rest_framework.response import Response
 from rest_framework import status
 from typing import Dict, List, Any
+from datetime import timedelta
 from django.db.models import QuerySet, Q, Count
 from django.http import HttpRequest
-from django.db.models.functions import TruncMonth
-from django.utils import timezone
+
 from plane.app.views.base import BaseAPIView
 from plane.app.permissions import ROLE, allow_permission
 from plane.db.models import (
@@ -15,16 +15,23 @@ from plane.db.models import (
     Module,
     IssueView,
     ProjectPage,
-    Workspace,
-    CycleIssue,
-    ModuleIssue,
-    ProjectMember,
+)
+
+from django.db.models import (
+    Q,
+    Count,
 )
 from plane.utils.build_chart import build_analytics_chart
+from datetime import timedelta
+from plane.bgtasks.analytic_plot_export import export_analytics_to_csv_email
 from plane.utils.date_utils import (
     get_analytics_filters,
 )
 
+from plane.utils.build_chart import build_analytics_chart
+from plane.bgtasks.analytic_plot_export import export_analytics_to_csv_email
+from plane.utils.date_utils import get_analytics_filters
+
 
 class AdvanceAnalyticsBaseView(BaseAPIView):
     def initialize_workspace(self, slug: str, type: str) -> None:
@@ -39,6 +46,7 @@ class AdvanceAnalyticsBaseView(BaseAPIView):
 
 
 class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
+
     def get_filtered_counts(self, queryset: QuerySet) -> Dict[str, int]:
         def get_filtered_count() -> int:
             if self.filters["analytics_date_range"]:
@@ -68,31 +76,36 @@ class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
 
         return {
             "count": get_filtered_count(),
-            # "filter_count": get_previous_count(),
+            "filter_count": get_previous_count(),
         }
 
     def get_overview_data(self) -> Dict[str, Dict[str, int]]:
-        members_query = WorkspaceMember.objects.filter(
-            workspace__slug=self._workspace_slug, is_active=True
-        )
-
-        if self.request.GET.get("project_ids", None):
-            project_ids = self.request.GET.get("project_ids", None)
-            project_ids = [str(project_id) for project_id in project_ids.split(",")]
-            members_query = ProjectMember.objects.filter(
-                project_id__in=project_ids, is_active=True
-            )
-
         return {
-            "total_users": self.get_filtered_counts(members_query),
+            "total_users": self.get_filtered_counts(
+                WorkspaceMember.objects.filter(
+                    workspace__slug=self._workspace_slug, is_active=True
+                )
+            ),
             "total_admins": self.get_filtered_counts(
-                members_query.filter(role=ROLE.ADMIN.value)
+                WorkspaceMember.objects.filter(
+                    workspace__slug=self._workspace_slug,
+                    role=ROLE.ADMIN.value,
+                    is_active=True,
+                )
             ),
             "total_members": self.get_filtered_counts(
-                members_query.filter(role=ROLE.MEMBER.value)
+                WorkspaceMember.objects.filter(
+                    workspace__slug=self._workspace_slug,
+                    role=ROLE.MEMBER.value,
+                    is_active=True,
+                )
             ),
             "total_guests": self.get_filtered_counts(
-                members_query.filter(role=ROLE.GUEST.value)
+                WorkspaceMember.objects.filter(
+                    workspace__slug=self._workspace_slug,
+                    role=ROLE.GUEST.value,
+                    is_active=True,
+                )
             ),
             "total_projects": self.get_filtered_counts(
                 Project.objects.filter(**self.filters["project_filters"])
@@ -105,13 +118,14 @@ class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
             ),
             "total_intake": self.get_filtered_counts(
                 Issue.objects.filter(**self.filters["base_filters"]).filter(
-                    issue_intake__status__in=["-2", "0"]
+                    issue_intake__isnull=False
                 )
             ),
         }
 
+
     def get_work_items_stats(self) -> Dict[str, Dict[str, int]]:
-        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+        base_queryset = Issue.objects.filter(**self.filters["base_filters"])
 
         return {
             "total_work_items": self.get_filtered_counts(base_queryset),
@@ -139,11 +153,13 @@ class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
                 self.get_overview_data(),
                 status=status.HTTP_200_OK,
             )
+
         elif tab == "work-items":
             return Response(
                 self.get_work_items_stats(),
                 status=status.HTTP_200_OK,
             )
+
         return Response({"message": "Invalid tab"}, status=status.HTTP_400_BAD_REQUEST)
 
 
@@ -160,21 +176,7 @@ class AdvanceAnalyticsStatsEndpoint(AdvanceAnalyticsBaseView):
             )
 
         return (
-            base_queryset.values("project_id", "project__name").annotate(
-                cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
-                completed_work_items=Count("id", filter=Q(state__group="completed")),
-                backlog_work_items=Count("id", filter=Q(state__group="backlog")),
-                un_started_work_items=Count("id", filter=Q(state__group="unstarted")),
-                started_work_items=Count("id", filter=Q(state__group="started")),
-            )
-            .order_by("project_id")
-        )
-
-    def get_work_items_stats(self) -> Dict[str, Dict[str, int]]:
-        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
-        return (
-            base_queryset
-            .values("project_id", "project__name")
+            base_queryset.values("project_id", "project__name")
             .annotate(
                 cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
                 completed_work_items=Count("id", filter=Q(state__group="completed")),
@@ -192,7 +194,7 @@ class AdvanceAnalyticsStatsEndpoint(AdvanceAnalyticsBaseView):
 
         if type == "work-items":
             return Response(
-                self.get_work_items_stats(),
+                self.get_project_issues_stats(),
                 status=status.HTTP_200_OK,
             )
 
@@ -261,10 +263,6 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
                 "assignees", "labels", "issue_module__module", "issue_cycle__cycle"
             )
         )
-
-        workspace = Workspace.objects.get(slug=self._workspace_slug)
-        start_date = workspace.created_at.date().replace(day=1)
-
         # Apply date range filter if available
         if self.filters["chart_period_range"]:
             start_date, end_date = self.filters["chart_period_range"]
@@ -272,52 +270,41 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
                 created_at__date__gte=start_date, created_at__date__lte=end_date
             )
 
-        # Annotate by month and count
-        monthly_stats = (
-            queryset.annotate(month=TruncMonth("created_at"))
-            .values("month")
+        # Get daily stats with optimized query
+        daily_stats = (
+            queryset.values("created_at__date")
             .annotate(
                 created_count=Count("id"),
-                completed_count=Count("id", filter=Q(state__group="completed")),
+                completed_count=Count("id", filter=Q(completed_at__isnull=False)),
             )
-            .order_by("month")
+            .order_by("created_at__date")
         )
 
-        # Create dictionary of month -> counts
+        # Create a dictionary of existing stats with summed counts
         stats_dict = {
-            stat["month"].strftime("%Y-%m-%d"): {
+            stat["created_at__date"].strftime("%Y-%m-%d"): {
                 "created_count": stat["created_count"],
                 "completed_count": stat["completed_count"],
             }
-            for stat in monthly_stats
+            for stat in daily_stats
         }
 
-        # Generate monthly data (ensure months with 0 count are included)
+        # Generate data for all days in the range
         data = []
-        # include the current date at the end
-        end_date = timezone.now().date()
-        last_month = end_date.replace(day=1)
-        current_month = start_date
-
-        while current_month <= last_month:
-            date_str = current_month.strftime("%Y-%m-%d")
+        current_date = start_date
+        while current_date <= end_date:
+            date_str = current_date.strftime("%Y-%m-%d")
             stats = stats_dict.get(date_str, {"created_count": 0, "completed_count": 0})
             data.append(
                 {
                     "key": date_str,
                     "name": date_str,
-                    "count": stats["created_count"],
+                    "count": stats["created_count"] + stats["completed_count"],
                     "completed_issues": stats["completed_count"],
                     "created_issues": stats["created_count"],
                 }
             )
-            # Move to next month
-            if current_month.month == 12:
-                current_month = current_month.replace(
-                    year=current_month.year + 1, month=1
-                )
-            else:
-                current_month = current_month.replace(month=current_month.month + 1)
+            current_date += timedelta(days=1)
 
         schema = {
             "completed_issues": "completed_issues",
@@ -337,6 +324,7 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
             return Response(self.project_chart(), status=status.HTTP_200_OK)
 
         elif type == "custom-work-items":
+            # Get the base queryset
             queryset = (
                 Issue.issue_objects.filter(**self.filters["base_filters"])
                 .select_related("workspace", "state", "parent")
@@ -364,3 +352,60 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
             )
 
         return Response({"message": "Invalid type"}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class AdvanceAnalyticsExportEndpoint(AdvanceAnalyticsBaseView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def post(self, request: HttpRequest, slug: str) -> Response:
+        self.initialize_workspace(slug, type="chart")
+        queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+
+        # Apply date range filter if available
+        if self.filters["chart_period_range"]:
+            start_date, end_date = self.filters["chart_period_range"]
+            queryset = queryset.filter(
+                created_at__date__gte=start_date, created_at__date__lte=end_date
+            )
+
+        queryset = (
+            queryset.values("project_id", "project__name")
+            .annotate(
+                cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
+                completed_work_items=Count("id", filter=Q(state__group="completed")),
+                backlog_work_items=Count("id", filter=Q(state__group="backlog")),
+                un_started_work_items=Count("id", filter=Q(state__group="unstarted")),
+                started_work_items=Count("id", filter=Q(state__group="started")),
+            )
+            .order_by("project_id")
+        )
+
+        # Convert QuerySet to list of dictionaries for serialization
+        serialized_data = list(queryset)
+
+        headers = [
+            "Projects",
+            "Completed Issues",
+            "Backlog Issues",
+            "Unstarted Issues",
+            "Started Issues",
+        ]
+
+        keys = [
+            "project__name",
+            "completed_work_items",
+            "backlog_work_items",
+            "un_started_work_items",
+            "started_work_items",
+        ]
+
+        email = request.user.email
+
+        # Send serialized data to background task
+        export_analytics_to_csv_email.delay(serialized_data, headers, keys, email, slug)
+
+        return Response(
+            {
+                "message": f"Once the export is ready it will be emailed to you at {str(email)}"
+            },
+            status=status.HTTP_200_OK,
+        )

apiserver/plane/app/views/analytic/project_analytics.py

@@ -1,421 +0,0 @@
-from rest_framework.response import Response
-from rest_framework import status
-from typing import Dict, Any
-from django.db.models import QuerySet, Q, Count
-from django.http import HttpRequest
-from django.db.models.functions import TruncMonth
-from django.utils import timezone
-from datetime import timedelta
-from plane.app.views.base import BaseAPIView
-from plane.app.permissions import ROLE, allow_permission
-from plane.db.models import (
-    Project,
-    Issue,
-    Cycle,
-    Module,
-    CycleIssue,
-    ModuleIssue,
-)
-from django.db import models
-from django.db.models import F, Case, When, Value
-from django.db.models.functions import Concat
-from plane.utils.build_chart import build_analytics_chart
-from plane.utils.date_utils import (
-    get_analytics_filters,
-)
-
-
-class ProjectAdvanceAnalyticsBaseView(BaseAPIView):
-    def initialize_workspace(self, slug: str, type: str) -> None:
-        self._workspace_slug = slug
-        self.filters = get_analytics_filters(
-            slug=slug,
-            type=type,
-            user=self.request.user,
-            date_filter=self.request.GET.get("date_filter", None),
-            project_ids=self.request.GET.get("project_ids", None),
-        )
-
-
-class ProjectAdvanceAnalyticsEndpoint(ProjectAdvanceAnalyticsBaseView):
-    def get_filtered_counts(self, queryset: QuerySet) -> Dict[str, int]:
-        def get_filtered_count() -> int:
-            if self.filters["analytics_date_range"]:
-                return queryset.filter(
-                    created_at__gte=self.filters["analytics_date_range"]["current"][
-                        "gte"
-                    ],
-                    created_at__lte=self.filters["analytics_date_range"]["current"][
-                        "lte"
-                    ],
-                ).count()
-            return queryset.count()
-
-        return {
-            "count": get_filtered_count(),
-        }
-
-    def get_work_items_stats(
-        self, project_id, cycle_id=None, module_id=None
-    ) -> Dict[str, Dict[str, int]]:
-        """
-        Returns work item stats for the workspace, or filtered by cycle_id or module_id if provided.
-        """
-        base_queryset = None
-        if cycle_id is not None:
-            cycle_issues = CycleIssue.objects.filter(
-                **self.filters["base_filters"], cycle_id=cycle_id
-            ).values_list("issue_id", flat=True)
-            base_queryset = Issue.issue_objects.filter(id__in=cycle_issues)
-        elif module_id is not None:
-            module_issues = ModuleIssue.objects.filter(
-                **self.filters["base_filters"], module_id=module_id
-            ).values_list("issue_id", flat=True)
-            base_queryset = Issue.issue_objects.filter(id__in=module_issues)
-        else:
-            base_queryset = Issue.issue_objects.filter(
-                **self.filters["base_filters"], project_id=project_id
-            )
-
-        return {
-            "total_work_items": self.get_filtered_counts(base_queryset),
-            "started_work_items": self.get_filtered_counts(
-                base_queryset.filter(state__group="started")
-            ),
-            "backlog_work_items": self.get_filtered_counts(
-                base_queryset.filter(state__group="backlog")
-            ),
-            "un_started_work_items": self.get_filtered_counts(
-                base_queryset.filter(state__group="unstarted")
-            ),
-            "completed_work_items": self.get_filtered_counts(
-                base_queryset.filter(state__group="completed")
-            ),
-        }
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def get(self, request: HttpRequest, slug: str, project_id: str) -> Response:
-        self.initialize_workspace(slug, type="analytics")
-
-        # Optionally accept cycle_id or module_id as query params
-        cycle_id = request.GET.get("cycle_id", None)
-        module_id = request.GET.get("module_id", None)
-        return Response(
-            self.get_work_items_stats(
-                cycle_id=cycle_id, module_id=module_id, project_id=project_id
-            ),
-            status=status.HTTP_200_OK,
-        )
-
-
-class ProjectAdvanceAnalyticsStatsEndpoint(ProjectAdvanceAnalyticsBaseView):
-    def get_project_issues_stats(self) -> QuerySet:
-        # Get the base queryset with workspace and project filters
-        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
-
-        # Apply date range filter if available
-        if self.filters["chart_period_range"]:
-            start_date, end_date = self.filters["chart_period_range"]
-            base_queryset = base_queryset.filter(
-                created_at__date__gte=start_date, created_at__date__lte=end_date
-            )
-
-        return (
-            base_queryset.values("project_id", "project__name")
-            .annotate(
-                cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
-                completed_work_items=Count("id", filter=Q(state__group="completed")),
-                backlog_work_items=Count("id", filter=Q(state__group="backlog")),
-                un_started_work_items=Count("id", filter=Q(state__group="unstarted")),
-                started_work_items=Count("id", filter=Q(state__group="started")),
-            )
-            .order_by("project_id")
-        )
-
-    def get_work_items_stats(
-        self, project_id, cycle_id=None, module_id=None
-    ) -> Dict[str, Dict[str, int]]:
-        base_queryset = None
-        if cycle_id is not None:
-            cycle_issues = CycleIssue.objects.filter(
-                **self.filters["base_filters"], cycle_id=cycle_id
-            ).values_list("issue_id", flat=True)
-            base_queryset = Issue.issue_objects.filter(id__in=cycle_issues)
-        elif module_id is not None:
-            module_issues = ModuleIssue.objects.filter(
-                **self.filters["base_filters"], module_id=module_id
-            ).values_list("issue_id", flat=True)
-            base_queryset = Issue.issue_objects.filter(id__in=module_issues)
-        else:
-            base_queryset = Issue.issue_objects.filter(
-                **self.filters["base_filters"], project_id=project_id
-            )
-        return (
-            base_queryset.annotate(display_name=F("assignees__display_name"))
-            .annotate(assignee_id=F("assignees__id"))
-            .annotate(avatar=F("assignees__avatar"))
-            .annotate(
-                avatar_url=Case(
-                    # If `avatar_asset` exists, use it to generate the asset URL
-                    When(
-                        assignees__avatar_asset__isnull=False,
-                        then=Concat(
-                            Value("/api/assets/v2/static/"),
-                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
-                            Value("/"),
-                        ),
-                    ),
-                    # If `avatar_asset` is None, fall back to using `avatar` field directly
-                    When(
-                        assignees__avatar_asset__isnull=True, then="assignees__avatar"
-                    ),
-                    default=Value(None),
-                    output_field=models.CharField(),
-                )
-            )
-            .values("display_name", "assignee_id", "avatar_url")
-            .annotate(
-                cancelled_work_items=Count(
-                    "id", filter=Q(state__group="cancelled"), distinct=True
-                ),
-                completed_work_items=Count(
-                    "id", filter=Q(state__group="completed"), distinct=True
-                ),
-                backlog_work_items=Count(
-                    "id", filter=Q(state__group="backlog"), distinct=True
-                ),
-                un_started_work_items=Count(
-                    "id", filter=Q(state__group="unstarted"), distinct=True
-                ),
-                started_work_items=Count(
-                    "id", filter=Q(state__group="started"), distinct=True
-                ),
-            )
-            .order_by("display_name")
-        )
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
-    def get(self, request: HttpRequest, slug: str, project_id: str) -> Response:
-        self.initialize_workspace(slug, type="chart")
-        type = request.GET.get("type", "work-items")
-
-        if type == "work-items":
-            # Optionally accept cycle_id or module_id as query params
-            cycle_id = request.GET.get("cycle_id", None)
-            module_id = request.GET.get("module_id", None)
-            return Response(
-                self.get_work_items_stats(
-                    project_id=project_id, cycle_id=cycle_id, module_id=module_id
-                ),
-                status=status.HTTP_200_OK,
-            )
-
-        return Response({"message": "Invalid type"}, status=status.HTTP_400_BAD_REQUEST)
-
-
-class ProjectAdvanceAnalyticsChartEndpoint(ProjectAdvanceAnalyticsBaseView):
-    def work_item_completion_chart(
-        self, project_id, cycle_id=None, module_id=None
-    ) -> Dict[str, Any]:
-        # Get the base queryset
-        queryset = (
-            Issue.issue_objects.filter(**self.filters["base_filters"])
-            .filter(project_id=project_id)
-            .select_related("workspace", "state", "parent")
-            .prefetch_related(
-                "assignees", "labels", "issue_module__module", "issue_cycle__cycle"
-            )
-        )
-
-        if cycle_id is not None:
-            cycle_issues = CycleIssue.objects.filter(
-                **self.filters["base_filters"], cycle_id=cycle_id
-            ).values_list("issue_id", flat=True)
-            cycle = Cycle.objects.filter(id=cycle_id).first()
-            if cycle and cycle.start_date:
-                start_date = cycle.start_date.date()
-                end_date = cycle.end_date.date()
-            else:
-                return {"data": [], "schema": {}}
-            queryset = cycle_issues
-
-        elif module_id is not None:
-            module_issues = ModuleIssue.objects.filter(
-                **self.filters["base_filters"], module_id=module_id
-            ).values_list("issue_id", flat=True)
-            module = Module.objects.filter(id=module_id).first()
-            if module and module.start_date:
-                start_date = module.start_date
-                end_date = module.target_date
-            else:
-                return {"data": [], "schema": {}}
-            queryset = module_issues
-
-        else:
-            project = Project.objects.filter(id=project_id).first()
-            if project.created_at:
-                start_date = project.created_at.date().replace(day=1)
-            else:
-                return {"data": [], "schema": {}}
-
-        if cycle_id or module_id:
-            # Get daily stats with optimized query
-            daily_stats = (
-                queryset.values("created_at__date")
-                .annotate(
-                    created_count=Count("id"),
-                    completed_count=Count(
-                        "id", filter=Q(issue__state__group="completed")
-                    ),
-                )
-                .order_by("created_at__date")
-            )
-
-            # Create a dictionary of existing stats with summed counts
-            stats_dict = {
-                stat["created_at__date"].strftime("%Y-%m-%d"): {
-                    "created_count": stat["created_count"],
-                    "completed_count": stat["completed_count"],
-                }
-                for stat in daily_stats
-            }
-
-            # Generate data for all days in the range
-            data = []
-            current_date = start_date
-            while current_date <= end_date:
-                date_str = current_date.strftime("%Y-%m-%d")
-                stats = stats_dict.get(
-                    date_str, {"created_count": 0, "completed_count": 0}
-                )
-                data.append(
-                    {
-                        "key": date_str,
-                        "name": date_str,
-                        "count": stats["created_count"] + stats["completed_count"],
-                        "completed_issues": stats["completed_count"],
-                        "created_issues": stats["created_count"],
-                    }
-                )
-                current_date += timedelta(days=1)
-        else:
-            # Apply date range filter if available
-            if self.filters["chart_period_range"]:
-                start_date, end_date = self.filters["chart_period_range"]
-                queryset = queryset.filter(
-                    created_at__date__gte=start_date, created_at__date__lte=end_date
-                )
-
-            # Annotate by month and count
-            monthly_stats = (
-                queryset.annotate(month=TruncMonth("created_at"))
-                .values("month")
-                .annotate(
-                    created_count=Count("id"),
-                    completed_count=Count("id", filter=Q(state__group="completed")),
-                )
-                .order_by("month")
-            )
-
-            # Create dictionary of month -> counts
-            stats_dict = {
-                stat["month"].strftime("%Y-%m-%d"): {
-                    "created_count": stat["created_count"],
-                    "completed_count": stat["completed_count"],
-                }
-                for stat in monthly_stats
-            }
-
-            # Generate monthly data (ensure months with 0 count are included)
-            data = []
-            # include the current date at the end
-            end_date = timezone.now().date()
-            last_month = end_date.replace(day=1)
-            current_month = start_date
-
-            while current_month <= last_month:
-                date_str = current_month.strftime("%Y-%m-%d")
-                stats = stats_dict.get(
-                    date_str, {"created_count": 0, "completed_count": 0}
-                )
-                data.append(
-                    {
-                        "key": date_str,
-                        "name": date_str,
-                        "count": stats["created_count"],
-                        "completed_issues": stats["completed_count"],
-                        "created_issues": stats["created_count"],
-                    }
-                )
-                # Move to next month
-                if current_month.month == 12:
-                    current_month = current_month.replace(
-                        year=current_month.year + 1, month=1
-                    )
-                else:
-                    current_month = current_month.replace(month=current_month.month + 1)
-
-        schema = {
-            "completed_issues": "completed_issues",
-            "created_issues": "created_issues",
-        }
-
-        return {"data": data, "schema": schema}
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
-    def get(self, request: HttpRequest, slug: str, project_id: str) -> Response:
-        self.initialize_workspace(slug, type="chart")
-        type = request.GET.get("type", "projects")
-        group_by = request.GET.get("group_by", None)
-        x_axis = request.GET.get("x_axis", "PRIORITY")
-        cycle_id = request.GET.get("cycle_id", None)
-        module_id = request.GET.get("module_id", None)
-
-        if type == "custom-work-items":
-            queryset = (
-                Issue.issue_objects.filter(**self.filters["base_filters"])
-                .filter(project_id=project_id)
-                .select_related("workspace", "state", "parent")
-                .prefetch_related(
-                    "assignees", "labels", "issue_module__module", "issue_cycle__cycle"
-                )
-            )
-
-            # Apply cycle/module filters if present
-            if cycle_id is not None:
-                cycle_issues = CycleIssue.objects.filter(
-                    **self.filters["base_filters"], cycle_id=cycle_id
-                ).values_list("issue_id", flat=True)
-                queryset = queryset.filter(id__in=cycle_issues)
-
-            elif module_id is not None:
-                module_issues = ModuleIssue.objects.filter(
-                    **self.filters["base_filters"], module_id=module_id
-                ).values_list("issue_id", flat=True)
-                queryset = queryset.filter(id__in=module_issues)
-
-            # Apply date range filter if available
-            if self.filters["chart_period_range"]:
-                start_date, end_date = self.filters["chart_period_range"]
-                queryset = queryset.filter(
-                    created_at__date__gte=start_date, created_at__date__lte=end_date
-                )
-
-            return Response(
-                build_analytics_chart(queryset, x_axis, group_by),
-                status=status.HTTP_200_OK,
-            )
-
-        elif type == "work-items":
-            # Optionally accept cycle_id or module_id as query params
-            cycle_id = request.GET.get("cycle_id", None)
-            module_id = request.GET.get("module_id", None)
-
-            return Response(
-                self.work_item_completion_chart(
-                    project_id=project_id, cycle_id=cycle_id, module_id=module_id
-                ),
-                status=status.HTTP_200_OK,
-            )
-
-        return Response({"message": "Invalid type"}, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/app/views/asset/v2.py

@@ -707,14 +707,3 @@ class ProjectBulkAssetEndpoint(BaseAPIView):
                 pass
 
         return Response(status=status.HTTP_204_NO_CONTENT)
-
-
-class AssetCheckEndpoint(BaseAPIView):
-    """Endpoint to check if an asset exists."""
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
-    def get(self, request, slug, asset_id):
-        asset = FileAsset.all_objects.filter(
-            id=asset_id, workspace__slug=slug, deleted_at__isnull=True
-        ).exists()
-        return Response({"exists": asset}, status=status.HTTP_200_OK)

apiserver/plane/app/views/cycle/base.py

@@ -1119,13 +1119,14 @@ class CycleUserPropertiesEndpoint(BaseAPIView):
 class CycleProgressEndpoint(BaseAPIView):
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def get(self, request, slug, project_id, cycle_id):
+
         cycle = Cycle.objects.filter(
             workspace__slug=slug, project_id=project_id, id=cycle_id
         ).first()
         if not cycle:
             return Response(
                 {"error": "Cycle not found"}, status=status.HTTP_404_NOT_FOUND
-            )
+            ) 
         aggregate_estimates = (
             Issue.issue_objects.filter(
                 estimate_point__estimate__type="points",
@@ -1176,7 +1177,7 @@ class CycleProgressEndpoint(BaseAPIView):
                 ),
             )
         )
-        if cycle.progress_snapshot:
+        if cycle.progress_snapshot:      
             backlog_issues = cycle.progress_snapshot.get("backlog_issues", 0)
             unstarted_issues = cycle.progress_snapshot.get("unstarted_issues", 0)
             started_issues = cycle.progress_snapshot.get("started_issues", 0)

apiserver/plane/app/views/cycle/issue.py

@@ -29,7 +29,6 @@ from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPagina
 from plane.app.permissions import allow_permission, ROLE
 from plane.utils.host import base_host
 
-
 class CycleIssueViewSet(BaseViewSet):
     serializer_class = CycleIssueSerializer
     model = CycleIssue

apiserver/plane/app/views/external/base.py

@@ -11,7 +11,8 @@ from rest_framework.response import Response
 
 # Module import
 from plane.app.permissions import ROLE, allow_permission
-from plane.app.serializers import ProjectLiteSerializer, WorkspaceLiteSerializer
+from plane.app.serializers import (ProjectLiteSerializer,
+                                   WorkspaceLiteSerializer)
 from plane.db.models import Project, Workspace
 from plane.license.utils.instance_value import get_configuration_value
 from plane.utils.exception_logger import log_exception
@@ -21,7 +22,6 @@ from ..base import BaseAPIView
 
 class LLMProvider:
     """Base class for LLM provider configurations"""
-
     name: str = ""
     models: List[str] = []
     default_model: str = ""
@@ -34,13 +34,11 @@ class LLMProvider:
             "default_model": cls.default_model,
         }
 
-
 class OpenAIProvider(LLMProvider):
     name = "OpenAI"
     models = ["gpt-3.5-turbo", "gpt-4o-mini", "gpt-4o", "o1-mini", "o1-preview"]
     default_model = "gpt-4o-mini"
 
-
 class AnthropicProvider(LLMProvider):
     name = "Anthropic"
     models = [
@@ -51,45 +49,40 @@ class AnthropicProvider(LLMProvider):
         "claude-2.1",
         "claude-2",
         "claude-instant-1.2",
-        "claude-instant-1",
+        "claude-instant-1"
     ]
     default_model = "claude-3-sonnet-20240229"
 
-
 class GeminiProvider(LLMProvider):
     name = "Gemini"
     models = ["gemini-pro", "gemini-1.5-pro-latest", "gemini-pro-vision"]
     default_model = "gemini-pro"
 
-
 SUPPORTED_PROVIDERS = {
     "openai": OpenAIProvider,
     "anthropic": AnthropicProvider,
     "gemini": GeminiProvider,
 }
 
-
 def get_llm_config() -> Tuple[str | None, str | None, str | None]:
     """
     Helper to get LLM configuration values, returns:
         - api_key, model, provider
     """
-    api_key, provider_key, model = get_configuration_value(
-        [
-            {
-                "key": "LLM_API_KEY",
-                "default": os.environ.get("LLM_API_KEY", None),
-            },
-            {
-                "key": "LLM_PROVIDER",
-                "default": os.environ.get("LLM_PROVIDER", "openai"),
-            },
-            {
-                "key": "LLM_MODEL",
-                "default": os.environ.get("LLM_MODEL", None),
-            },
-        ]
-    )
+    api_key, provider_key, model = get_configuration_value([
+        {
+            "key": "LLM_API_KEY",
+            "default": os.environ.get("LLM_API_KEY", None),
+        },
+        {
+            "key": "LLM_PROVIDER",
+            "default": os.environ.get("LLM_PROVIDER", "openai"),
+        },
+        {
+            "key": "LLM_MODEL",
+            "default": os.environ.get("LLM_MODEL", None),
+        },
+    ])
 
     provider = SUPPORTED_PROVIDERS.get(provider_key.lower())
     if not provider:
@@ -106,20 +99,16 @@ def get_llm_config() -> Tuple[str | None, str | None, str | None]:
 
     # Validate model is supported by provider
     if model not in provider.models:
-        log_exception(
-            ValueError(
-                f"Model {model} not supported by {provider.name}. "
-                f"Supported models: {', '.join(provider.models)}"
-            )
-        )
+        log_exception(ValueError(
+            f"Model {model} not supported by {provider.name}. "
+            f"Supported models: {', '.join(provider.models)}"
+        ))
         return None, None, None
 
     return api_key, model, provider_key
 
 
-def get_llm_response(
-    task, prompt, api_key: str, model: str, provider: str
-) -> Tuple[str | None, str | None]:
+def get_llm_response(task, prompt, api_key: str, model: str, provider: str) -> Tuple[str | None, str | None]:
     """Helper to get LLM completion response"""
     final_text = task + "\n" + prompt
     try:
@@ -129,7 +118,10 @@ def get_llm_response(
 
         client = OpenAI(api_key=api_key)
         chat_completion = client.chat.completions.create(
-            model=model, messages=[{"role": "user", "content": final_text}]
+            model=model,
+            messages=[
+                {"role": "user", "content": final_text}
+            ]
         )
         text = chat_completion.choices[0].message.content
         return text, None
@@ -143,7 +135,6 @@ def get_llm_response(
         else:
             return None, f"Error occurred while generating response from {provider}"
 
-
 class GPTIntegrationEndpoint(BaseAPIView):
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
     def post(self, request, slug, project_id):
@@ -161,9 +152,7 @@ class GPTIntegrationEndpoint(BaseAPIView):
                 {"error": "Task is required"}, status=status.HTTP_400_BAD_REQUEST
             )
 
-        text, error = get_llm_response(
-            task, request.data.get("prompt", False), api_key, model, provider
-        )
+        text, error = get_llm_response(task, request.data.get("prompt", False), api_key, model, provider)
         if not text and error:
             return Response(
                 {"error": "An internal error has occurred."},
@@ -201,9 +190,7 @@ class WorkspaceGPTIntegrationEndpoint(BaseAPIView):
                 {"error": "Task is required"}, status=status.HTTP_400_BAD_REQUEST
             )
 
-        text, error = get_llm_response(
-            task, request.data.get("prompt", False), api_key, model, provider
-        )
+        text, error = get_llm_response(task, request.data.get("prompt", False), api_key, model, provider)
         if not text and error:
             return Response(
                 {"error": "An internal error has occurred."},

apiserver/plane/app/views/issue/archive.py

@@ -38,7 +38,6 @@ from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPagina
 from plane.app.permissions import allow_permission, ROLE
 from plane.utils.error_codes import ERROR_CODES
 from plane.utils.host import base_host
-
 # Module imports
 from .. import BaseViewSet, BaseAPIView
 

apiserver/plane/app/views/issue/attachment.py

@@ -23,7 +23,6 @@ from plane.settings.storage import S3Storage
 from plane.bgtasks.storage_metadata_task import get_asset_object_metadata
 from plane.utils.host import base_host
 
-
 class IssueAttachmentEndpoint(BaseAPIView):
     serializer_class = IssueAttachmentSerializer
     model = FileAsset

apiserver/plane/app/views/issue/comment.py

@@ -19,7 +19,6 @@ from plane.db.models import IssueComment, ProjectMember, CommentReaction, Projec
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.utils.host import base_host
 
-
 class IssueCommentViewSet(BaseViewSet):
     serializer_class = IssueCommentSerializer
     model = IssueComment

apiserver/plane/app/views/issue/link.py

@@ -15,10 +15,8 @@ from plane.app.serializers import IssueLinkSerializer
 from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import IssueLink
 from plane.bgtasks.issue_activities_task import issue_activity
-from plane.bgtasks.work_item_link_task import crawl_work_item_link_title
 from plane.utils.host import base_host
 
-
 class IssueLinkViewSet(BaseViewSet):
     permission_classes = [ProjectEntityPermission]
 
@@ -45,9 +43,6 @@ class IssueLinkViewSet(BaseViewSet):
         serializer = IssueLinkSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save(project_id=project_id, issue_id=issue_id)
-            crawl_work_item_link_title.delay(
-                serializer.data.get("id"), serializer.data.get("url")
-            )
             issue_activity.delay(
                 type="link.activity.created",
                 requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
@@ -59,10 +54,6 @@ class IssueLinkViewSet(BaseViewSet):
                 notification=True,
                 origin=base_host(request=request, is_app=True),
             )
-
-            issue_link = self.get_queryset().get(id=serializer.data.get("id"))
-            serializer = IssueLinkSerializer(issue_link)
-
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
@@ -74,14 +65,9 @@ class IssueLinkViewSet(BaseViewSet):
         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()
-            crawl_work_item_link_title.delay(
-                serializer.data.get("id"), serializer.data.get("url")
-            )
-
             issue_activity.delay(
                 type="link.activity.updated",
                 requested_data=requested_data,
@@ -93,9 +79,6 @@ class IssueLinkViewSet(BaseViewSet):
                 notification=True,
                 origin=base_host(request=request, is_app=True),
             )
-            issue_link = self.get_queryset().get(id=serializer.data.get("id"))
-            serializer = IssueLinkSerializer(issue_link)
-
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 

apiserver/plane/app/views/issue/reaction.py

@@ -17,7 +17,6 @@ from plane.db.models import IssueReaction
 from plane.bgtasks.issue_activities_task import issue_activity
 from plane.utils.host import base_host
 
-
 class IssueReactionViewSet(BaseViewSet):
     serializer_class = IssueReactionSerializer
     model = IssueReaction

apiserver/plane/app/views/issue/relation.py

@@ -29,7 +29,6 @@ from plane.bgtasks.issue_activities_task import issue_activity
 from plane.utils.issue_relation_mapper import get_actual_relation
 from plane.utils.host import base_host
 
-
 class IssueRelationViewSet(BaseViewSet):
     serializer_class = IssueRelationSerializer
     model = IssueRelation

apiserver/plane/app/views/issue/sub_issue.py

@@ -25,7 +25,6 @@ from collections import defaultdict
 from plane.utils.host import base_host
 from plane.utils.order_queryset import order_issue_queryset
 
-
 class SubIssuesEndpoint(BaseAPIView):
     permission_classes = [ProjectEntityPermission]
 

apiserver/plane/app/views/module/base.py

@@ -63,7 +63,6 @@ from .. import BaseAPIView, BaseViewSet
 from plane.bgtasks.recent_visited_task import recent_visited_task
 from plane.utils.host import base_host
 
-
 class ModuleViewSet(BaseViewSet):
     model = Module
     webhook_event = "module"

apiserver/plane/app/views/module/issue.py

@@ -36,7 +36,6 @@ from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPagina
 from .. import BaseViewSet
 from plane.utils.host import base_host
 
-
 class ModuleIssueViewSet(BaseViewSet):
     serializer_class = ModuleIssueSerializer
     model = ModuleIssue
@@ -281,11 +280,7 @@ class ModuleIssueViewSet(BaseViewSet):
                 issue_id=str(issue_id),
                 project_id=str(project_id),
                 current_instance=json.dumps(
-                    {
-                        "module_name": module_issue.first().module.name
-                        if (module_issue.first() and module_issue.first().module)
-                        else None
-                    }
+                    {"module_name": module_issue.first().module.name if (module_issue.first() and module_issue.first().module) else None}
                 ),
                 epoch=int(timezone.now().timestamp()),
                 notification=True,

apiserver/plane/app/views/project/base.py

@@ -341,10 +341,7 @@ class ProjectViewSet(BaseViewSet):
         except IntegrityError as e:
             if "already exists" in str(e):
                 return Response(
-                    {
-                        "name": "The project name is already taken",
-                        "code": "PROJECT_NAME_ALREADY_EXIST",
-                    },
+                    {"name": "The project name is already taken"},
                     status=status.HTTP_409_CONFLICT,
                 )
         except Workspace.DoesNotExist:
@@ -353,10 +350,7 @@ class ProjectViewSet(BaseViewSet):
             )
         except serializers.ValidationError:
             return Response(
-                {
-                    "identifier": "The project identifier is already taken",
-                    "code": "PROJECT_IDENTIFIER_ALREADY_EXIST",
-                },
+                {"identifier": "The project identifier is already taken"},
                 status=status.HTTP_409_CONFLICT,
             )
 
@@ -425,10 +419,7 @@ class ProjectViewSet(BaseViewSet):
         except IntegrityError as e:
             if "already exists" in str(e):
                 return Response(
-                    {
-                        "name": "The project name is already taken",
-                        "code": "PROJECT_NAME_ALREADY_EXIST",
-                    },
+                    {"name": "The project name is already taken"},
                     status=status.HTTP_409_CONFLICT,
                 )
         except (Project.DoesNotExist, Workspace.DoesNotExist):
@@ -437,10 +428,7 @@ class ProjectViewSet(BaseViewSet):
             )
         except serializers.ValidationError:
             return Response(
-                {
-                    "identifier": "The project identifier is already taken",
-                    "code": "PROJECT_IDENTIFIER_ALREADY_EXIST",
-                },
+                {"identifier": "The project identifier is already taken"},
                 status=status.HTTP_409_CONFLICT,
             )
 
@@ -457,7 +445,7 @@ class ProjectViewSet(BaseViewSet):
                 is_active=True,
             ).exists()
         ):
-            project = Project.objects.get(pk=pk, workspace__slug=slug)
+            project = Project.objects.get(pk=pk)
             project.delete()
             webhook_activity.delay(
                 event="project",

apiserver/plane/app/views/project/invite.py

@@ -29,7 +29,6 @@ from plane.db.models import (
 from plane.db.models.project import ProjectNetwork
 from plane.utils.host import base_host
 
-
 class ProjectInvitationsViewset(BaseViewSet):
     serializer_class = ProjectMemberInviteSerializer
     model = ProjectMemberInvite

apiserver/plane/app/views/project/member.py

@@ -168,8 +168,6 @@ class ProjectMemberViewSet(BaseViewSet):
             workspace__slug=slug,
             member__is_bot=False,
             is_active=True,
-            member__member_workspace__workspace__slug=slug,
-            member__member_workspace__is_active=True,
         ).select_related("project", "member", "workspace")
 
         serializer = ProjectMemberRoleSerializer(
@@ -315,11 +313,7 @@ class UserProjectRolesEndpoint(BaseAPIView):
 
     def get(self, request, slug):
         project_members = ProjectMember.objects.filter(
-            workspace__slug=slug,
-            member_id=request.user.id,
-            is_active=True,
-            member__member_workspace__workspace__slug=slug,
-            member__member_workspace__is_active=True,
+            workspace__slug=slug, member_id=request.user.id, is_active=True
         ).values("project_id", "role")
 
         project_members = {

apiserver/plane/app/views/timezone/base.py

@@ -24,152 +24,125 @@ class TimezoneEndpoint(APIView):
     @method_decorator(cache_page(60 * 60 * 2))
     def get(self, request):
         timezone_locations = [
-            ("Midway Island", "Pacific/Midway"),  # UTC-11:00
-            ("American Samoa", "Pacific/Pago_Pago"),  # UTC-11:00
-            ("Hawaii", "Pacific/Honolulu"),  # UTC-10:00
-            ("Aleutian Islands", "America/Adak"),  # UTC-10:00 (DST: UTC-09:00)
-            ("Marquesas Islands", "Pacific/Marquesas"),  # UTC-09:30
-            ("Alaska", "America/Anchorage"),  # UTC-09:00 (DST: UTC-08:00)
-            ("Gambier Islands", "Pacific/Gambier"),  # UTC-09:00
-            (
-                "Pacific Time (US and Canada)",
-                "America/Los_Angeles",
-            ),  # UTC-08:00 (DST: UTC-07:00)
-            ("Baja California", "America/Tijuana"),  # UTC-08:00 (DST: UTC-07:00)
-            (
-                "Mountain Time (US and Canada)",
-                "America/Denver",
-            ),  # UTC-07:00 (DST: UTC-06:00)
-            ("Arizona", "America/Phoenix"),  # UTC-07:00
-            ("Chihuahua, Mazatlan", "America/Chihuahua"),  # UTC-07:00 (DST: UTC-06:00)
-            (
-                "Central Time (US and Canada)",
-                "America/Chicago",
-            ),  # UTC-06:00 (DST: UTC-05:00)
-            ("Saskatchewan", "America/Regina"),  # UTC-06:00
-            (
-                "Guadalajara, Mexico City, Monterrey",
-                "America/Mexico_City",
-            ),  # UTC-06:00 (DST: UTC-05:00)
-            ("Tegucigalpa, Honduras", "America/Tegucigalpa"),  # UTC-06:00
-            ("Costa Rica", "America/Costa_Rica"),  # UTC-06:00
-            (
-                "Eastern Time (US and Canada)",
-                "America/New_York",
-            ),  # UTC-05:00 (DST: UTC-04:00)
-            ("Lima", "America/Lima"),  # UTC-05:00
-            ("Bogota", "America/Bogota"),  # UTC-05:00
-            ("Quito", "America/Guayaquil"),  # UTC-05:00
-            ("Chetumal", "America/Cancun"),  # UTC-05:00 (DST: UTC-04:00)
-            ("Caracas (Old Venezuela Time)", "America/Caracas"),  # UTC-04:30
-            ("Atlantic Time (Canada)", "America/Halifax"),  # UTC-04:00 (DST: UTC-03:00)
-            ("Caracas", "America/Caracas"),  # UTC-04:00
-            ("Santiago", "America/Santiago"),  # UTC-04:00 (DST: UTC-03:00)
-            ("La Paz", "America/La_Paz"),  # UTC-04:00
-            ("Manaus", "America/Manaus"),  # UTC-04:00
-            ("Georgetown", "America/Guyana"),  # UTC-04:00
-            ("Bermuda", "Atlantic/Bermuda"),  # UTC-04:00 (DST: UTC-03:00)
-            (
-                "Newfoundland Time (Canada)",
-                "America/St_Johns",
-            ),  # UTC-03:30 (DST: UTC-02:30)
-            ("Buenos Aires", "America/Argentina/Buenos_Aires"),  # UTC-03:00
-            ("Brasilia", "America/Sao_Paulo"),  # UTC-03:00
-            ("Greenland", "America/Godthab"),  # UTC-03:00 (DST: UTC-02:00)
-            ("Montevideo", "America/Montevideo"),  # UTC-03:00
-            ("Falkland Islands", "Atlantic/Stanley"),  # UTC-03:00
-            (
-                "South Georgia and the South Sandwich Islands",
-                "Atlantic/South_Georgia",
-            ),  # UTC-02:00
-            ("Azores", "Atlantic/Azores"),  # UTC-01:00 (DST: UTC+00:00)
-            ("Cape Verde Islands", "Atlantic/Cape_Verde"),  # UTC-01:00
-            ("Dublin", "Europe/Dublin"),  # UTC+00:00 (DST: UTC+01:00)
-            ("Reykjavik", "Atlantic/Reykjavik"),  # UTC+00:00
-            ("Lisbon", "Europe/Lisbon"),  # UTC+00:00 (DST: UTC+01:00)
-            ("Monrovia", "Africa/Monrovia"),  # UTC+00:00
-            ("Casablanca", "Africa/Casablanca"),  # UTC+00:00 (DST: UTC+01:00)
-            (
-                "Central European Time (Berlin, Rome, Paris)",
-                "Europe/Paris",
-            ),  # UTC+01:00 (DST: UTC+02:00)
-            ("West Central Africa", "Africa/Lagos"),  # UTC+01:00
-            ("Algiers", "Africa/Algiers"),  # UTC+01:00
-            ("Lagos", "Africa/Lagos"),  # UTC+01:00
-            ("Tunis", "Africa/Tunis"),  # UTC+01:00
-            (
-                "Eastern European Time (Cairo, Helsinki, Kyiv)",
-                "Europe/Kiev",
-            ),  # UTC+02:00 (DST: UTC+03:00)
-            ("Athens", "Europe/Athens"),  # UTC+02:00 (DST: UTC+03:00)
-            ("Jerusalem", "Asia/Jerusalem"),  # UTC+02:00 (DST: UTC+03:00)
-            ("Johannesburg", "Africa/Johannesburg"),  # UTC+02:00
-            ("Harare, Pretoria", "Africa/Harare"),  # UTC+02:00
-            ("Moscow Time", "Europe/Moscow"),  # UTC+03:00
-            ("Baghdad", "Asia/Baghdad"),  # UTC+03:00
-            ("Nairobi", "Africa/Nairobi"),  # UTC+03:00
-            ("Kuwait, Riyadh", "Asia/Riyadh"),  # UTC+03:00
-            ("Tehran", "Asia/Tehran"),  # UTC+03:30 (DST: UTC+04:30)
-            ("Abu Dhabi", "Asia/Dubai"),  # UTC+04:00
-            ("Baku", "Asia/Baku"),  # UTC+04:00 (DST: UTC+05:00)
-            ("Yerevan", "Asia/Yerevan"),  # UTC+04:00 (DST: UTC+05:00)
-            ("Astrakhan", "Europe/Astrakhan"),  # UTC+04:00
-            ("Tbilisi", "Asia/Tbilisi"),  # UTC+04:00
-            ("Mauritius", "Indian/Mauritius"),  # UTC+04:00
-            ("Islamabad", "Asia/Karachi"),  # UTC+05:00
-            ("Karachi", "Asia/Karachi"),  # UTC+05:00
-            ("Tashkent", "Asia/Tashkent"),  # UTC+05:00
-            ("Yekaterinburg", "Asia/Yekaterinburg"),  # UTC+05:00
-            ("Maldives", "Indian/Maldives"),  # UTC+05:00
-            ("Chagos", "Indian/Chagos"),  # UTC+05:00
-            ("Chennai", "Asia/Kolkata"),  # UTC+05:30
-            ("Kolkata", "Asia/Kolkata"),  # UTC+05:30
-            ("Mumbai", "Asia/Kolkata"),  # UTC+05:30
-            ("New Delhi", "Asia/Kolkata"),  # UTC+05:30
-            ("Sri Jayawardenepura", "Asia/Colombo"),  # UTC+05:30
-            ("Kathmandu", "Asia/Kathmandu"),  # UTC+05:45
-            ("Dhaka", "Asia/Dhaka"),  # UTC+06:00
-            ("Almaty", "Asia/Almaty"),  # UTC+06:00
-            ("Bishkek", "Asia/Bishkek"),  # UTC+06:00
-            ("Thimphu", "Asia/Thimphu"),  # UTC+06:00
-            ("Yangon (Rangoon)", "Asia/Yangon"),  # UTC+06:30
-            ("Cocos Islands", "Indian/Cocos"),  # UTC+06:30
-            ("Bangkok", "Asia/Bangkok"),  # UTC+07:00
-            ("Hanoi", "Asia/Ho_Chi_Minh"),  # UTC+07:00
-            ("Jakarta", "Asia/Jakarta"),  # UTC+07:00
-            ("Novosibirsk", "Asia/Novosibirsk"),  # UTC+07:00
-            ("Krasnoyarsk", "Asia/Krasnoyarsk"),  # UTC+07:00
-            ("Beijing", "Asia/Shanghai"),  # UTC+08:00
-            ("Singapore", "Asia/Singapore"),  # UTC+08:00
-            ("Perth", "Australia/Perth"),  # UTC+08:00
-            ("Hong Kong", "Asia/Hong_Kong"),  # UTC+08:00
-            ("Ulaanbaatar", "Asia/Ulaanbaatar"),  # UTC+08:00
-            ("Palau", "Pacific/Palau"),  # UTC+08:00
-            ("Eucla", "Australia/Eucla"),  # UTC+08:45
-            ("Tokyo", "Asia/Tokyo"),  # UTC+09:00
-            ("Seoul", "Asia/Seoul"),  # UTC+09:00
-            ("Yakutsk", "Asia/Yakutsk"),  # UTC+09:00
-            ("Adelaide", "Australia/Adelaide"),  # UTC+09:30 (DST: UTC+10:30)
-            ("Darwin", "Australia/Darwin"),  # UTC+09:30
-            ("Sydney", "Australia/Sydney"),  # UTC+10:00 (DST: UTC+11:00)
-            ("Brisbane", "Australia/Brisbane"),  # UTC+10:00
-            ("Guam", "Pacific/Guam"),  # UTC+10:00
-            ("Vladivostok", "Asia/Vladivostok"),  # UTC+10:00
-            ("Tahiti", "Pacific/Tahiti"),  # UTC+10:00
-            ("Lord Howe Island", "Australia/Lord_Howe"),  # UTC+10:30 (DST: UTC+11:00)
-            ("Solomon Islands", "Pacific/Guadalcanal"),  # UTC+11:00
-            ("Magadan", "Asia/Magadan"),  # UTC+11:00
-            ("Norfolk Island", "Pacific/Norfolk"),  # UTC+11:00
-            ("Bougainville Island", "Pacific/Bougainville"),  # UTC+11:00
-            ("Chokurdakh", "Asia/Srednekolymsk"),  # UTC+11:00
-            ("Auckland", "Pacific/Auckland"),  # UTC+12:00 (DST: UTC+13:00)
-            ("Wellington", "Pacific/Auckland"),  # UTC+12:00 (DST: UTC+13:00)
-            ("Fiji Islands", "Pacific/Fiji"),  # UTC+12:00 (DST: UTC+13:00)
-            ("Anadyr", "Asia/Anadyr"),  # UTC+12:00
-            ("Chatham Islands", "Pacific/Chatham"),  # UTC+12:45 (DST: UTC+13:45)
-            ("Nuku'alofa", "Pacific/Tongatapu"),  # UTC+13:00
-            ("Samoa", "Pacific/Apia"),  # UTC+13:00 (DST: UTC+14:00)
-            ("Kiritimati Island", "Pacific/Kiritimati"),  # UTC+14:00
+            ('Midway Island', 'Pacific/Midway'),  # UTC-11:00
+            ('American Samoa', 'Pacific/Pago_Pago'),  # UTC-11:00
+            ('Hawaii', 'Pacific/Honolulu'),  # UTC-10:00
+            ('Aleutian Islands', 'America/Adak'),  # UTC-10:00 (DST: UTC-09:00)
+            ('Marquesas Islands', 'Pacific/Marquesas'),  # UTC-09:30
+            ('Alaska', 'America/Anchorage'),  # UTC-09:00 (DST: UTC-08:00)
+            ('Gambier Islands', 'Pacific/Gambier'),  # UTC-09:00
+            ('Pacific Time (US and Canada)', 'America/Los_Angeles'),  # UTC-08:00 (DST: UTC-07:00)
+            ('Baja California', 'America/Tijuana'),  # UTC-08:00 (DST: UTC-07:00)
+            ('Mountain Time (US and Canada)', 'America/Denver'),  # UTC-07:00 (DST: UTC-06:00)
+            ('Arizona', 'America/Phoenix'),  # UTC-07:00
+            ('Chihuahua, Mazatlan', 'America/Chihuahua'),  # UTC-07:00 (DST: UTC-06:00)
+            ('Central Time (US and Canada)', 'America/Chicago'),  # UTC-06:00 (DST: UTC-05:00)
+            ('Saskatchewan', 'America/Regina'),  # UTC-06:00
+            ('Guadalajara, Mexico City, Monterrey', 'America/Mexico_City'),  # UTC-06:00 (DST: UTC-05:00)
+            ('Tegucigalpa, Honduras', 'America/Tegucigalpa'),  # UTC-06:00
+            ('Costa Rica', 'America/Costa_Rica'),  # UTC-06:00
+            ('Eastern Time (US and Canada)', 'America/New_York'),  # UTC-05:00 (DST: UTC-04:00)
+            ('Lima', 'America/Lima'),  # UTC-05:00
+            ('Bogota', 'America/Bogota'),  # UTC-05:00
+            ('Quito', 'America/Guayaquil'),  # UTC-05:00
+            ('Chetumal', 'America/Cancun'),  # UTC-05:00 (DST: UTC-04:00)
+            ('Caracas (Old Venezuela Time)', 'America/Caracas'),  # UTC-04:30
+            ('Atlantic Time (Canada)', 'America/Halifax'),  # UTC-04:00 (DST: UTC-03:00)
+            ('Caracas', 'America/Caracas'),  # UTC-04:00
+            ('Santiago', 'America/Santiago'),  # UTC-04:00 (DST: UTC-03:00)
+            ('La Paz', 'America/La_Paz'),  # UTC-04:00
+            ('Manaus', 'America/Manaus'),  # UTC-04:00
+            ('Georgetown', 'America/Guyana'),  # UTC-04:00
+            ('Bermuda', 'Atlantic/Bermuda'),  # UTC-04:00 (DST: UTC-03:00)
+            ('Newfoundland Time (Canada)', 'America/St_Johns'),  # UTC-03:30 (DST: UTC-02:30)
+            ('Buenos Aires', 'America/Argentina/Buenos_Aires'),  # UTC-03:00
+            ('Brasilia', 'America/Sao_Paulo'),  # UTC-03:00
+            ('Greenland', 'America/Godthab'),  # UTC-03:00 (DST: UTC-02:00)
+            ('Montevideo', 'America/Montevideo'),  # UTC-03:00
+            ('Falkland Islands', 'Atlantic/Stanley'),  # UTC-03:00
+            ('South Georgia and the South Sandwich Islands', 'Atlantic/South_Georgia'),  # UTC-02:00
+            ('Azores', 'Atlantic/Azores'),  # UTC-01:00 (DST: UTC+00:00)
+            ('Cape Verde Islands', 'Atlantic/Cape_Verde'),  # UTC-01:00
+            ('Dublin', 'Europe/Dublin'),  # UTC+00:00 (DST: UTC+01:00)
+            ('Reykjavik', 'Atlantic/Reykjavik'),  # UTC+00:00
+            ('Lisbon', 'Europe/Lisbon'),  # UTC+00:00 (DST: UTC+01:00)
+            ('Monrovia', 'Africa/Monrovia'),  # UTC+00:00
+            ('Casablanca', 'Africa/Casablanca'),  # UTC+00:00 (DST: UTC+01:00)
+            ('Central European Time (Berlin, Rome, Paris)', 'Europe/Paris'),  # UTC+01:00 (DST: UTC+02:00)
+            ('West Central Africa', 'Africa/Lagos'),  # UTC+01:00
+            ('Algiers', 'Africa/Algiers'),  # UTC+01:00
+            ('Lagos', 'Africa/Lagos'),  # UTC+01:00
+            ('Tunis', 'Africa/Tunis'),  # UTC+01:00
+            ('Eastern European Time (Cairo, Helsinki, Kyiv)', 'Europe/Kiev'),  # UTC+02:00 (DST: UTC+03:00)
+            ('Athens', 'Europe/Athens'),  # UTC+02:00 (DST: UTC+03:00)
+            ('Jerusalem', 'Asia/Jerusalem'),  # UTC+02:00 (DST: UTC+03:00)
+            ('Johannesburg', 'Africa/Johannesburg'),  # UTC+02:00
+            ('Harare, Pretoria', 'Africa/Harare'),  # UTC+02:00
+            ('Moscow Time', 'Europe/Moscow'),  # UTC+03:00
+            ('Baghdad', 'Asia/Baghdad'),  # UTC+03:00
+            ('Nairobi', 'Africa/Nairobi'),  # UTC+03:00
+            ('Kuwait, Riyadh', 'Asia/Riyadh'),  # UTC+03:00
+            ('Tehran', 'Asia/Tehran'),  # UTC+03:30 (DST: UTC+04:30)
+            ('Abu Dhabi', 'Asia/Dubai'),  # UTC+04:00
+            ('Baku', 'Asia/Baku'),  # UTC+04:00 (DST: UTC+05:00)
+            ('Yerevan', 'Asia/Yerevan'),  # UTC+04:00 (DST: UTC+05:00)
+            ('Astrakhan', 'Europe/Astrakhan'),  # UTC+04:00
+            ('Tbilisi', 'Asia/Tbilisi'),  # UTC+04:00
+            ('Mauritius', 'Indian/Mauritius'),  # UTC+04:00
+            ('Islamabad', 'Asia/Karachi'),  # UTC+05:00
+            ('Karachi', 'Asia/Karachi'),  # UTC+05:00
+            ('Tashkent', 'Asia/Tashkent'),  # UTC+05:00
+            ('Yekaterinburg', 'Asia/Yekaterinburg'),  # UTC+05:00
+            ('Maldives', 'Indian/Maldives'),  # UTC+05:00
+            ('Chagos', 'Indian/Chagos'),  # UTC+05:00
+            ('Chennai', 'Asia/Kolkata'),  # UTC+05:30
+            ('Kolkata', 'Asia/Kolkata'),  # UTC+05:30
+            ('Mumbai', 'Asia/Kolkata'),  # UTC+05:30
+            ('New Delhi', 'Asia/Kolkata'),  # UTC+05:30
+            ('Sri Jayawardenepura', 'Asia/Colombo'),  # UTC+05:30
+            ('Kathmandu', 'Asia/Kathmandu'),  # UTC+05:45
+            ('Dhaka', 'Asia/Dhaka'),  # UTC+06:00
+            ('Almaty', 'Asia/Almaty'),  # UTC+06:00
+            ('Bishkek', 'Asia/Bishkek'),  # UTC+06:00
+            ('Thimphu', 'Asia/Thimphu'),  # UTC+06:00
+            ('Yangon (Rangoon)', 'Asia/Yangon'),  # UTC+06:30
+            ('Cocos Islands', 'Indian/Cocos'),  # UTC+06:30
+            ('Bangkok', 'Asia/Bangkok'),  # UTC+07:00
+            ('Hanoi', 'Asia/Ho_Chi_Minh'),  # UTC+07:00
+            ('Jakarta', 'Asia/Jakarta'),  # UTC+07:00
+            ('Novosibirsk', 'Asia/Novosibirsk'),  # UTC+07:00
+            ('Krasnoyarsk', 'Asia/Krasnoyarsk'),  # UTC+07:00
+            ('Beijing', 'Asia/Shanghai'),  # UTC+08:00
+            ('Singapore', 'Asia/Singapore'),  # UTC+08:00
+            ('Perth', 'Australia/Perth'),  # UTC+08:00
+            ('Hong Kong', 'Asia/Hong_Kong'),  # UTC+08:00
+            ('Ulaanbaatar', 'Asia/Ulaanbaatar'),  # UTC+08:00
+            ('Palau', 'Pacific/Palau'),  # UTC+08:00
+            ('Eucla', 'Australia/Eucla'),  # UTC+08:45
+            ('Tokyo', 'Asia/Tokyo'),  # UTC+09:00
+            ('Seoul', 'Asia/Seoul'),  # UTC+09:00
+            ('Yakutsk', 'Asia/Yakutsk'),  # UTC+09:00
+            ('Adelaide', 'Australia/Adelaide'),  # UTC+09:30 (DST: UTC+10:30)
+            ('Darwin', 'Australia/Darwin'),  # UTC+09:30
+            ('Sydney', 'Australia/Sydney'),  # UTC+10:00 (DST: UTC+11:00)
+            ('Brisbane', 'Australia/Brisbane'),  # UTC+10:00
+            ('Guam', 'Pacific/Guam'),  # UTC+10:00
+            ('Vladivostok', 'Asia/Vladivostok'),  # UTC+10:00
+            ('Tahiti', 'Pacific/Tahiti'),  # UTC+10:00
+            ('Lord Howe Island', 'Australia/Lord_Howe'),  # UTC+10:30 (DST: UTC+11:00)
+            ('Solomon Islands', 'Pacific/Guadalcanal'),  # UTC+11:00
+            ('Magadan', 'Asia/Magadan'),  # UTC+11:00
+            ('Norfolk Island', 'Pacific/Norfolk'),  # UTC+11:00
+            ('Bougainville Island', 'Pacific/Bougainville'),  # UTC+11:00
+            ('Chokurdakh', 'Asia/Srednekolymsk'),  # UTC+11:00
+            ('Auckland', 'Pacific/Auckland'),  # UTC+12:00 (DST: UTC+13:00)
+            ('Wellington', 'Pacific/Auckland'),  # UTC+12:00 (DST: UTC+13:00)
+            ('Fiji Islands', 'Pacific/Fiji'),  # UTC+12:00 (DST: UTC+13:00)
+            ('Anadyr', 'Asia/Anadyr'),  # UTC+12:00
+            ('Chatham Islands', 'Pacific/Chatham'),  # UTC+12:45 (DST: UTC+13:45)
+            ("Nuku'alofa", 'Pacific/Tongatapu'),  # UTC+13:00
+            ('Samoa', 'Pacific/Apia'),  # UTC+13:00 (DST: UTC+14:00)
+            ('Kiritimati Island', 'Pacific/Kiritimati')  # UTC+14:00
         ]
 
         timezone_list = []
@@ -177,6 +150,7 @@ class TimezoneEndpoint(APIView):
 
         # Process timezone mapping
         for friendly_name, tz_identifier in timezone_locations:
+
             try:
                 tz = pytz.timezone(tz_identifier)
                 current_offset = now.astimezone(tz).strftime("%z")

apiserver/plane/app/views/workspace/base.py

@@ -3,7 +3,6 @@ import csv
 import io
 import os
 from datetime import date
-import uuid
 
 from dateutil.relativedelta import relativedelta
 from django.db import IntegrityError
@@ -36,7 +35,6 @@ from plane.db.models import (
     Workspace,
     WorkspaceMember,
     WorkspaceTheme,
-    Profile,
 )
 from plane.app.permissions import ROLE, allow_permission
 from django.utils.decorators import method_decorator
@@ -45,7 +43,6 @@ from django.views.decorators.vary import vary_on_cookie
 from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
 from plane.license.utils.instance_value import get_configuration_value
 from plane.bgtasks.workspace_seed_task import workspace_seed
-from plane.utils.url import contains_url
 
 
 class WorkSpaceViewSet(BaseViewSet):
@@ -112,12 +109,6 @@ class WorkSpaceViewSet(BaseViewSet):
                     status=status.HTTP_400_BAD_REQUEST,
                 )
 
-            if contains_url(name):
-                return Response(
-                    {"error": "Name cannot contain a URL"},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-
             if serializer.is_valid(raise_exception=True):
                 serializer.save(owner=request.user)
                 # Create Workspace member
@@ -159,18 +150,8 @@ class WorkSpaceViewSet(BaseViewSet):
     def partial_update(self, request, *args, **kwargs):
         return super().partial_update(request, *args, **kwargs)
 
-    def remove_last_workspace_ids_from_user_settings(self, id: uuid.UUID) -> None:
-        """
-        Remove the last workspace id from the user settings
-        """
-        Profile.objects.filter(last_workspace_id=id).update(last_workspace_id=None)
-        return
-
     @allow_permission([ROLE.ADMIN], level="WORKSPACE")
     def destroy(self, request, *args, **kwargs):
-        # Get the workspace
-        workspace = self.get_object()
-        self.remove_last_workspace_ids_from_user_settings(workspace.id)
         return super().destroy(request, *args, **kwargs)
 
 
@@ -178,6 +159,8 @@ class UserWorkSpacesEndpoint(BaseAPIView):
     search_fields = ["name"]
     filterset_fields = ["owner"]
 
+    @method_decorator(cache_control(private=True, max_age=12))
+    @method_decorator(vary_on_cookie)
     def get(self, request):
         fields = [field for field in request.GET.get("fields", "").split(",") if field]
         member_count = (

apiserver/plane/app/views/workspace/cycle.py

@@ -12,7 +12,6 @@ from plane.app.permissions import WorkspaceViewerPermission
 from plane.app.serializers.cycle import CycleSerializer
 from plane.utils.timezone_converter import user_timezone_converter
 
-
 class WorkspaceCyclesEndpoint(BaseAPIView):
     permission_classes = [WorkspaceViewerPermission]
 

apiserver/plane/app/views/workspace/draft.py

@@ -38,7 +38,6 @@ from plane.bgtasks.issue_activities_task import issue_activity
 from plane.utils.issue_filters import issue_filters
 from plane.utils.host import base_host
 
-
 class WorkspaceDraftIssueViewSet(BaseViewSet):
     model = DraftIssue
 

apiserver/plane/app/views/workspace/member.py

@@ -1,6 +1,5 @@
 # Django imports
 from django.db.models import Count, Q, OuterRef, Subquery, IntegerField
-from django.utils import timezone
 from django.db.models.functions import Coalesce
 
 # Third party modules
@@ -134,7 +133,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         # Deactivate the users from the projects where the user is part of
         _ = ProjectMember.objects.filter(
             workspace__slug=slug, member_id=workspace_member.member_id, is_active=True
-        ).update(is_active=False, updated_at=timezone.now())
+        ).update(is_active=False)
 
         workspace_member.is_active = False
         workspace_member.save()
@@ -195,7 +194,7 @@ class WorkSpaceMemberViewSet(BaseViewSet):
         # # Deactivate the users from the projects where the user is part of
         _ = ProjectMember.objects.filter(
             workspace__slug=slug, member_id=workspace_member.member_id, is_active=True
-        ).update(is_active=False, updated_at=timezone.now())
+        ).update(is_active=False)
 
         # # Deactivate the user
         workspace_member.is_active = False

apiserver/plane/app/views/workspace/user_preference.py

@@ -27,7 +27,10 @@ class WorkspaceUserPreferenceViewSet(BaseAPIView):
 
         create_preference_keys = []
 
-        keys = [key for key, _ in WorkspaceUserPreference.UserPreferenceKeys.choices]
+        keys = [
+            key
+            for key, _ in WorkspaceUserPreference.UserPreferenceKeys.choices
+        ]
 
         for preference in keys:
             if preference not in get_preference.values_list("key", flat=True):
@@ -36,10 +39,7 @@ class WorkspaceUserPreferenceViewSet(BaseAPIView):
                 preference = WorkspaceUserPreference.objects.bulk_create(
                     [
                         WorkspaceUserPreference(
-                            key=key,
-                            user=request.user,
-                            workspace=workspace,
-                            sort_order=(65535 + (i * 10000)),
+                            key=key, user=request.user, workspace=workspace, sort_order=(65535 + (i*10000))
                         )
                         for i, key in enumerate(create_preference_keys)
                     ],
@@ -47,13 +47,10 @@ class WorkspaceUserPreferenceViewSet(BaseAPIView):
                     ignore_conflicts=True,
                 )
 
-        preferences = (
-            WorkspaceUserPreference.objects.filter(
-                user=request.user, workspace_id=workspace.id
-            )
-            .order_by("sort_order")
-            .values("key", "is_pinned", "sort_order")
-        )
+        preferences = WorkspaceUserPreference.objects.filter(
+            user=request.user, workspace_id=workspace.id
+        ).order_by("sort_order").values("key", "is_pinned", "sort_order")
+
 
         user_preferences = {}
 
@@ -61,7 +58,7 @@ class WorkspaceUserPreferenceViewSet(BaseAPIView):
             user_preferences[(str(preference["key"]))] = {
                 "is_pinned": preference["is_pinned"],
                 "sort_order": preference["sort_order"],
-            }
+        }
         return Response(
             user_preferences,
             status=status.HTTP_200_OK,

apiserver/plane/authentication/adapter/base.py

@@ -18,7 +18,6 @@ from plane.bgtasks.user_activation_email_task import user_activation_email
 from plane.utils.host import base_host
 from plane.utils.ip_address import get_client_ip
 
-
 class Adapter:
     """Common interface for all auth providers"""
 

apiserver/plane/authentication/adapter/error.py

@@ -41,6 +41,7 @@ AUTHENTICATION_ERROR_CODES = {
     "GOOGLE_OAUTH_PROVIDER_ERROR": 5115,
     "GITHUB_OAUTH_PROVIDER_ERROR": 5120,
     "GITLAB_OAUTH_PROVIDER_ERROR": 5121,
+
     # Reset Password
     "INVALID_PASSWORD_TOKEN": 5125,
     "EXPIRED_PASSWORD_TOKEN": 5130,

apiserver/plane/authentication/provider/oauth/github.py

@@ -25,24 +25,23 @@ class GitHubOAuthProvider(OauthAdapter):
 
     organization_scope = "read:org"
 
+
     def __init__(self, request, code=None, state=None, callback=None):
-        GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET, GITHUB_ORGANIZATION_ID = (
-            get_configuration_value(
-                [
-                    {
-                        "key": "GITHUB_CLIENT_ID",
-                        "default": os.environ.get("GITHUB_CLIENT_ID"),
-                    },
-                    {
-                        "key": "GITHUB_CLIENT_SECRET",
-                        "default": os.environ.get("GITHUB_CLIENT_SECRET"),
-                    },
-                    {
-                        "key": "GITHUB_ORGANIZATION_ID",
-                        "default": os.environ.get("GITHUB_ORGANIZATION_ID"),
-                    },
-                ]
-            )
+        GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET, GITHUB_ORGANIZATION_ID = get_configuration_value(
+            [
+                {
+                    "key": "GITHUB_CLIENT_ID",
+                    "default": os.environ.get("GITHUB_CLIENT_ID"),
+                },
+                {
+                    "key": "GITHUB_CLIENT_SECRET",
+                    "default": os.environ.get("GITHUB_CLIENT_SECRET"),
+                },
+                {
+                    "key": "GITHUB_ORGANIZATION_ID",
+                    "default": os.environ.get("GITHUB_ORGANIZATION_ID"),
+                },
+            ]
         )
 
         if not (GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET):
@@ -129,10 +128,7 @@ class GitHubOAuthProvider(OauthAdapter):
 
     def is_user_in_organization(self, github_username):
         headers = {"Authorization": f"Bearer {self.token_data.get('access_token')}"}
-        response = requests.get(
-            f"{self.org_membership_url}/{self.organization_id}/memberships/{github_username}",
-            headers=headers,
-        )
+        response = requests.get(f"{self.org_membership_url}/{self.organization_id}/memberships/{github_username}", headers=headers)
         return response.status_code == 200  # 200 means the user is a member
 
     def set_user_data(self):
@@ -149,6 +145,7 @@ class GitHubOAuthProvider(OauthAdapter):
                     error_message="GITHUB_USER_NOT_IN_ORG",
                 )
 
+
         email = self.__get_email(headers=headers)
         super().set_user_data(
             {

apiserver/plane/authentication/urls.py

@@ -42,11 +42,11 @@ urlpatterns = [
     # credentials
     path("sign-in/", SignInAuthEndpoint.as_view(), name="sign-in"),
     path("sign-up/", SignUpAuthEndpoint.as_view(), name="sign-up"),
-    path("spaces/sign-in/", SignInAuthSpaceEndpoint.as_view(), name="space-sign-in"),
-    path("spaces/sign-up/", SignUpAuthSpaceEndpoint.as_view(), name="space-sign-up"),
+    path("spaces/sign-in/", SignInAuthSpaceEndpoint.as_view(), name="sign-in"),
+    path("spaces/sign-up/", SignUpAuthSpaceEndpoint.as_view(), name="sign-in"),
     # signout
     path("sign-out/", SignOutAuthEndpoint.as_view(), name="sign-out"),
-    path("spaces/sign-out/", SignOutAuthSpaceEndpoint.as_view(), name="space-sign-out"),
+    path("spaces/sign-out/", SignOutAuthSpaceEndpoint.as_view(), name="sign-out"),
     # csrf token
     path("get-csrf-token/", CSRFTokenEndpoint.as_view(), name="get_csrf_token"),
     # Magic sign in
@@ -56,17 +56,17 @@ urlpatterns = [
     path(
         "spaces/magic-generate/",
         MagicGenerateSpaceEndpoint.as_view(),
-        name="space-magic-generate",
+        name="magic-generate",
     ),
     path(
         "spaces/magic-sign-in/",
         MagicSignInSpaceEndpoint.as_view(),
-        name="space-magic-sign-in",
+        name="magic-sign-in",
     ),
     path(
         "spaces/magic-sign-up/",
         MagicSignUpSpaceEndpoint.as_view(),
-        name="space-magic-sign-up",
+        name="magic-sign-up",
     ),
     ## Google Oauth
     path("google/", GoogleOauthInitiateEndpoint.as_view(), name="google-initiate"),
@@ -74,12 +74,12 @@ urlpatterns = [
     path(
         "spaces/google/",
         GoogleOauthInitiateSpaceEndpoint.as_view(),
-        name="space-google-initiate",
+        name="google-initiate",
     ),
     path(
-        "spaces/google/callback/",
+        "google/callback/",
         GoogleCallbackSpaceEndpoint.as_view(),
-        name="space-google-callback",
+        name="google-callback",
     ),
     ## Github Oauth
     path("github/", GitHubOauthInitiateEndpoint.as_view(), name="github-initiate"),
@@ -87,12 +87,12 @@ urlpatterns = [
     path(
         "spaces/github/",
         GitHubOauthInitiateSpaceEndpoint.as_view(),
-        name="space-github-initiate",
+        name="github-initiate",
     ),
     path(
         "spaces/github/callback/",
         GitHubCallbackSpaceEndpoint.as_view(),
-        name="space-github-callback",
+        name="github-callback",
     ),
     ## Gitlab Oauth
     path("gitlab/", GitLabOauthInitiateEndpoint.as_view(), name="gitlab-initiate"),
@@ -100,12 +100,12 @@ urlpatterns = [
     path(
         "spaces/gitlab/",
         GitLabOauthInitiateSpaceEndpoint.as_view(),
-        name="space-gitlab-initiate",
+        name="gitlab-initiate",
     ),
     path(
         "spaces/gitlab/callback/",
         GitLabCallbackSpaceEndpoint.as_view(),
-        name="space-gitlab-callback",
+        name="gitlab-callback",
     ),
     # Email Check
     path("email-check/", EmailCheckEndpoint.as_view(), name="email-check"),
@@ -120,12 +120,12 @@ urlpatterns = [
     path(
         "spaces/forgot-password/",
         ForgotPasswordSpaceEndpoint.as_view(),
-        name="space-forgot-password",
+        name="forgot-password",
     ),
     path(
         "spaces/reset-password/<uidb64>/<token>/",
         ResetPasswordSpaceEndpoint.as_view(),
-        name="space-forgot-password",
+        name="forgot-password",
     ),
     path("change-password/", ChangePasswordEndpoint.as_view(), name="forgot-password"),
     path("set-password/", SetUserPasswordEndpoint.as_view(), name="set-password"),

apiserver/plane/authentication/utils/login.py

@@ -6,7 +6,6 @@ from django.conf import settings
 from plane.utils.host import base_host
 from plane.utils.ip_address import get_client_ip
 
-
 def user_login(request, user, is_app=False, is_admin=False, is_space=False):
     login(request=request, user=user)
 

apiserver/plane/authentication/views/app/email.py

@@ -21,7 +21,6 @@ from plane.authentication.adapter.error import (
 )
 from plane.utils.path_validator import validate_next_path
 
-
 class SignInAuthEndpoint(View):
     def post(self, request):
         next_path = request.POST.get("next_path")

apiserver/plane/authentication/views/app/github.py

@@ -18,7 +18,6 @@ from plane.authentication.adapter.error import (
 )
 from plane.utils.path_validator import validate_next_path
 
-
 class GitHubOauthInitiateEndpoint(View):
     def get(self, request):
         # Get host and next path

apiserver/plane/authentication/views/app/gitlab.py

@@ -18,7 +18,6 @@ from plane.authentication.adapter.error import (
 )
 from plane.utils.path_validator import validate_next_path
 
-
 class GitLabOauthInitiateEndpoint(View):
     def get(self, request):
         # Get host and next path

apiserver/plane/authentication/views/app/google.py

@@ -20,7 +20,6 @@ from plane.authentication.adapter.error import (
 )
 from plane.utils.path_validator import validate_next_path
 
-
 class GoogleOauthInitiateEndpoint(View):
     def get(self, request):
         request.session["host"] = base_host(request=request, is_app=True)
@@ -96,9 +95,7 @@ class GoogleCallbackEndpoint(View):
             # Get the redirection path
             path = get_redirection_path(user=user)
             # redirect to referer path
-            url = urljoin(
-                base_host, str(validate_next_path(next_path)) if next_path else path
-            )
+            url = urljoin(base_host, str(validate_next_path(next_path)) if next_path else path)
             return HttpResponseRedirect(url)
         except AuthenticationException as e:
             params = e.get_error_dict()

apiserver/plane/authentication/views/common.py

@@ -53,14 +53,12 @@ class ChangePasswordEndpoint(APIView):
                     error_message="MISSING_PASSWORD",
                     payload={"error": "Old password is missing"},
                 )
-                return Response(
-                    exc.get_error_dict(), status=status.HTTP_400_BAD_REQUEST
-                )
+                return Response(exc.get_error_dict(), status=status.HTTP_400_BAD_REQUEST)
 
         # Get the new password
         new_password = request.data.get("new_password", False)
 
-        if not new_password:
+        if  not new_password:
             exc = AuthenticationException(
                 error_code=AUTHENTICATION_ERROR_CODES["MISSING_PASSWORD"],
                 error_message="MISSING_PASSWORD",
@@ -68,6 +66,7 @@ class ChangePasswordEndpoint(APIView):
             )
             return Response(exc.get_error_dict(), status=status.HTTP_400_BAD_REQUEST)
 
+
         # If the user password is not autoset then we need to check the old passwords
         if not user.is_password_autoset and not user.check_password(old_password):
             exc = AuthenticationException(

apiserver/plane/authentication/views/space/magic.py

@@ -25,7 +25,6 @@ from plane.authentication.adapter.error import (
 )
 from plane.utils.path_validator import validate_next_path
 
-
 class MagicGenerateSpaceEndpoint(APIView):
     permission_classes = [AllowAny]
 
@@ -39,6 +38,7 @@ class MagicGenerateSpaceEndpoint(APIView):
             )
             return Response(exc.get_error_dict(), status=status.HTTP_400_BAD_REQUEST)
 
+
         email = request.data.get("email", "").strip().lower()
         try:
             validate_email(email)

apiserver/plane/bgtasks/email_notification_task.py

@@ -284,7 +284,6 @@ def send_email_notification(
                 "project": str(issue.project.name),
                 "user_preference": f"{base_api}/profile/preferences/email",
                 "comments": comments,
-                "entity_type": "issue",
             }
             html_content = render_to_string(
                 "emails/notifications/issue-updates.html", context

apiserver/plane/bgtasks/export_task.py

@@ -3,11 +3,9 @@ import csv
 import io
 import json
 import zipfile
-from typing import List
+
 import boto3
 from botocore.client import Config
-from uuid import UUID
-from datetime import datetime, date
 
 # Third party imports
 from celery import shared_task
@@ -22,30 +20,21 @@ from django.db.models import F, Prefetch
 from collections import defaultdict
 
 # Module imports
-from plane.db.models import ExporterHistory, Issue, FileAsset, Label, User, IssueComment
+from plane.db.models import ExporterHistory, Issue, FileAsset, Label, User
 from plane.utils.exception_logger import log_exception
 
 
-def dateTimeConverter(time: datetime) -> str | None:
-    """
-    Convert a datetime object to a formatted string.
-    """
+def dateTimeConverter(time):
     if time:
         return time.strftime("%a, %d %b %Y %I:%M:%S %Z%z")
 
 
-def dateConverter(time: date) -> str | None:
-    """
-    Convert a date object to a formatted string.
-    """
+def dateConverter(time):
     if time:
         return time.strftime("%a, %d %b %Y")
 
 
-def create_csv_file(data: List[List[str]]) -> str:
-    """
-    Create a CSV file from the provided data.
-    """
+def create_csv_file(data):
     csv_buffer = io.StringIO()
     csv_writer = csv.writer(csv_buffer, delimiter=",", quoting=csv.QUOTE_ALL)
 
@@ -56,17 +45,11 @@ def create_csv_file(data: List[List[str]]) -> str:
     return csv_buffer.getvalue()
 
 
-def create_json_file(data: List[dict]) -> str:
-    """
-    Create a JSON file from the provided data.
-    """
+def create_json_file(data):
     return json.dumps(data)
 
 
-def create_xlsx_file(data: List[List[str]]) -> bytes:
-    """
-    Create an XLSX file from the provided data.
-    """
+def create_xlsx_file(data):
     workbook = Workbook()
     sheet = workbook.active
 
@@ -79,10 +62,7 @@ def create_xlsx_file(data: List[List[str]]) -> bytes:
     return xlsx_buffer.getvalue()
 
 
-def create_zip_file(files: List[tuple[str, str | bytes]]) -> io.BytesIO:
-    """
-    Create a ZIP file from the provided files.
-    """
+def create_zip_file(files):
     zip_buffer = io.BytesIO()
     with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zipf:
         for filename, file_content in files:
@@ -92,13 +72,7 @@ def create_zip_file(files: List[tuple[str, str | bytes]]) -> io.BytesIO:
     return zip_buffer
 
 
-# TODO: Change the upload_to_s3 function to use the new storage method with entry in file asset table
-def upload_to_s3(
-    zip_file: io.BytesIO, workspace_id: UUID, token_id: str, slug: str
-) -> None:
-    """
-    Upload a ZIP file to S3 and generate a presigned URL.
-    """
+def upload_to_s3(zip_file, workspace_id, token_id, slug):
     file_name = (
         f"{workspace_id}/export-{slug}-{token_id[:6]}-{str(timezone.now().date())}.zip"
     )
@@ -180,10 +154,7 @@ def upload_to_s3(
     exporter_instance.save(update_fields=["status", "url", "key"])
 
 
-def generate_table_row(issue: dict) -> List[str]:
-    """
-    Generate a table row from an issue dictionary.
-    """
+def generate_table_row(issue):
     return [
         f"""{issue["project_identifier"]}-{issue["sequence_id"]}""",
         issue["project_name"],
@@ -195,24 +166,22 @@ def generate_table_row(issue: dict) -> List[str]:
         issue["priority"],
         issue["created_by"],
         ", ".join(issue["labels"]) if issue["labels"] else "",
-        issue["cycle_name"],
-        issue["cycle_start_date"],
-        issue["cycle_end_date"],
+        issue.get("cycle_name", ""),
+        issue.get("cycle_start_date", ""),
+        issue.get("cycle_end_date", ""),
         ", ".join(issue.get("module_name", "")) if issue.get("module_name") else "",
         dateTimeConverter(issue["created_at"]),
         dateTimeConverter(issue["updated_at"]),
         dateTimeConverter(issue["completed_at"]),
         dateTimeConverter(issue["archived_at"]),
-        (
-            ", ".join(
-                [
-                    f"{comment['comment']} ({comment['created_at']} by {comment['created_by']})"
-                    for comment in issue["comments"]
-                ]
-            )
-            if issue["comments"]
-            else ""
-        ),
+        ", ".join(
+            [
+                f"{comment['comment']} ({comment['created_at']} by {comment['created_by']})"
+                for comment in issue["comments"]
+            ]
+        )
+        if issue["comments"]
+        else "",
         issue["estimate"] if issue["estimate"] else "",
         ", ".join(issue["link"]) if issue["link"] else "",
         ", ".join(issue["assignees"]) if issue["assignees"] else "",
@@ -222,10 +191,7 @@ def generate_table_row(issue: dict) -> List[str]:
     ]
 
 
-def generate_json_row(issue: dict) -> dict:
-    """
-    Generate a JSON row from an issue dictionary.
-    """
+def generate_json_row(issue):
     return {
         "ID": f"""{issue["project_identifier"]}-{issue["sequence_id"]}""",
         "Project": issue["project_name"],
@@ -255,10 +221,7 @@ def generate_json_row(issue: dict) -> dict:
     }
 
 
-def update_json_row(rows: List[dict], row: dict) -> None:
-    """
-    Update the json row with the new assignee and label.
-    """
+def update_json_row(rows, row):
     matched_index = next(
         (
             index
@@ -287,10 +250,7 @@ def update_json_row(rows: List[dict], row: dict) -> None:
         rows.append(row)
 
 
-def update_table_row(rows: List[List[str]], row: List[str]) -> None:
-    """
-    Update the table row with the new assignee and label.
-    """
+def update_table_row(rows, row):
     matched_index = next(
         (index for index, existing_row in enumerate(rows) if existing_row[0] == row[0]),
         None,
@@ -312,32 +272,20 @@ def update_table_row(rows: List[List[str]], row: List[str]) -> None:
         rows.append(row)
 
 
-def generate_csv(
-    header: List[str],
-    project_id: str,
-    issues: List[dict],
-    files: List[tuple[str, str | bytes]],
-) -> None:
+def generate_csv(header, project_id, issues, files):
     """
     Generate CSV export for all the passed issues.
     """
     rows = [header]
     for issue in issues:
         row = generate_table_row(issue)
+
         update_table_row(rows, row)
     csv_file = create_csv_file(rows)
     files.append((f"{project_id}.csv", csv_file))
 
 
-def generate_json(
-    header: List[str],
-    project_id: str,
-    issues: List[dict],
-    files: List[tuple[str, str | bytes]],
-) -> None:
-    """
-    Generate JSON export for all the passed issues.
-    """
+def generate_json(header, project_id, issues, files):
     rows = []
     for issue in issues:
         row = generate_json_row(issue)
@@ -346,15 +294,7 @@ def generate_json(
     files.append((f"{project_id}.json", json_file))
 
 
-def generate_xlsx(
-    header: List[str],
-    project_id: str,
-    issues: List[dict],
-    files: List[tuple[str, str | bytes]],
-) -> None:
-    """
-    Generate XLSX export for all the passed issues.
-    """
+def generate_xlsx(header, project_id, issues, files):
     rows = [header]
     for issue in issues:
         row = generate_table_row(issue)
@@ -364,36 +304,13 @@ def generate_xlsx(
     files.append((f"{project_id}.xlsx", xlsx_file))
 
 
-def get_created_by(obj: Issue | IssueComment) -> str:
-    """
-    Get the created by user for the given object.
-    """
-    if obj.created_by:
-        return f"{obj.created_by.first_name} {obj.created_by.last_name}"
-    return ""
-
-
 @shared_task
-def issue_export_task(
-    provider: str,
-    workspace_id: UUID,
-    project_ids: List[str],
-    token_id: str,
-    multiple: bool,
-    slug: str,
-):
-    """
-    Export issues from the workspace.
-    provider (str): The provider to export the issues to csv | json | xlsx.
-    token_id (str): The export object token id.
-    multiple (bool): Whether to export the issues to multiple files per project.
-    """
+def issue_export_task(provider, workspace_id, project_ids, token_id, multiple, slug):
     try:
         exporter_instance = ExporterHistory.objects.get(token=token_id)
         exporter_instance.status = "processing"
         exporter_instance.save(update_fields=["status"])
 
-        # Base query to get the issues
         workspace_issues = (
             Issue.objects.filter(
                 workspace__id=workspace_id,
@@ -431,21 +348,16 @@ def issue_export_task(
             )
         )
 
-        # Get the attachments for the issues
         file_assets = FileAsset.objects.filter(
-            issue_id__in=workspace_issues.values_list("id", flat=True),
-            entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            issue_id__in=workspace_issues.values_list("id", flat=True)
         ).annotate(work_item_id=F("issue_id"), asset_id=F("id"))
 
-        # Create a dictionary to store the attachments for the issues
         attachment_dict = defaultdict(list)
         for asset in file_assets:
             attachment_dict[asset.work_item_id].append(asset.asset_id)
 
-        # Create a list to store the issues data
         issues_data = []
 
-        # Iterate over the issues
         for issue in workspace_issues:
             attachments = attachment_dict.get(issue.id, [])
 
@@ -468,18 +380,18 @@ def issue_export_task(
                 "module_name": [
                     module.module.name for module in issue.issue_module.all()
                 ],
-                "created_by": get_created_by(issue),
+                "created_by": f"{issue.created_by.first_name} {issue.created_by.last_name}",
                 "labels": [label.name for label in issue.label_details],
                 "comments": [
                     {
                         "comment": comment.comment_stripped,
                         "created_at": dateConverter(comment.created_at),
-                        "created_by": get_created_by(comment),
+                        "created_by": f"{comment.created_by.first_name} {comment.created_by.last_name}",
                     }
                     for comment in issue.issue_comments.all()
                 ],
-                "estimate": issue.estimate_point.value
-                if issue.estimate_point and issue.estimate_point.value
+                "estimate": issue.estimate_point.estimate.name
+                if issue.estimate_point
                 else "",
                 "link": [link.url for link in issue.issue_link.all()],
                 "assignees": [
@@ -494,17 +406,14 @@ def issue_export_task(
                 ],
             }
 
-            # Get Cycles data for the issue
-            cycle = issue.issue_cycle.last()
-            if cycle:
-                # Update cycle data
+            # Get prefetched cycles and modules
+            cycles = list(issue.issue_cycle.all())
+
+            # Update cycle data
+            for cycle in cycles:
                 issue_data["cycle_name"] = cycle.cycle.name
                 issue_data["cycle_start_date"] = dateConverter(cycle.cycle.start_date)
                 issue_data["cycle_end_date"] = dateConverter(cycle.cycle.end_date)
-            else:
-                issue_data["cycle_name"] = ""
-                issue_data["cycle_start_date"] = ""
-                issue_data["cycle_end_date"] = ""
 
             issues_data.append(issue_data)
 
@@ -537,7 +446,6 @@ def issue_export_task(
             "Attachment Links",
         ]
 
-        # Map the provider to the function
         EXPORTER_MAPPER = {
             "csv": generate_csv,
             "json": generate_json,

apiserver/plane/bgtasks/work_item_link_task.py

@@ -1,177 +0,0 @@
-# Python imports
-import logging
-
-
-# Third party imports
-from celery import shared_task
-import requests
-from bs4 import BeautifulSoup
-from urllib.parse import urlparse, urljoin
-import base64
-import ipaddress
-from typing import Dict, Any
-from typing import Optional
-from plane.db.models import IssueLink
-from plane.utils.exception_logger import log_exception
-
-logger = logging.getLogger("plane.worker")
-
-
-DEFAULT_FAVICON = "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLXdpZHRoPSIyIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIGNsYXNzPSJsdWNpZGUgbHVjaWRlLWxpbmstaWNvbiBsdWNpZGUtbGluayI+PHBhdGggZD0iTTEwIDEzYTUgNSAwIDAgMCA3LjU0LjU0bDMtM2E1IDUgMCAwIDAtNy4wNy03LjA3bC0xLjcyIDEuNzEiLz48cGF0aCBkPSJNMTQgMTFhNSA1IDAgMCAwLTcuNTQtLjU0bC0zIDNhNSA1IDAgMCAwIDcuMDcgNy4wN2wxLjcxLTEuNzEiLz48L3N2Zz4="  # noqa: E501
-
-def crawl_work_item_link_title_and_favicon(url: str) -> Dict[str, Any]:
-    """
-    Crawls a URL to extract the title and favicon.
-
-    Args:
-        url (str): The URL to crawl
-
-    Returns:
-        str: JSON string containing title and base64-encoded favicon
-    """
-    try:
-        # Prevent access to private IP ranges
-        parsed = urlparse(url)
-
-        try:
-            ip = ipaddress.ip_address(parsed.hostname)
-            if ip.is_private or ip.is_loopback or ip.is_reserved:
-                raise ValueError("Access to private/internal networks is not allowed")
-        except ValueError:
-            # Not an IP address, continue with domain validation
-            pass
-
-        # Set up headers to mimic a real browser
-        headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"  # noqa: E501
-        }
-
-        soup = None
-        title = None
-
-        try:
-            response = requests.get(url, headers=headers, timeout=1)
-
-            soup = BeautifulSoup(response.content, "html.parser")
-            title_tag = soup.find("title")
-            title = title_tag.get_text().strip() if title_tag else None
-
-        except requests.RequestException as e:
-            logger.warning(f"Failed to fetch HTML for title: {str(e)}")
-
-        # Fetch and encode favicon
-        favicon_base64 = fetch_and_encode_favicon(headers, soup, url)
-
-        # Prepare result
-        result = {
-            "title": title,
-            "favicon": favicon_base64["favicon_base64"],
-            "url": url,
-            "favicon_url": favicon_base64["favicon_url"],
-        }
-
-        return result
-
-    except Exception as e:
-        log_exception(e)
-        return {
-            "error": f"Unexpected error: {str(e)}",
-            "title": None,
-            "favicon": None,
-            "url": url,
-        }
-
-
-def find_favicon_url(soup: Optional[BeautifulSoup], base_url: str) -> Optional[str]:
-    """
-    Find the favicon URL from HTML soup.
-
-    Args:
-        soup: BeautifulSoup object
-        base_url: Base URL for resolving relative paths
-
-    Returns:
-        str: Absolute URL to favicon or None
-    """
-
-    if soup is not None:
-        # Look for various favicon link tags
-        favicon_selectors = [
-            'link[rel="icon"]',
-            'link[rel="shortcut icon"]',
-            'link[rel="apple-touch-icon"]',
-            'link[rel="apple-touch-icon-precomposed"]',
-        ]
-
-        for selector in favicon_selectors:
-            favicon_tag = soup.select_one(selector)
-            if favicon_tag and favicon_tag.get("href"):
-                return urljoin(base_url, favicon_tag["href"])
-
-    # Fallback to /favicon.ico
-    parsed_url = urlparse(base_url)
-    fallback_url = f"{parsed_url.scheme}://{parsed_url.netloc}/favicon.ico"
-
-    # Check if fallback exists
-    try:
-        response = requests.head(fallback_url, timeout=2)
-        if response.status_code == 200:
-            return fallback_url
-    except requests.RequestException as e:
-        log_exception(e)
-        return None
-
-    return None
-
-
-def fetch_and_encode_favicon(
-    headers: Dict[str, str], soup: Optional[BeautifulSoup], url: str
-) -> Dict[str, Optional[str]]:
-    """
-    Fetch favicon and encode it as base64.
-
-    Args:
-        favicon_url: URL to the favicon
-        headers: Request headers
-
-    Returns:
-        str: Base64 encoded favicon with data URI prefix or None
-    """
-    try:
-        favicon_url = find_favicon_url(soup, url)
-        if favicon_url is None:
-            return {
-                "favicon_url": None,
-                "favicon_base64": f"data:image/svg+xml;base64,{DEFAULT_FAVICON}",
-            }
-
-        response = requests.get(favicon_url, headers=headers, timeout=1)
-
-        # Get content type
-        content_type = response.headers.get("content-type", "image/x-icon")
-
-        # Convert to base64
-        favicon_base64 = base64.b64encode(response.content).decode("utf-8")
-
-        # Return as data URI
-        return {
-            "favicon_url": favicon_url,
-            "favicon_base64": f"data:{content_type};base64,{favicon_base64}",
-        }
-
-    except Exception as e:
-        logger.warning(f"Failed to fetch favicon: {e}")
-        return {
-            "favicon_url": None,
-            "favicon_base64": f"data:image/svg+xml;base64,{DEFAULT_FAVICON}",
-        }
-
-
-@shared_task
-def crawl_work_item_link_title(id: str, url: str) -> None:
-    meta_data = crawl_work_item_link_title_and_favicon(url)
-    issue_link = IssueLink.objects.get(id=id)
-
-    issue_link.metadata = meta_data
-
-    issue_link.save()

apiserver/plane/db/management/commands/update_deleted_workspace_slug.py

@@ -5,9 +5,7 @@ from plane.db.models import Workspace
 
 
 class Command(BaseCommand):
-    help = (
-        "Updates the slug of a soft-deleted workspace by appending the epoch timestamp"
-    )
+    help = "Updates the slug of a soft-deleted workspace by appending the epoch timestamp"
 
     def add_arguments(self, parser):
         parser.add_argument(
@@ -77,4 +75,4 @@ class Command(BaseCommand):
                     self.style.ERROR(
                         f"Error updating workspace '{workspace.name}': {str(e)}"
                     )
-                )
+                )

apiserver/plane/db/migrations/0096_user_is_email_valid_user_masked_at.py

@@ -1,23 +0,0 @@
-# Generated by Django 4.2.20 on 2025-05-21 13:43
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("db", "0095_page_external_id_page_external_source"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="user",
-            name="is_email_valid",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="user",
-            name="masked_at",
-            field=models.DateTimeField(null=True),
-        ),
-    ]

apiserver/plane/db/migrations/0097_project_external_id_project_external_source.py

@@ -1,23 +0,0 @@
-# Generated by Django 4.2.21 on 2025-06-06 12:33
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('db', '0096_user_is_email_valid_user_masked_at'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='project',
-            name='external_id',
-            field=models.CharField(blank=True, max_length=255, null=True),
-        ),
-        migrations.AddField(
-            model_name='project',
-            name='external_source',
-            field=models.CharField(blank=True, max_length=255, null=True),
-        ),
-    ]

apiserver/plane/db/models/__init__.py

@@ -82,4 +82,4 @@ from .label import Label
 
 from .device import Device, DeviceSession
 
-from .sticky import Sticky
+from .sticky import Sticky

apiserver/plane/db/models/project.py

@@ -122,9 +122,6 @@ class Project(BaseModel):
     # timezone
     TIMEZONE_CHOICES = tuple(zip(pytz.all_timezones, pytz.all_timezones))
     timezone = models.CharField(max_length=255, default="UTC", choices=TIMEZONE_CHOICES)
-    # external_id for imports
-    external_source = models.CharField(max_length=255, null=True, blank=True)
-    external_id = models.CharField(max_length=255, blank=True, null=True)
 
     @property
     def cover_image_url(self):

apiserver/plane/db/models/user.py

@@ -106,12 +106,6 @@ class User(AbstractBaseUser, PermissionsMixin):
         max_length=255, default="UTC", choices=USER_TIMEZONE_CHOICES
     )
 
-    # email validation
-    is_email_valid = models.BooleanField(default=False)
-
-    # masking
-    masked_at = models.DateTimeField(null=True)
-
     USERNAME_FIELD = "email"
     REQUIRED_FIELDS = ["username"]
 

apiserver/plane/db/models/workspace.py

@@ -153,8 +153,12 @@ class Workspace(BaseModel):
         return None
 
     def delete(
-        self, using: Optional[str] = None, soft: bool = True, *args: Any, **kwargs: Any
-    ):
+            self,
+            using: Optional[str] = None,
+            soft: bool = True,
+            *args: Any,
+            **kwargs: Any
+        ):
         """
         Override the delete method to append epoch timestamp to the slug when soft deleting.
 
@@ -168,7 +172,7 @@ class Workspace(BaseModel):
         result = super().delete(using=using, soft=soft, *args, **kwargs)
 
         # If it's a soft delete and the model still exists (not hard deleted)
-        if soft and hasattr(self, "deleted_at") and self.deleted_at:
+        if soft and hasattr(self, 'deleted_at') and self.deleted_at:
             # Use the deleted_at timestamp to update the slug
             deletion_timestamp: int = int(self.deleted_at.timestamp())
             self.slug = f"{self.slug}__{deletion_timestamp}"

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

@@ -57,7 +57,7 @@ class InstanceEndpoint(BaseAPIView):
             POSTHOG_API_KEY,
             POSTHOG_HOST,
             UNSPLASH_ACCESS_KEY,
-            LLM_API_KEY,
+            OPENAI_API_KEY,
             IS_INTERCOM_ENABLED,
             INTERCOM_APP_ID,
         ) = get_configuration_value(
@@ -112,8 +112,8 @@ class InstanceEndpoint(BaseAPIView):
                     "default": os.environ.get("UNSPLASH_ACCESS_KEY", ""),
                 },
                 {
-                    "key": "LLM_API_KEY",
-                    "default": os.environ.get("LLM_API_KEY", ""),
+                    "key": "OPENAI_API_KEY",
+                    "default": os.environ.get("OPENAI_API_KEY", ""),
                 },
                 # Intercom settings
                 {
@@ -151,7 +151,7 @@ class InstanceEndpoint(BaseAPIView):
         data["has_unsplash_configured"] = bool(UNSPLASH_ACCESS_KEY)
 
         # Open AI settings
-        data["has_llm_configured"] = bool(LLM_API_KEY)
+        data["has_openai_configured"] = bool(OPENAI_API_KEY)
 
         # File size settings
         data["file_size_limit"] = float(os.environ.get("FILE_SIZE_LIMIT", 5242880))

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

@@ -157,7 +157,7 @@ class Command(BaseCommand):
             },
             # Deprecated, use LLM_MODEL
             {
-                "key": "GPT_ENGINE",
+                "key": "GPT_ENGINE",  
                 "value": os.environ.get("GPT_ENGINE", "gpt-3.5-turbo"),
                 "category": "SMTP",
                 "is_encrypted": False,

apiserver/plane/middleware/logger.py

@@ -83,32 +83,6 @@ class APITokenLogMiddleware:
         self.process_request(request, response, request_body)
         return response
 
-    def _safe_decode_body(self, content):
-        """
-        Safely decodes request/response body content, handling binary data.
-        Returns None if content is None, or a string representation of the content.
-        """
-        # If the content is None, return None
-        if content is None:
-            return None
-
-        # If the content is an empty bytes object, return None
-        if content == b"":
-            return None
-
-        # Check if content is binary by looking for common binary file signatures
-        if (
-            content.startswith(b"\x89PNG")
-            or content.startswith(b"\xff\xd8\xff")
-            or content.startswith(b"%PDF")
-        ):
-            return "[Binary Content]"
-
-        try:
-            return content.decode("utf-8")
-        except UnicodeDecodeError:
-            return "[Could not decode content]"
-
     def process_request(self, request, response, request_body):
         api_key_header = "X-Api-Key"
         api_key = request.headers.get(api_key_header)
@@ -121,13 +95,9 @@ class APITokenLogMiddleware:
                     method=request.method,
                     query_params=request.META.get("QUERY_STRING", ""),
                     headers=str(request.headers),
-                    body=(
-                        self._safe_decode_body(request_body) if request_body else None
-                    ),
+                    body=(request_body.decode("utf-8") if request_body else None),
                     response_body=(
-                        self._safe_decode_body(response.content)
-                        if response.content
-                        else None
+                        response.content.decode("utf-8") if response.content else None
                     ),
                     response_code=response.status_code,
                     ip_address=get_client_ip(request=request),

apiserver/plane/settings/storage.py

@@ -32,6 +32,7 @@ class S3Storage(S3Boto3Storage):
         ) or os.environ.get("MINIO_ENDPOINT_URL")
 
         if os.environ.get("USE_MINIO") == "1":
+
             # Determine protocol based on environment variable
             if os.environ.get("MINIO_ENDPOINT_SSL") == "1":
                 endpoint_protocol = "https"

apiserver/plane/space/utils/grouper.py

@@ -135,7 +135,7 @@ def issue_on_results(
                 default=None,
                 output_field=JSONField(),
             ),
-            filter=Q(votes__isnull=False, votes__deleted_at__isnull=True),
+            filter=Q(votes__isnull=False,votes__deleted_at__isnull=True),
             distinct=True,
         ),
         reaction_items=ArrayAgg(
@@ -169,9 +169,7 @@ def issue_on_results(
                 default=None,
                 output_field=JSONField(),
             ),
-            filter=Q(
-                issue_reactions__isnull=False, issue_reactions__deleted_at__isnull=True
-            ),
+            filter=Q(issue_reactions__isnull=False, issue_reactions__deleted_at__isnull=True),
             distinct=True,
         ),
     ).values(*required_fields, "vote_items", "reaction_items")

apiserver/plane/space/views/issue.py

@@ -179,7 +179,7 @@ class ProjectIssuesPublicEndpoint(BaseAPIView):
                             Q(issue_intake__status=1)
                             | Q(issue_intake__status=-1)
                             | Q(issue_intake__status=2)
-                            | Q(issue_intake__isnull=True),
+                            | Q(issue_intake__status=True),
                             archived_at__isnull=True,
                             is_draft=False,
                         ),
@@ -205,7 +205,7 @@ class ProjectIssuesPublicEndpoint(BaseAPIView):
                         Q(issue_intake__status=1)
                         | Q(issue_intake__status=-1)
                         | Q(issue_intake__status=2)
-                        | Q(issue_intake__isnull=True),
+                        | Q(issue_intake__status=True),
                         archived_at__isnull=True,
                         is_draft=False,
                     ),

apiserver/plane/space/views/meta.py

@@ -14,7 +14,9 @@ class ProjectMetaDataEndpoint(BaseAPIView):
 
     def get(self, request, anchor):
         try:
-            deploy_board = DeployBoard.objects.get(anchor=anchor, entity_name="project")
+            deploy_board = DeployBoard.objects.get(
+                anchor=anchor, entity_name="project"
+            )
         except DeployBoard.DoesNotExist:
             return Response(
                 {"error": "Project is not published"}, status=status.HTTP_404_NOT_FOUND

apiserver/plane/tests/README.md

@@ -1,143 +0,0 @@
-# Plane Tests
-
-This directory contains tests for the Plane application. The tests are organized using pytest.
-
-## Test Structure
-
-Tests are organized into the following categories:
-
-- **Unit tests**: Test individual functions or classes in isolation.
-- **Contract tests**: Test interactions between components and verify API contracts are fulfilled.
-  - **API tests**: Test the external API endpoints (under `/api/v1/`).
-  - **App tests**: Test the web application API endpoints (under `/api/`).
-- **Smoke tests**: Basic tests to verify that the application runs correctly.
-
-## API vs App Endpoints
-
-Plane has two types of API endpoints:
-
-1. **External API** (`plane.api`):
-   - Available at `/api/v1/` endpoint
-   - Uses API key authentication (X-Api-Key header)
-   - Designed for external API contracts and third-party access
-   - Tests use the `api_key_client` fixture for authentication
-   - Test files are in `contract/api/`
-
-2. **Web App API** (`plane.app`):
-   - Available at `/api/` endpoint
-   - Uses session-based authentication (CSRF disabled)
-   - Designed for the web application frontend
-   - Tests use the `session_client` fixture for authentication
-   - Test files are in `contract/app/`
-
-## Running Tests
-
-To run all tests:
-
-```bash
-python -m pytest
-```
-
-To run specific test categories:
-
-```bash
-# Run unit tests
-python -m pytest plane/tests/unit/
-
-# Run API contract tests
-python -m pytest plane/tests/contract/api/
-
-# Run App contract tests
-python -m pytest plane/tests/contract/app/
-
-# Run smoke tests
-python -m pytest plane/tests/smoke/
-```
-
-For convenience, we also provide a helper script:
-
-```bash
-# Run all tests
-./run_tests.py
-
-# Run only unit tests
-./run_tests.py -u
-
-# Run contract tests with coverage report
-./run_tests.py -c -o
-
-# Run tests in parallel
-./run_tests.py -p
-```
-
-## Fixtures
-
-The following fixtures are available for testing:
-
-- `api_client`: Unauthenticated API client
-- `create_user`: Creates a test user
-- `api_token`: API token for the test user
-- `api_key_client`: API client with API key authentication (for external API tests)
-- `session_client`: API client with session authentication (for app API tests)
-- `plane_server`: Live Django test server for HTTP-based smoke tests
-
-## Writing Tests
-
-When writing tests, follow these guidelines:
-
-1. Place tests in the appropriate directory based on their type.
-2. Use the correct client fixture based on the API being tested:
-   - For external API (`/api/v1/`), use `api_key_client`
-   - For web app API (`/api/`), use `session_client`
-   - For smoke tests with real HTTP, use `plane_server`
-3. Use the correct URL namespace when reverse-resolving URLs:
-   - For external API, use `reverse("api:endpoint_name")`  
-   - For web app API, use `reverse("endpoint_name")`
-4. Add the `@pytest.mark.django_db` decorator to tests that interact with the database.
-5. Add the appropriate markers (`@pytest.mark.contract`, etc.) to categorize tests.
-
-## Test Fixtures
-
-Common fixtures are defined in:
-
-- `conftest.py`: General fixtures for authentication, database access, etc.
-- `conftest_external.py`: Fixtures for external services (Redis, Elasticsearch, Celery, MongoDB)
-- `factories.py`: Test factories for easy model instance creation
-
-## Best Practices
-
-When writing tests, follow these guidelines:
-
-1. **Use pytest's assert syntax** instead of Django's `self.assert*` methods.
-2. **Add markers to categorize tests**:
-   ```python
-   @pytest.mark.unit
-   @pytest.mark.contract
-   @pytest.mark.smoke
-   ```
-3. **Use fixtures instead of setUp/tearDown methods** for cleaner, more reusable test code.
-4. **Mock external dependencies** with the provided fixtures to avoid external service dependencies.
-5. **Write focused tests** that verify one specific behavior or edge case.
-6. **Keep test files small and organized** by logical components or endpoints.
-7. **Target 90% code coverage** for models, serializers, and business logic.
-
-## External Dependencies
-
-Tests for components that interact with external services should:
-
-1. Use the `mock_redis`, `mock_elasticsearch`, `mock_mongodb`, and `mock_celery` fixtures for unit and most contract tests.
-2. For more comprehensive contract tests, use Docker-based test containers (optional).
-
-## Coverage Reports
-
-Generate a coverage report with:
-
-```bash
-python -m pytest --cov=plane --cov-report=term --cov-report=html
-```
-
-This creates an HTML report in the `htmlcov/` directory.
-
-## Migration from Old Tests
-
-Some tests are still in the old format in the `api/` directory. These need to be migrated to the new contract test structure in the appropriate directories. 

apiserver/plane/tests/TESTING_GUIDE.md

@@ -1,151 +0,0 @@
-# Testing Guide for Plane
-
-This guide explains how to write tests for Plane using our pytest-based testing strategy.
-
-## Test Categories
-
-We divide tests into three categories:
-
-1. **Unit Tests**: Testing individual components in isolation.
-2. **Contract Tests**: Testing API endpoints and verifying contracts between components.
-3. **Smoke Tests**: Basic end-to-end tests for critical flows.
-
-## Writing Unit Tests
-
-Unit tests should be placed in the appropriate directory under `tests/unit/` depending on what you're testing:
-
-- `tests/unit/models/` - For model tests
-- `tests/unit/serializers/` - For serializer tests
-- `tests/unit/utils/` - For utility function tests
-
-### Example Unit Test:
-
-```python
-import pytest
-from plane.api.serializers import MySerializer
-
-@pytest.mark.unit
-class TestMySerializer:
-    def test_serializer_valid_data(self):
-        # Create input data
-        data = {"field1": "value1", "field2": 42}
-        
-        # Initialize the serializer
-        serializer = MySerializer(data=data)
-        
-        # Validate
-        assert serializer.is_valid()
-        
-        # Check validated data
-        assert serializer.validated_data["field1"] == "value1"
-        assert serializer.validated_data["field2"] == 42
-```
-
-## Writing Contract Tests
-
-Contract tests should be placed in `tests/contract/api/` or `tests/contract/app/` directories and should test the API endpoints.
-
-### Example Contract Test:
-
-```python
-import pytest
-from django.urls import reverse
-from rest_framework import status
-
-@pytest.mark.contract
-class TestMyEndpoint:
-    @pytest.mark.django_db
-    def test_my_endpoint_get(self, auth_client):
-        # Get the URL
-        url = reverse("my-endpoint")
-        
-        # Make request
-        response = auth_client.get(url)
-        
-        # Check response
-        assert response.status_code == status.HTTP_200_OK
-        assert "data" in response.data
-```
-
-## Writing Smoke Tests
-
-Smoke tests should be placed in `tests/smoke/` directory and use the `plane_server` fixture to test against a real HTTP server.
-
-### Example Smoke Test:
-
-```python
-import pytest
-import requests
-
-@pytest.mark.smoke
-class TestCriticalFlow:
-    @pytest.mark.django_db
-    def test_login_flow(self, plane_server, create_user, user_data):
-        # Get login URL
-        url = f"{plane_server.url}/api/auth/signin/"
-        
-        # Test login
-        response = requests.post(
-            url, 
-            json={
-                "email": user_data["email"],
-                "password": user_data["password"]
-            }
-        )
-        
-        # Verify
-        assert response.status_code == 200
-        data = response.json()
-        assert "access_token" in data
-```
-
-## Useful Fixtures
-
-Our test setup provides several useful fixtures:
-
-1. `api_client`: An unauthenticated DRF APIClient
-2. `api_key_client`: API client with API key authentication (for external API tests)
-3. `session_client`: API client with session authentication (for web app API tests)
-4. `create_user`: Creates and returns a test user
-5. `mock_redis`: Mocks Redis interactions
-6. `mock_elasticsearch`: Mocks Elasticsearch interactions
-7. `mock_celery`: Mocks Celery task execution
-
-## Using Factory Boy
-
-For more complex test data setup, use the provided factories:
-
-```python
-from plane.tests.factories import UserFactory, WorkspaceFactory
-
-# Create a user
-user = UserFactory()
-
-# Create a workspace with a specific owner
-workspace = WorkspaceFactory(owner=user)
-
-# Create multiple objects
-users = UserFactory.create_batch(5)
-```
-
-## Running Tests
-
-Use pytest to run tests:
-
-```bash
-# Run all tests
-python -m pytest
-
-# Run only unit tests with coverage
-python -m pytest -m unit --cov=plane
-```
-
-## Best Practices
-
-1. **Keep tests small and focused** - Each test should verify one specific behavior.
-2. **Use markers** - Always add appropriate markers (`@pytest.mark.unit`, etc.).
-3. **Mock external dependencies** - Use the provided mock fixtures.
-4. **Use factories** - For complex data setup, use factories.
-5. **Don't test the framework** - Focus on testing your business logic, not Django/DRF itself.
-6. **Write readable assertions** - Use plain `assert` statements with clear messaging.
-7. **Focus on coverage** - Aim for ≥90% code coverage for critical components.

apiserver/plane/tests/__init__.py

@@ -1 +1 @@
-# Test package initialization
+from .api import *

apiserver/plane/tests/api/base.py

@@ -0,0 +1,34 @@
+# Third party imports
+from rest_framework.test import APITestCase, APIClient
+
+# Module imports
+from plane.db.models import User
+from plane.app.views.authentication import get_tokens_for_user
+
+
+class BaseAPITest(APITestCase):
+    def setUp(self):
+        self.client = APIClient(HTTP_USER_AGENT="plane/test", REMOTE_ADDR="10.10.10.10")
+
+
+class AuthenticatedAPITest(BaseAPITest):
+    def setUp(self):
+        super().setUp()
+
+        ## Create Dummy User
+        self.email = "user@plane.so"
+        user = User.objects.create(email=self.email)
+        user.set_password("user@123")
+        user.save()
+
+        # Set user
+        self.user = user
+
+        # Set Up User ID
+        self.user_id = user.id
+
+        access_token, _ = get_tokens_for_user(user)
+        self.access_token = access_token
+
+        # Set Up Authentication Token
+        self.client.credentials(HTTP_AUTHORIZATION="Bearer " + access_token)

apiserver/plane/tests/api/test_asset.py

@@ -0,0 +1 @@
+# TODO: Tests for File Asset Uploads

apiserver/plane/tests/api/test_auth_extended.py

@@ -0,0 +1 @@
+# TODO: Tests for ChangePassword and other Endpoints

apiserver/plane/tests/api/test_authentication.py

@@ -0,0 +1,183 @@
+# Python import
+import json
+
+# Django imports
+from django.urls import reverse
+
+# Third Party imports
+from rest_framework import status
+from .base import BaseAPITest
+
+# Module imports
+from plane.db.models import User
+from plane.settings.redis import redis_instance
+
+
+class SignInEndpointTests(BaseAPITest):
+    def setUp(self):
+        super().setUp()
+        user = User.objects.create(email="user@plane.so")
+        user.set_password("user@123")
+        user.save()
+
+    def test_without_data(self):
+        url = reverse("sign-in")
+        response = self.client.post(url, {}, format="json")
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_email_validity(self):
+        url = reverse("sign-in")
+        response = self.client.post(
+            url, {"email": "useremail.com", "password": "user@123"}, format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(
+            response.data, {"error": "Please provide a valid email address."}
+        )
+
+    def test_password_validity(self):
+        url = reverse("sign-in")
+        response = self.client.post(
+            url, {"email": "user@plane.so", "password": "user123"}, format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(
+            response.data,
+            {
+                "error": "Sorry, we could not find a user with the provided credentials. Please try again."
+            },
+        )
+
+    def test_user_exists(self):
+        url = reverse("sign-in")
+        response = self.client.post(
+            url, {"email": "user@email.so", "password": "user123"}, format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(
+            response.data,
+            {
+                "error": "Sorry, we could not find a user with the provided credentials. Please try again."
+            },
+        )
+
+    def test_user_login(self):
+        url = reverse("sign-in")
+
+        response = self.client.post(
+            url, {"email": "user@plane.so", "password": "user@123"}, format="json"
+        )
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data.get("user").get("email"), "user@plane.so")
+
+
+class MagicLinkGenerateEndpointTests(BaseAPITest):
+    def setUp(self):
+        super().setUp()
+        user = User.objects.create(email="user@plane.so")
+        user.set_password("user@123")
+        user.save()
+
+    def test_without_data(self):
+        url = reverse("magic-generate")
+        response = self.client.post(url, {}, format="json")
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_email_validity(self):
+        url = reverse("magic-generate")
+        response = self.client.post(url, {"email": "useremail.com"}, format="json")
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(
+            response.data, {"error": "Please provide a valid email address."}
+        )
+
+    def test_magic_generate(self):
+        url = reverse("magic-generate")
+
+        ri = redis_instance()
+        ri.delete("magic_user@plane.so")
+
+        response = self.client.post(url, {"email": "user@plane.so"}, format="json")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_max_generate_attempt(self):
+        url = reverse("magic-generate")
+
+        ri = redis_instance()
+        ri.delete("magic_user@plane.so")
+
+        for _ in range(4):
+            response = self.client.post(url, {"email": "user@plane.so"}, format="json")
+
+        response = self.client.post(url, {"email": "user@plane.so"}, format="json")
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(
+            response.data, {"error": "Max attempts exhausted. Please try again later."}
+        )
+
+
+class MagicSignInEndpointTests(BaseAPITest):
+    def setUp(self):
+        super().setUp()
+        user = User.objects.create(email="user@plane.so")
+        user.set_password("user@123")
+        user.save()
+
+    def test_without_data(self):
+        url = reverse("magic-sign-in")
+        response = self.client.post(url, {}, format="json")
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(response.data, {"error": "User token and key are required"})
+
+    def test_expired_invalid_magic_link(self):
+        ri = redis_instance()
+        ri.delete("magic_user@plane.so")
+
+        url = reverse("magic-sign-in")
+        response = self.client.post(
+            url,
+            {"key": "magic_user@plane.so", "token": "xxxx-xxxxx-xxxx"},
+            format="json",
+        )
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(
+            response.data, {"error": "The magic code/link has expired please try again"}
+        )
+
+    def test_invalid_magic_code(self):
+        ri = redis_instance()
+        ri.delete("magic_user@plane.so")
+        ## Create Token
+        url = reverse("magic-generate")
+        self.client.post(url, {"email": "user@plane.so"}, format="json")
+
+        url = reverse("magic-sign-in")
+        response = self.client.post(
+            url,
+            {"key": "magic_user@plane.so", "token": "xxxx-xxxxx-xxxx"},
+            format="json",
+        )
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(
+            response.data, {"error": "Your login code was incorrect. Please try again."}
+        )
+
+    def test_magic_code_sign_in(self):
+        ri = redis_instance()
+        ri.delete("magic_user@plane.so")
+        ## Create Token
+        url = reverse("magic-generate")
+        self.client.post(url, {"email": "user@plane.so"}, format="json")
+
+        # Get the token
+        user_data = json.loads(ri.get("magic_user@plane.so"))
+        token = user_data["token"]
+
+        url = reverse("magic-sign-in")
+        response = self.client.post(
+            url, {"key": "magic_user@plane.so", "token": token}, format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data.get("user").get("email"), "user@plane.so")

apiserver/plane/tests/api/test_cycle.py

@@ -0,0 +1 @@
+# TODO: Write Test for Cycle Endpoints

apiserver/plane/tests/api/test_issue.py

@@ -0,0 +1 @@
+# TODO: Write Test for Issue Endpoints

apiserver/plane/tests/api/test_oauth.py

@@ -0,0 +1 @@
+# TODO: Tests for OAuth Authentication Endpoint

apiserver/plane/tests/api/test_people.py

@@ -0,0 +1 @@
+# TODO: Write Test for people Endpoint

apiserver/plane/tests/api/test_project.py

@@ -0,0 +1 @@
+# TODO: Write Tests for project endpoints

apiserver/plane/tests/api/test_shortcut.py

@@ -0,0 +1 @@
+# TODO: Write Test for shortcuts

apiserver/plane/tests/api/test_state.py

@@ -0,0 +1 @@
+# TODO: Wrote test for state endpoints

apiserver/plane/tests/api/test_view.py

@@ -0,0 +1 @@
+# TODO: Write test for view endpoints

apiserver/plane/tests/api/test_workspace.py

@@ -0,0 +1,44 @@
+# Django imports
+from django.urls import reverse
+
+# Third party import
+from rest_framework import status
+
+# Module imports
+from .base import AuthenticatedAPITest
+from plane.db.models import Workspace, WorkspaceMember
+
+
+class WorkSpaceCreateReadUpdateDelete(AuthenticatedAPITest):
+    def setUp(self):
+        super().setUp()
+
+    def test_create_workspace(self):
+        url = reverse("workspace")
+
+        # Test with empty data
+        response = self.client.post(url, {}, format="json")
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+        # Test with valid data
+        response = self.client.post(
+            url, {"name": "Plane", "slug": "pla-ne"}, format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+        self.assertEqual(Workspace.objects.count(), 1)
+        # Check if the member is created
+        self.assertEqual(WorkspaceMember.objects.count(), 1)
+
+        # Check other values
+        workspace = Workspace.objects.get(pk=response.data["id"])
+        workspace_member = WorkspaceMember.objects.get(
+            workspace=workspace, member_id=self.user_id
+        )
+        self.assertEqual(workspace.owner_id, self.user_id)
+        self.assertEqual(workspace_member.role, 20)
+
+        # Create a already existing workspace
+        response = self.client.post(
+            url, {"name": "Plane", "slug": "pla-ne"}, format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_409_CONFLICT)

apiserver/plane/tests/conftest.py

@@ -1,78 +0,0 @@
-import pytest
-from django.conf import settings
-from rest_framework.test import APIClient
-from pytest_django.fixtures import django_db_setup
-from unittest.mock import patch, MagicMock
-
-from plane.db.models import User
-from plane.db.models.api import APIToken
-
-
-@pytest.fixture(scope="session")
-def django_db_setup(django_db_setup):
-    """Set up the Django database for the test session"""
-    pass
-
-
-@pytest.fixture
-def api_client():
-    """Return an unauthenticated API client"""
-    return APIClient()
-
-
-@pytest.fixture
-def user_data():
-    """Return standard user data for tests"""
-    return {
-        "email": "test@plane.so",
-        "password": "test-password",
-        "first_name": "Test",
-        "last_name": "User"
-    }
-
-
-@pytest.fixture
-def create_user(db, user_data):
-    """Create and return a user instance"""
-    user = User.objects.create(
-        email=user_data["email"],
-        first_name=user_data["first_name"],
-        last_name=user_data["last_name"]
-    )
-    user.set_password(user_data["password"])
-    user.save()
-    return user
-
-
-@pytest.fixture
-def api_token(db, create_user):
-    """Create and return an API token for testing the external API"""
-    token = APIToken.objects.create(
-        user=create_user,
-        label="Test API Token",
-        token="test-api-token-12345",
-    )
-    return token
-
-
-@pytest.fixture
-def api_key_client(api_client, api_token):
-    """Return an API key authenticated client for external API testing"""
-    api_client.credentials(HTTP_X_API_KEY=api_token.token)
-    return api_client
-
-
-@pytest.fixture
-def session_client(api_client, create_user):
-    """Return a session authenticated API client for app API testing, which is what plane.app uses"""
-    api_client.force_authenticate(user=create_user)
-    return api_client
-
-
-@pytest.fixture
-def plane_server(live_server):
-    """
-    Renamed version of live_server fixture to avoid name clashes.
-    Returns a live Django server for testing HTTP requests.
-    """
-    return live_server

apiserver/plane/tests/conftest_external.py

@@ -1,117 +0,0 @@
-import pytest
-from unittest.mock import MagicMock, patch
-from django.conf import settings
-
-
-@pytest.fixture
-def mock_redis():
-    """
-    Mock Redis for testing without actual Redis connection.
-
-    This fixture patches the redis_instance function to return a MagicMock
-    that behaves like a Redis client.
-    """
-    mock_redis_client = MagicMock()
-
-    # Configure the mock to handle common Redis operations
-    mock_redis_client.get.return_value = None
-    mock_redis_client.set.return_value = True
-    mock_redis_client.delete.return_value = True
-    mock_redis_client.exists.return_value = 0
-    mock_redis_client.ttl.return_value = -1
-
-    # Start the patch
-    with patch('plane.settings.redis.redis_instance', return_value=mock_redis_client):
-        yield mock_redis_client
-
-
-@pytest.fixture
-def mock_elasticsearch():
-    """
-    Mock Elasticsearch for testing without actual ES connection.
-
-    This fixture patches Elasticsearch to return a MagicMock
-    that behaves like an Elasticsearch client.
-    """
-    mock_es_client = MagicMock()
-
-    # Configure the mock to handle common ES operations
-    mock_es_client.indices.exists.return_value = True
-    mock_es_client.indices.create.return_value = {"acknowledged": True}
-    mock_es_client.search.return_value = {"hits": {"total": {"value": 0}, "hits": []}}
-    mock_es_client.index.return_value = {"_id": "test_id", "result": "created"}
-    mock_es_client.update.return_value = {"_id": "test_id", "result": "updated"}
-    mock_es_client.delete.return_value = {"_id": "test_id", "result": "deleted"}
-
-    # Start the patch
-    with patch('elasticsearch.Elasticsearch', return_value=mock_es_client):
-        yield mock_es_client
-
-
-@pytest.fixture
-def mock_mongodb():
-    """
-    Mock MongoDB for testing without actual MongoDB connection.
-
-    This fixture patches PyMongo to return a MagicMock that behaves like a MongoDB client.
-    """
-    # Create mock MongoDB clients and collections
-    mock_mongo_client = MagicMock()
-    mock_mongo_db = MagicMock()
-    mock_mongo_collection = MagicMock()
-
-    # Set up the chain: client -> database -> collection
-    mock_mongo_client.__getitem__.return_value = mock_mongo_db
-    mock_mongo_client.get_database.return_value = mock_mongo_db
-    mock_mongo_db.__getitem__.return_value = mock_mongo_collection
-
-    # Configure common MongoDB collection operations
-    mock_mongo_collection.find_one.return_value = None
-    mock_mongo_collection.find.return_value = MagicMock(
-        __iter__=lambda x: iter([]),
-        count=lambda: 0
-    )
-    mock_mongo_collection.insert_one.return_value = MagicMock(
-        inserted_id="mock_id_123",
-        acknowledged=True
-    )
-    mock_mongo_collection.insert_many.return_value = MagicMock(
-        inserted_ids=["mock_id_123", "mock_id_456"],
-        acknowledged=True
-    )
-    mock_mongo_collection.update_one.return_value = MagicMock(
-        modified_count=1,
-        matched_count=1,
-        acknowledged=True
-    )
-    mock_mongo_collection.update_many.return_value = MagicMock(
-        modified_count=2,
-        matched_count=2,
-        acknowledged=True
-    )
-    mock_mongo_collection.delete_one.return_value = MagicMock(
-        deleted_count=1,
-        acknowledged=True
-    )
-    mock_mongo_collection.delete_many.return_value = MagicMock(
-        deleted_count=2,
-        acknowledged=True
-    )
-    mock_mongo_collection.count_documents.return_value = 0
-
-    # Start the patch
-    with patch('pymongo.MongoClient', return_value=mock_mongo_client):
-        yield mock_mongo_client
-
-
-@pytest.fixture
-def mock_celery():
-    """
-    Mock Celery for testing without actual task execution.
-
-    This fixture patches Celery's task.delay() to prevent actual task execution.
-    """
-    # Start the patch
-    with patch('celery.app.task.Task.delay') as mock_delay:
-        mock_delay.return_value = MagicMock(id="mock-task-id")
-        yield mock_delay

apiserver/plane/tests/contract/app/__init__.py

@@ -1 +0,0 @@
- 

apiserver/plane/tests/contract/app/test_authentication.py

@@ -1,459 +0,0 @@
-import json
-import uuid
-import pytest
-from django.urls import reverse
-from django.utils import timezone
-from rest_framework import status
-from django.test import Client
-from django.core.exceptions import ValidationError
-from unittest.mock import patch, MagicMock
-
-from plane.db.models import User
-from plane.settings.redis import redis_instance
-from plane.license.models import Instance
-
-
-@pytest.fixture
-def setup_instance(db):
-    """Create and configure an instance for authentication tests"""
-    instance_id = uuid.uuid4() if not Instance.objects.exists() else Instance.objects.first().id
-
-    # Create or update instance with all required fields
-    instance, _ = Instance.objects.update_or_create(
-        id=instance_id,
-        defaults={
-            "instance_name": "Test Instance",
-            "instance_id": str(uuid.uuid4()),
-            "current_version": "1.0.0",
-            "domain": "http://localhost:8000",
-            "last_checked_at": timezone.now(),
-            "is_setup_done": True,
-        }
-    )
-    return instance
-
-
-@pytest.fixture
-def django_client():
-    """Return a Django test client with User-Agent header for handling redirects"""
-    client = Client(HTTP_USER_AGENT="Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0.1")
-    return client
-
-
-@pytest.mark.contract
-class TestMagicLinkGenerate:
-    """Test magic link generation functionality"""
-
-    @pytest.fixture
-    def setup_user(self, db):
-        """Create a test user for magic link tests"""
-        user = User.objects.create(email="user@plane.so")
-        user.set_password("user@123")
-        user.save()
-        return user
-
-    @pytest.mark.django_db
-    def test_without_data(self, api_client, setup_user, setup_instance):
-        """Test magic link generation with empty data"""
-        url = reverse("magic-generate")
-        try:
-            response = api_client.post(url, {}, format="json")
-            assert response.status_code == status.HTTP_400_BAD_REQUEST
-        except ValidationError:
-            # If a ValidationError is raised directly, that's also acceptable
-            # as it indicates the empty email was rejected
-            assert True
-
-    @pytest.mark.django_db
-    def test_email_validity(self, api_client, setup_user, setup_instance):
-        """Test magic link generation with invalid email format"""
-        url = reverse("magic-generate")
-        try:
-            response = api_client.post(url, {"email": "useremail.com"}, format="json")
-            assert response.status_code == status.HTTP_400_BAD_REQUEST
-            assert "error_code" in response.data  # Check for error code in response
-        except ValidationError:
-            # If a ValidationError is raised directly, that's also acceptable
-            # as it indicates the invalid email was rejected
-            assert True
-
-    @pytest.mark.django_db
-    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
-    def test_magic_generate(self, mock_magic_link, api_client, setup_user, setup_instance):
-        """Test successful magic link generation"""
-        url = reverse("magic-generate")
-
-        ri = redis_instance()
-        ri.delete("magic_user@plane.so")
-
-        response = api_client.post(url, {"email": "user@plane.so"}, format="json")
-        assert response.status_code == status.HTTP_200_OK
-        assert "key" in response.data  # Check for key in response
-
-        # Verify the mock was called with the expected arguments
-        mock_magic_link.assert_called_once()
-        args = mock_magic_link.call_args[0]
-        assert args[0] == "user@plane.so"  # First arg should be the email
-
-    @pytest.mark.django_db
-    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
-    def test_max_generate_attempt(self, mock_magic_link, api_client, setup_user, setup_instance):
-        """Test exceeding maximum magic link generation attempts"""
-        url = reverse("magic-generate")
-
-        ri = redis_instance()
-        ri.delete("magic_user@plane.so")
-
-        for _ in range(4):
-            api_client.post(url, {"email": "user@plane.so"}, format="json")
-
-        response = api_client.post(url, {"email": "user@plane.so"}, format="json")
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-        assert "error_code" in response.data  # Check for error code in response
-
-
-@pytest.mark.contract
-class TestSignInEndpoint:
-    """Test sign-in functionality"""
-
-    @pytest.fixture
-    def setup_user(self, db):
-        """Create a test user for authentication tests"""
-        user = User.objects.create(email="user@plane.so")
-        user.set_password("user@123")
-        user.save()
-        return user
-
-    @pytest.mark.django_db
-    def test_without_data(self, django_client, setup_user, setup_instance):
-        """Test sign-in with empty data"""
-        url = reverse("sign-in")
-        response = django_client.post(url, {}, follow=True)
-
-        # Check redirect contains error code
-        assert "REQUIRED_EMAIL_PASSWORD_SIGN_IN" in response.redirect_chain[-1][0]
-
-    @pytest.mark.django_db
-    def test_email_validity(self, django_client, setup_user, setup_instance):
-        """Test sign-in with invalid email format"""
-        url = reverse("sign-in")
-        response = django_client.post(
-            url, {"email": "useremail.com", "password": "user@123"}, follow=True
-        )
-
-        # Check redirect contains error code
-        assert "INVALID_EMAIL_SIGN_IN" in response.redirect_chain[-1][0]
-
-    @pytest.mark.django_db
-    def test_user_exists(self, django_client, setup_user, setup_instance):
-        """Test sign-in with non-existent user"""
-        url = reverse("sign-in")
-        response = django_client.post(
-            url, {"email": "user@email.so", "password": "user123"}, follow=True
-        )
-
-        # Check redirect contains error code
-        assert "USER_DOES_NOT_EXIST" in response.redirect_chain[-1][0]
-
-    @pytest.mark.django_db
-    def test_password_validity(self, django_client, setup_user, setup_instance):
-        """Test sign-in with incorrect password"""
-        url = reverse("sign-in")
-        response = django_client.post(
-            url, {"email": "user@plane.so", "password": "user123"}, follow=True
-        )
-
-
-        # Check for the specific authentication error in the URL
-        redirect_urls = [url for url, _ in response.redirect_chain]
-        redirect_contents = ' '.join(redirect_urls)
-
-        # The actual error code for invalid password is AUTHENTICATION_FAILED_SIGN_IN
-        assert "AUTHENTICATION_FAILED_SIGN_IN" in redirect_contents
-
-    @pytest.mark.django_db
-    def test_user_login(self, django_client, setup_user, setup_instance):
-        """Test successful sign-in"""
-        url = reverse("sign-in")
-
-        # First make the request without following redirects
-        response = django_client.post(
-            url, {"email": "user@plane.so", "password": "user@123"}, follow=False
-        )
-
-        # Check that the initial response is a redirect (302) without error code
-        assert response.status_code == 302
-        assert "error_code" not in response.url
-
-        # Now follow just the first redirect to avoid 404s
-        response = django_client.get(response.url, follow=False)
-
-        # The user should be authenticated regardless of the final page
-        assert "_auth_user_id" in django_client.session
-
-    @pytest.mark.django_db
-    def test_next_path_redirection(self, django_client, setup_user, setup_instance):
-        """Test sign-in with next_path parameter"""
-        url = reverse("sign-in")
-        next_path = "workspaces"
-
-        # First make the request without following redirects
-        response = django_client.post(
-            url,
-            {"email": "user@plane.so", "password": "user@123", "next_path": next_path},
-            follow=False
-        )
-
-        # Check that the initial response is a redirect (302) without error code
-        assert response.status_code == 302
-        assert "error_code" not in response.url
-
-
-        # In a real browser, the next_path would be used to build the absolute URL
-        # Since we're just testing the authentication logic, we won't check for the exact URL structure
-        # Instead, just verify that we're authenticated
-        assert "_auth_user_id" in django_client.session
-
-
-@pytest.mark.contract
-class TestMagicSignIn:
-    """Test magic link sign-in functionality"""
-
-    @pytest.fixture
-    def setup_user(self, db):
-        """Create a test user for magic sign-in tests"""
-        user = User.objects.create(email="user@plane.so")
-        user.set_password("user@123")
-        user.save()
-        return user
-
-    @pytest.mark.django_db
-    def test_without_data(self, django_client, setup_user, setup_instance):
-        """Test magic link sign-in with empty data"""
-        url = reverse("magic-sign-in")
-        response = django_client.post(url, {}, follow=True)
-
-        # Check redirect contains error code
-        assert "MAGIC_SIGN_IN_EMAIL_CODE_REQUIRED" in response.redirect_chain[-1][0]
-
-    @pytest.mark.django_db
-    def test_expired_invalid_magic_link(self, django_client, setup_user, setup_instance):
-        """Test magic link sign-in with expired/invalid link"""
-        ri = redis_instance()
-        ri.delete("magic_user@plane.so")
-
-        url = reverse("magic-sign-in")
-        response = django_client.post(
-            url,
-            {"email": "user@plane.so", "code": "xxxx-xxxxx-xxxx"},
-            follow=False
-        )
-
-        # Check that we get a redirect
-        assert response.status_code == 302
-
-        # The actual error code is EXPIRED_MAGIC_CODE_SIGN_IN (when key doesn't exist)
-        # or INVALID_MAGIC_CODE_SIGN_IN (when key exists but code doesn't match)
-        assert "EXPIRED_MAGIC_CODE_SIGN_IN" in response.url or "INVALID_MAGIC_CODE_SIGN_IN" in response.url
-
-    @pytest.mark.django_db
-    def test_user_does_not_exist(self, django_client, setup_instance):
-        """Test magic sign-in with non-existent user"""
-        url = reverse("magic-sign-in")
-        response = django_client.post(
-            url,
-            {"email": "nonexistent@plane.so", "code": "xxxx-xxxxx-xxxx"},
-            follow=True
-        )
-
-        # Check redirect contains error code
-        assert "USER_DOES_NOT_EXIST" in response.redirect_chain[-1][0]
-
-    @pytest.mark.django_db
-    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
-    def test_magic_code_sign_in(self, mock_magic_link, django_client, api_client, setup_user, setup_instance):
-        """Test successful magic link sign-in process"""
-        # First generate a magic link token
-        gen_url = reverse("magic-generate")
-        response = api_client.post(gen_url, {"email": "user@plane.so"}, format="json")
-
-        # Check that the token generation was successful
-        assert response.status_code == status.HTTP_200_OK
-
-        # Since we're mocking the magic_link task, we need to manually get the token from Redis
-        ri = redis_instance()
-        user_data = json.loads(ri.get("magic_user@plane.so"))
-        token = user_data["token"]
-
-        # Use Django client to test the redirect flow without following redirects
-        url = reverse("magic-sign-in")
-        response = django_client.post(
-            url,
-            {"email": "user@plane.so", "code": token},
-            follow=False
-        )
-
-        # Check that the initial response is a redirect without error code
-        assert response.status_code == 302
-        assert "error_code" not in response.url
-
-        # The user should now be authenticated
-        assert "_auth_user_id" in django_client.session
-
-    @pytest.mark.django_db
-    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
-    def test_magic_sign_in_with_next_path(self, mock_magic_link, django_client, api_client, setup_user, setup_instance):
-        """Test magic sign-in with next_path parameter"""
-        # First generate a magic link token
-        gen_url = reverse("magic-generate")
-        response = api_client.post(gen_url, {"email": "user@plane.so"}, format="json")
-
-        # Check that the token generation was successful
-        assert response.status_code == status.HTTP_200_OK
-
-        # Since we're mocking the magic_link task, we need to manually get the token from Redis
-        ri = redis_instance()
-        user_data = json.loads(ri.get("magic_user@plane.so"))
-        token = user_data["token"]
-
-        # Use Django client to test the redirect flow without following redirects
-        url = reverse("magic-sign-in")
-        next_path = "workspaces"
-        response = django_client.post(
-            url,
-            {"email": "user@plane.so", "code": token, "next_path": next_path},
-            follow=False
-        )
-
-        # Check that the initial response is a redirect without error code
-        assert response.status_code == 302
-        assert "error_code" not in response.url
-
-        # Check that the redirect URL contains the next_path
-        assert next_path in response.url
-
-        # The user should now be authenticated
-        assert "_auth_user_id" in django_client.session
-
-
-@pytest.mark.contract
-class TestMagicSignUp:
-    """Test magic link sign-up functionality"""
-
-    @pytest.mark.django_db
-    def test_without_data(self, django_client, setup_instance):
-        """Test magic link sign-up with empty data"""
-        url = reverse("magic-sign-up")
-        response = django_client.post(url, {}, follow=True)
-
-        # Check redirect contains error code
-        assert "MAGIC_SIGN_UP_EMAIL_CODE_REQUIRED" in response.redirect_chain[-1][0]
-
-    @pytest.mark.django_db
-    def test_user_already_exists(self, django_client, db, setup_instance):
-        """Test magic sign-up with existing user"""
-        # Create a user that already exists
-        User.objects.create(email="existing@plane.so")
-
-        url = reverse("magic-sign-up")
-        response = django_client.post(
-            url,
-            {"email": "existing@plane.so", "code": "xxxx-xxxxx-xxxx"},
-            follow=True
-        )
-
-        # Check redirect contains error code
-        assert "USER_ALREADY_EXIST" in response.redirect_chain[-1][0]
-
-    @pytest.mark.django_db
-    def test_expired_invalid_magic_link(self, django_client, setup_instance):
-        """Test magic link sign-up with expired/invalid link"""
-        url = reverse("magic-sign-up")
-        response = django_client.post(
-            url,
-            {"email": "new@plane.so", "code": "xxxx-xxxxx-xxxx"},
-            follow=False
-        )
-
-        # Check that we get a redirect
-        assert response.status_code == 302
-
-        # The actual error code is EXPIRED_MAGIC_CODE_SIGN_UP (when key doesn't exist)
-        # or INVALID_MAGIC_CODE_SIGN_UP (when key exists but code doesn't match)
-        assert "EXPIRED_MAGIC_CODE_SIGN_UP" in response.url or "INVALID_MAGIC_CODE_SIGN_UP" in response.url
-
-    @pytest.mark.django_db
-    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
-    def test_magic_code_sign_up(self, mock_magic_link, django_client, api_client, setup_instance):
-        """Test successful magic link sign-up process"""
-        email = "newuser@plane.so"
-
-        # First generate a magic link token
-        gen_url = reverse("magic-generate")
-        response = api_client.post(gen_url, {"email": email}, format="json")
-
-        # Check that the token generation was successful
-        assert response.status_code == status.HTTP_200_OK
-
-        # Since we're mocking the magic_link task, we need to manually get the token from Redis
-        ri = redis_instance()
-        user_data = json.loads(ri.get(f"magic_{email}"))
-        token = user_data["token"]
-
-        # Use Django client to test the redirect flow without following redirects
-        url = reverse("magic-sign-up")
-        response = django_client.post(
-            url,
-            {"email": email, "code": token},
-            follow=False
-        )
-
-        # Check that the initial response is a redirect without error code
-        assert response.status_code == 302
-        assert "error_code" not in response.url
-
-        # Check if user was created
-        assert User.objects.filter(email=email).exists()
-
-        # Check if user is authenticated
-        assert "_auth_user_id" in django_client.session
-
-    @pytest.mark.django_db
-    @patch("plane.bgtasks.magic_link_code_task.magic_link.delay")
-    def test_magic_sign_up_with_next_path(self, mock_magic_link, django_client, api_client, setup_instance):
-        """Test magic sign-up with next_path parameter"""
-        email = "newuser2@plane.so"
-
-        # First generate a magic link token
-        gen_url = reverse("magic-generate")
-        response = api_client.post(gen_url, {"email": email}, format="json")
-
-        # Check that the token generation was successful
-        assert response.status_code == status.HTTP_200_OK
-
-        # Since we're mocking the magic_link task, we need to manually get the token from Redis
-        ri = redis_instance()
-        user_data = json.loads(ri.get(f"magic_{email}"))
-        token = user_data["token"]
-
-        # Use Django client to test the redirect flow without following redirects
-        url = reverse("magic-sign-up")
-        next_path = "onboarding"
-        response = django_client.post(
-            url,
-            {"email": email, "code": token, "next_path": next_path},
-            follow=False
-        )
-
-        # Check that the initial response is a redirect without error code
-        assert response.status_code == 302
-        assert "error_code" not in response.url
-
-        # In a real browser, the next_path would be used to build the absolute URL
-        # Since we're just testing the authentication logic, we won't check for the exact URL structure
-
-        # Check if user was created
-        assert User.objects.filter(email=email).exists()
-
-        # Check if user is authenticated
-        assert "_auth_user_id" in django_client.session

apiserver/plane/tests/contract/app/test_workspace_app.py

@@ -1,79 +0,0 @@
-import pytest
-from django.urls import reverse
-from rest_framework import status
-from unittest.mock import patch
-
-from plane.db.models import Workspace, WorkspaceMember
-
-
-@pytest.mark.contract
-class TestWorkspaceAPI:
-    """Test workspace CRUD operations"""
-
-    @pytest.mark.django_db
-    def test_create_workspace_empty_data(self, session_client):
-        """Test creating a workspace with empty data"""
-        url = reverse("workspace")
-
-        # Test with empty data
-        response = session_client.post(url, {}, format="json")
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    @pytest.mark.django_db
-    @patch("plane.bgtasks.workspace_seed_task.workspace_seed.delay")
-    def test_create_workspace_valid_data(self, mock_workspace_seed, session_client, create_user):
-        """Test creating a workspace with valid data"""
-        url = reverse("workspace")
-        user = create_user  # Use the create_user fixture directly as it returns a user object
-
-        # Test with valid data - include all required fields
-        workspace_data = {
-            "name": "Plane",
-            "slug": "pla-ne-test",
-            "company_name": "Plane Inc."
-        }
-
-        # Make the request
-        response = session_client.post(url, workspace_data, format="json")
-
-        # Check response status
-        assert response.status_code == status.HTTP_201_CREATED
-
-        # Verify workspace was created
-        assert Workspace.objects.count() == 1
-
-        # Check if the member is created
-        assert WorkspaceMember.objects.count() == 1
-
-        # Check other values
-        workspace = Workspace.objects.get(slug=workspace_data["slug"])
-        workspace_member = WorkspaceMember.objects.filter(
-            workspace=workspace, member=user
-        ).first()
-        assert workspace.owner == user
-        assert workspace_member.role == 20
-
-        # Verify the workspace_seed task was called
-        mock_workspace_seed.assert_called_once_with(response.data["id"])
-
-    @pytest.mark.django_db
-    @patch('plane.bgtasks.workspace_seed_task.workspace_seed.delay')
-    def test_create_duplicate_workspace(self, mock_workspace_seed, session_client):
-        """Test creating a duplicate workspace"""
-        url = reverse("workspace")
-
-        # Create first workspace
-        session_client.post(
-            url, {"name": "Plane", "slug": "pla-ne"}, format="json"
-        )
-
-        # Try to create a workspace with the same slug
-        response = session_client.post(
-            url, {"name": "Plane", "slug": "pla-ne"}, format="json"
-        )
-
-        # The API returns 400 BAD REQUEST for duplicate slugs, not 409 CONFLICT
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-        # Optionally check the error message to confirm it's related to the duplicate slug
-        assert "slug" in response.data

apiserver/plane/tests/factories.py

@@ -1,82 +0,0 @@
-import factory
-from uuid import uuid4
-from django.utils import timezone
-
-from plane.db.models import (
-    User,
-    Workspace,
-    WorkspaceMember,
-    Project,
-    ProjectMember
-)
-
-
-class UserFactory(factory.django.DjangoModelFactory):
-    """Factory for creating User instances"""
-    class Meta:
-        model = User
-        django_get_or_create = ('email',)
-
-    id = factory.LazyFunction(uuid4)
-    email = factory.Sequence(lambda n: f'user{n}@plane.so')
-    password = factory.PostGenerationMethodCall('set_password', 'password')
-    first_name = factory.Sequence(lambda n: f'First{n}')
-    last_name = factory.Sequence(lambda n: f'Last{n}')
-    is_active = True
-    is_superuser = False
-    is_staff = False
-
-
-class WorkspaceFactory(factory.django.DjangoModelFactory):
-    """Factory for creating Workspace instances"""
-    class Meta:
-        model = Workspace
-        django_get_or_create = ('slug',)
-
-    id = factory.LazyFunction(uuid4)
-    name = factory.Sequence(lambda n: f'Workspace {n}')
-    slug = factory.Sequence(lambda n: f'workspace-{n}')
-    owner = factory.SubFactory(UserFactory)
-    created_at = factory.LazyFunction(timezone.now)
-    updated_at = factory.LazyFunction(timezone.now)
-
-
-class WorkspaceMemberFactory(factory.django.DjangoModelFactory):
-    """Factory for creating WorkspaceMember instances"""
-    class Meta:
-        model = WorkspaceMember
-
-    id = factory.LazyFunction(uuid4)
-    workspace = factory.SubFactory(WorkspaceFactory)
-    member = factory.SubFactory(UserFactory)
-    role = 20  # Admin role by default
-    created_at = factory.LazyFunction(timezone.now)
-    updated_at = factory.LazyFunction(timezone.now)
-
-
-class ProjectFactory(factory.django.DjangoModelFactory):
-    """Factory for creating Project instances"""
-    class Meta:
-        model = Project
-        django_get_or_create = ('name', 'workspace')
-
-    id = factory.LazyFunction(uuid4)
-    name = factory.Sequence(lambda n: f'Project {n}')
-    workspace = factory.SubFactory(WorkspaceFactory)
-    created_by = factory.SelfAttribute('workspace.owner')
-    updated_by = factory.SelfAttribute('workspace.owner')
-    created_at = factory.LazyFunction(timezone.now)
-    updated_at = factory.LazyFunction(timezone.now)
-
-
-class ProjectMemberFactory(factory.django.DjangoModelFactory):
-    """Factory for creating ProjectMember instances"""
-    class Meta:
-        model = ProjectMember
-
-    id = factory.LazyFunction(uuid4)
-    project = factory.SubFactory(ProjectFactory)
-    member = factory.SubFactory(UserFactory)
-    role = 20  # Admin role by default
-    created_at = factory.LazyFunction(timezone.now)
-    updated_at = factory.LazyFunction(timezone.now)