chore: add workspace creation validation

.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

@@ -117,44 +117,6 @@ jobs:
         name: Checkout Files
         uses: actions/checkout@v4
 
-      - name: Get changed files
-        id: changed_files
-        uses: tj-actions/changed-files@v42
-        with:
-          files_yaml: |
-            apiserver:
-              - apiserver/**
-            proxy:
-              - caddy/**
-            admin:
-              - admin/**
-              - packages/**
-              - "package.json"
-              - "yarn.lock"
-              - "tsconfig.json"
-              - "turbo.json"
-            space:
-              - space/**
-              - packages/**
-              - "package.json"
-              - "yarn.lock"
-              - "tsconfig.json"
-              - "turbo.json"
-            web:
-              - web/**
-              - packages/**
-              - "package.json"
-              - "yarn.lock"
-              - "tsconfig.json"
-              - "turbo.json"
-            live:
-              - live/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-
   branch_build_push_admin:
     name: Build-Push Admin Docker Image
     runs-on: ubuntu-22.04
@@ -280,8 +242,8 @@ jobs:
           dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
           docker-image-owner: makeplane
           docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_proxy }}
-          build-context: ./caddy
-          dockerfile-path: ./caddy/Dockerfile
+          build-context: ./nginx
+          dockerfile-path: ./nginx/Dockerfile
           buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
           buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
           buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
@@ -328,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/core/components/auth-header.tsx

@@ -67,8 +67,9 @@ export const InstanceHeader: FC = observer(() => {
         {breadcrumbItems.length >= 0 && (
           <div>
             <Breadcrumbs>
-              <Breadcrumbs.Item
-                component={
+              <Breadcrumbs.BreadcrumbItem
+                type="text"
+                link={
                   <BreadcrumbLink
                     href="/general/"
                     label="Settings"
@@ -79,9 +80,10 @@ export const InstanceHeader: FC = observer(() => {
               {breadcrumbItems.map(
                 (item) =>
                   item.title && (
-                    <Breadcrumbs.Item
+                    <Breadcrumbs.BreadcrumbItem
                       key={item.title}
-                      component={<BreadcrumbLink href={item.href} label={item.title} />}
+                      type="text"
+                      link={<BreadcrumbLink href={item.href} label={item.title} />}
                     />
                   )
               )}

admin/core/components/authentication/auth-banner.tsx

@@ -1,11 +1,11 @@
 import { FC } from "react";
 import { Info, X } from "lucide-react";
 // plane constants
-import { TAdminAuthErrorInfo } from "@plane/constants";
+import { TAuthErrorInfo } from "@plane/constants";
 
 type TAuthBanner = {
-  bannerData: TAdminAuthErrorInfo | undefined;
-  handleBannerData?: (bannerData: TAdminAuthErrorInfo | undefined) => void;
+  bannerData: TAuthErrorInfo | undefined;
+  handleBannerData?: (bannerData: TAuthErrorInfo | undefined) => void;
 };
 
 export const AuthBanner: FC<TAuthBanner> = (props) => {

admin/core/components/login/sign-in-form.tsx

@@ -4,7 +4,7 @@ import { FC, useEffect, useMemo, useState } from "react";
 import { useSearchParams } from "next/navigation";
 import { Eye, EyeOff } from "lucide-react";
 // plane internal packages
-import { API_BASE_URL, EAdminAuthErrorCodes, TAdminAuthErrorInfo } from "@plane/constants";
+import { API_BASE_URL, EAdminAuthErrorCodes, TAuthErrorInfo } from "@plane/constants";
 import { AuthService } from "@plane/services";
 import { Button, Input, Spinner } from "@plane/ui";
 // components
@@ -54,7 +54,7 @@ export const InstanceSignInForm: FC = (props) => {
   const [csrfToken, setCsrfToken] = useState<string | undefined>(undefined);
   const [formData, setFormData] = useState<TFormData>(defaultFromData);
   const [isSubmitting, setIsSubmitting] = useState(false);
-  const [errorInfo, setErrorInfo] = useState<TAdminAuthErrorInfo | undefined>(undefined);
+  const [errorInfo, setErrorInfo] = useState<TAuthErrorInfo | undefined>(undefined);
 
   const handleFormChange = (key: keyof TFormData, value: string | boolean) =>
     setFormData((prev) => ({ ...prev, [key]: value }));

admin/core/lib/auth-helpers.tsx

@@ -3,7 +3,7 @@ import Image from "next/image";
 import Link from "next/link";
 import { KeyRound, Mails } from "lucide-react";
 // plane packages
-import { SUPPORT_EMAIL, EAdminAuthErrorCodes, TAdminAuthErrorInfo } from "@plane/constants";
+import { SUPPORT_EMAIL, EAdminAuthErrorCodes, TAuthErrorInfo } from "@plane/constants";
 import { TGetBaseAuthenticationModeProps, TInstanceAuthenticationModes } from "@plane/types";
 import { resolveGeneralTheme } from "@plane/utils";
 // components
@@ -89,7 +89,7 @@ const errorCodeMessages: {
 export const authErrorHandler = (
   errorCode: EAdminAuthErrorCodes,
   email?: string | undefined
-): TAdminAuthErrorInfo | undefined => {
+): TAuthErrorInfo | undefined => {
   const bannerAlertErrorCodes = [
     EAdminAuthErrorCodes.ADMIN_ALREADY_EXIST,
     EAdminAuthErrorCodes.REQUIRED_ADMIN_EMAIL_PASSWORD_FIRST_NAME,

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": {
@@ -31,7 +31,7 @@
     "lucide-react": "^0.469.0",
     "mobx": "^6.12.0",
     "mobx-react": "^9.1.1",
-    "next": "14.2.30",
+    "next": "^14.2.28",
     "next-themes": "^0.2.1",
     "postcss": "^8.4.38",
     "react": "^18.3.1",
@@ -50,6 +50,6 @@
     "@types/react-dom": "^18.2.18",
     "@types/uuid": "^9.0.8",
     "@types/zxcvbn": "^4.4.4",
-    "typescript": "5.8.3"
+    "typescript": "5.3.3"
   }
 }

aio/Dockerfile-app

@@ -11,7 +11,7 @@ WORKDIR /app
 RUN yarn global add turbo
 COPY . .
 
-RUN turbo prune --scope=web --scope=space --scope=admin --scope=live --docker
+RUN turbo prune --scope=web --scope=space --scope=admin --docker
 
 # *****************************************************************************
 # STAGE 2: Install dependencies & build the project
@@ -53,7 +53,7 @@ ENV NEXT_PUBLIC_WEB_BASE_URL=$NEXT_PUBLIC_WEB_BASE_URL
 ENV NEXT_TELEMETRY_DISABLED=1
 ENV TURBO_TELEMETRY_DISABLED=1
 
-RUN yarn turbo run build --filter=web --filter=space --filter=admin --filter=live
+RUN yarn turbo run build --filter=web --filter=space --filter=admin
 
 # *****************************************************************************
 # STAGE 3: Copy the project and start it
@@ -87,8 +87,6 @@ RUN chmod +x ./api/bin/*
 RUN chmod -R 777 ./api/
 
 # NEXTJS BUILDS
-COPY --from=installer /app/node_modules ./node_modules/
-
 COPY --from=installer /app/web/next.config.js ./web/
 COPY --from=installer /app/web/package.json ./web/
 COPY --from=installer /app/web/.next/standalone ./web
@@ -107,10 +105,6 @@ COPY --from=installer /app/admin/.next/standalone ./admin
 COPY --from=installer /app/admin/.next/static ./admin/admin/.next/static
 COPY --from=installer /app/admin/public ./admin/admin/public
 
-COPY --from=installer /app/live/package.json ./live/
-COPY --from=installer /app/live/dist ./live/dist
-# COPY --from=installer /app/live/node_modules ./live/node_modules
-
 ARG NEXT_PUBLIC_API_BASE_URL=""
 ENV NEXT_PUBLIC_API_BASE_URL=$NEXT_PUBLIC_API_BASE_URL
 

aio/nginx.conf

@@ -45,14 +45,6 @@ http {
             proxy_pass http://localhost:3003/god-mode/;
         }
 
-        location /live/ {
-            proxy_http_version 1.1;
-            proxy_set_header Upgrade ${dollar}http_upgrade;
-            proxy_set_header Connection "upgrade";
-            proxy_set_header Host ${dollar}http_host;
-            proxy_pass http://localhost:3004/;
-        }
-
         location /api/ {
             proxy_http_version 1.1;
             proxy_set_header Upgrade ${dollar}http_upgrade;

aio/supervisord-app

@@ -29,16 +29,6 @@ stderr_logfile=/dev/stdout
 stderr_logfile_maxbytes=0
 environment=PORT=3003,HOSTNAME=0.0.0.0
 
-[program:live]
-command=node /app/live/dist/server.js
-autostart=true
-autorestart=true
-stdout_logfile=/dev/stdout
-stdout_logfile_maxbytes=0
-stderr_logfile=/dev/stdout
-stderr_logfile_maxbytes=0
-environment=PORT=3004,HOSTNAME=0.0.0.0,API_BASE_URL="http://localhost:8000"
-
 [program:migrator]
 directory=/app/api
 command=sh -c "./bin/docker-entrypoint-migrator.sh"

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/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/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,21 +3,17 @@ 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 plane.utils.url import clean_value
 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
+        return clean_value(value)
 
     def validate_last_name(self, value):
-        if contains_url(value):
-            raise serializers.ValidationError("Last name cannot contain a URL.")
-        return value
+        return clean_value(value)
 
     class Meta:
         model = User
@@ -110,16 +106,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

@@ -1,3 +1,9 @@
+# Django imports
+from django.core.validators import URLValidator
+from django.core.exceptions import ValidationError
+from django.template.defaultfilters import slugify
+
+
 # Third party imports
 from rest_framework import serializers
 
@@ -23,12 +29,7 @@ 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
+from plane.utils.url import clean_value
 
 
 class WorkSpaceSerializer(DynamicBaseSerializer):
@@ -36,22 +37,34 @@ 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
+
+        # Clean the slug
+        slug = clean_value(value)
+
+        # If the slug is empty, return an error
+        if not slug:
+            raise serializers.ValidationError("Slug cannot be empty")
+
+        # Slugify the slug
+        slug = slugify(slug)
+
+        # Return the slug
+        return slug
+
+    def validate_name(self, value):
+        # Clean the name
+        name = clean_value(value)
+
+        # If the name is empty, return an error
+        if not name:
+            raise serializers.ValidationError("Name cannot be empty")
+
+        # Return the name
+        return name
 
     class Meta:
         model = Workspace
@@ -196,7 +209,6 @@ class WorkspaceUserLinkSerializer(BaseSerializer):
 
 class IssueRecentVisitSerializer(serializers.ModelSerializer):
     project_identifier = serializers.SerializerMethodField()
-    assignees = serializers.SerializerMethodField()
 
     class Meta:
         model = Issue
@@ -214,14 +226,8 @@ class IssueRecentVisitSerializer(serializers.ModelSerializer):
 
     def get_project_identifier(self, obj):
         project = obj.project
-        return project.identifier if project else None
 
-    def get_assignees(self, obj):
-        return list(
-            obj.assignees.filter(issue_assignee__deleted_at__isnull=True).values_list(
-                "id", flat=True
-            )
-        )
+        return project.identifier if project else None
 
 
 class ProjectRecentVisitSerializer(serializers.ModelSerializer):

apiserver/plane/app/urls/analytic.py

@@ -11,9 +11,6 @@ from plane.app.views import (
     AdvanceAnalyticsChartEndpoint,
     DefaultAnalyticsEndpoint,
     ProjectStatsEndpoint,
-    ProjectAdvanceAnalyticsEndpoint,
-    ProjectAdvanceAnalyticsStatsEndpoint,
-    ProjectAdvanceAnalyticsChartEndpoint,
 )
 
 
@@ -70,19 +67,4 @@ urlpatterns = [
         AdvanceAnalyticsChartEndpoint.as_view(),
         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",
-    ),
 ]

apiserver/plane/app/urls/api.py

@@ -4,14 +4,14 @@ from plane.app.views import ApiTokenEndpoint, ServiceApiTokenEndpoint
 urlpatterns = [
     # API Tokens
     path(
-        "users/api-tokens/",
+        "workspaces/<str:slug>/api-tokens/",
         ApiTokenEndpoint.as_view(),
         name="api-tokens",
     ),
     path(
-        "users/api-tokens/<uuid:pk>/",
+        "workspaces/<str:slug>/api-tokens/<uuid:pk>/",
         ApiTokenEndpoint.as_view(),
-        name="api-tokens-details",
+        name="api-tokens",
     ),
     path(
         "workspaces/<str:slug>/service-api-tokens/",

apiserver/plane/app/urls/asset.py

@@ -12,9 +12,6 @@ from plane.app.views import (
     AssetRestoreEndpoint,
     ProjectAssetEndpoint,
     ProjectBulkAssetEndpoint,
-    AssetCheckEndpoint,
-    WorkspaceAssetDownloadEndpoint,
-    ProjectAssetDownloadEndpoint,
 )
 
 
@@ -84,21 +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",
-    ),
-    path(
-        "assets/v2/workspaces/<str:slug>/download/<uuid:asset_id>/",
-        WorkspaceAssetDownloadEndpoint.as_view(),
-        name="workspace-asset-download",
-    ),
-    path(
-        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/download/<uuid:asset_id>/",
-        ProjectAssetDownloadEndpoint.as_view(),
-        name="project-asset-download",
     ),
 ]

apiserver/plane/app/views/__init__.py

@@ -106,9 +106,6 @@ from .asset.v2 import (
     AssetRestoreEndpoint,
     ProjectAssetEndpoint,
     ProjectBulkAssetEndpoint,
-    AssetCheckEndpoint,
-    WorkspaceAssetDownloadEndpoint,
-    ProjectAssetDownloadEndpoint,
 )
 from .issue.base import (
     IssueListEndpoint,
@@ -208,12 +205,6 @@ from .analytic.advance import (
     AdvanceAnalyticsChartEndpoint,
 )
 
-from .analytic.project_analytics import (
-    ProjectAdvanceAnalyticsEndpoint,
-    ProjectAdvanceAnalyticsStatsEndpoint,
-    ProjectAdvanceAnalyticsChartEndpoint,
-)
-
 from .notification.base import (
     NotificationViewSet,
     UnreadNotificationEndpoint,

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

@@ -5,6 +5,7 @@ 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 (
@@ -18,8 +19,10 @@ from plane.db.models import (
     Workspace,
     CycleIssue,
     ModuleIssue,
-    ProjectMember,
 )
+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,
@@ -72,27 +75,32 @@ class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
         }
 
     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 +113,30 @@ 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"])
+    def get_work_items_stats(
+        self, 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"])
 
         return {
             "total_work_items": self.get_filtered_counts(base_queryset),
@@ -140,8 +165,11 @@ class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
                 status=status.HTTP_200_OK,
             )
         elif tab == "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(),
+                self.get_work_items_stats(cycle_id=cycle_id, module_id=module_id),
                 status=status.HTTP_200_OK,
             )
         return Response({"message": "Invalid tab"}, status=status.HTTP_400_BAD_REQUEST)
@@ -160,21 +188,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")),
@@ -185,14 +199,100 @@ class AdvanceAnalyticsStatsEndpoint(AdvanceAnalyticsBaseView):
             .order_by("project_id")
         )
 
+    def get_work_items_stats(
+        self, cycle_id=None, module_id=None, peek_view=False
+    ) -> 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)
+        elif peek_view:
+            base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+        else:
+            base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+            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")
+            )
+
+        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], level="WORKSPACE")
     def get(self, request: HttpRequest, slug: 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)
+            peek_view = request.GET.get("peek_view", False)
             return Response(
-                self.get_work_items_stats(),
+                self.get_work_items_stats(
+                    cycle_id=cycle_id, module_id=module_id, peek_view=peek_view
+                ),
                 status=status.HTTP_200_OK,
             )
 
@@ -252,7 +352,9 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
             for key, value in data.items()
         ]
 
-    def work_item_completion_chart(self) -> Dict[str, Any]:
+    def work_item_completion_chart(
+        self, cycle_id=None, module_id=None, peek_view=False
+    ) -> Dict[str, Any]:
         # Get the base queryset
         queryset = (
             Issue.issue_objects.filter(**self.filters["base_filters"])
@@ -262,62 +364,143 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
             )
         )
 
-        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"]
-            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
-                )
+        if cycle_id is not None and peek_view:
+            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:
-                current_month = current_month.replace(month=current_month.month + 1)
+                return {"data": [], "schema": {}}
+            queryset = cycle_issues
+        elif module_id is not None and peek_view:
+            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
+        elif peek_view:
+            project_ids_str = self.request.GET.get("project_ids")
+            if project_ids_str:
+                project_id_list = [
+                    pid.strip() for pid in project_ids_str.split(",") if pid.strip()
+                ]
+            else:
+                project_id_list = []
+                return {"data": [], "schema": {}}
+            project_id = project_id_list[0]
+            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": {}}
+        else:
+            workspace = Workspace.objects.get(slug=self._workspace_slug)
+            start_date = workspace.created_at.date().replace(day=1)
+
+        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",
@@ -332,6 +515,8 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
         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 == "projects":
             return Response(self.project_chart(), status=status.HTTP_200_OK)
@@ -345,6 +530,19 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
                 )
             )
 
+            # 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"]
@@ -358,8 +556,14 @@ class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
             )
 
         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)
+            peek_view = request.GET.get("peek_view", False)
             return Response(
-                self.work_item_completion_chart(),
+                self.work_item_completion_chart(
+                    cycle_id=cycle_id, module_id=module_id, peek_view=peek_view
+                ),
                 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/api.py

@@ -1,10 +1,8 @@
 # Python import
 from uuid import uuid4
-from typing import Optional
 
 # Third party
 from rest_framework.response import Response
-from rest_framework.request import Request
 from rest_framework import status
 
 # Module import
@@ -15,9 +13,12 @@ from plane.app.permissions import WorkspaceEntityPermission
 
 
 class ApiTokenEndpoint(BaseAPIView):
-    def post(self, request: Request) -> Response:
+    permission_classes = [WorkspaceEntityPermission]
+
+    def post(self, request, slug):
         label = request.data.get("label", str(uuid4().hex))
         description = request.data.get("description", "")
+        workspace = Workspace.objects.get(slug=slug)
         expired_at = request.data.get("expired_at", None)
 
         # Check the user type
@@ -27,6 +28,7 @@ class ApiTokenEndpoint(BaseAPIView):
             label=label,
             description=description,
             user=request.user,
+            workspace=workspace,
             user_type=user_type,
             expired_at=expired_at,
         )
@@ -35,23 +37,29 @@ class ApiTokenEndpoint(BaseAPIView):
         # Token will be only visible while creating
         return Response(serializer.data, status=status.HTTP_201_CREATED)
 
-    def get(self, request: Request, pk: Optional[str] = None) -> Response:
+    def get(self, request, slug, pk=None):
         if pk is None:
-            api_tokens = APIToken.objects.filter(user=request.user, is_service=False)
+            api_tokens = APIToken.objects.filter(
+                user=request.user, workspace__slug=slug, is_service=False
+            )
             serializer = APITokenReadSerializer(api_tokens, many=True)
             return Response(serializer.data, status=status.HTTP_200_OK)
         else:
-            api_tokens = APIToken.objects.get(user=request.user, pk=pk)
+            api_tokens = APIToken.objects.get(
+                user=request.user, workspace__slug=slug, pk=pk
+            )
             serializer = APITokenReadSerializer(api_tokens)
             return Response(serializer.data, status=status.HTTP_200_OK)
 
-    def delete(self, request: Request, pk: str) -> Response:
-        api_token = APIToken.objects.get(user=request.user, pk=pk, is_service=False)
+    def delete(self, request, slug, pk):
+        api_token = APIToken.objects.get(
+            workspace__slug=slug, user=request.user, pk=pk, is_service=False
+        )
         api_token.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-    def patch(self, request: Request, pk: str) -> Response:
-        api_token = APIToken.objects.get(user=request.user, pk=pk)
+    def patch(self, request, slug, pk):
+        api_token = APIToken.objects.get(workspace__slug=slug, user=request.user, pk=pk)
         serializer = APITokenSerializer(api_token, data=request.data, partial=True)
         if serializer.is_valid():
             serializer.save()
@@ -62,7 +70,7 @@ class ApiTokenEndpoint(BaseAPIView):
 class ServiceApiTokenEndpoint(BaseAPIView):
     permission_classes = [WorkspaceEntityPermission]
 
-    def post(self, request: Request, slug: str) -> Response:
+    def post(self, request, slug):
         workspace = Workspace.objects.get(slug=slug)
 
         api_token = APIToken.objects.filter(

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

@@ -707,67 +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)
-
-
-class WorkspaceAssetDownloadEndpoint(BaseAPIView):
-    """Endpoint to generate a download link for an asset with content-disposition=attachment."""
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
-    def get(self, request, slug, asset_id):
-        try:
-            asset = FileAsset.objects.get(
-                id=asset_id,
-                workspace__slug=slug,
-                is_uploaded=True,
-            )
-        except FileAsset.DoesNotExist:
-            return Response(
-                {"error": "The requested asset could not be found."},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-
-        storage = S3Storage(request=request)
-        signed_url = storage.generate_presigned_url(
-            object_name=asset.asset.name,
-            disposition=f"attachment; filename={asset.asset.name}",
-        )
-
-        return HttpResponseRedirect(signed_url)
-
-
-class ProjectAssetDownloadEndpoint(BaseAPIView):
-    """Endpoint to generate a download link for an asset with content-disposition=attachment."""
-
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="PROJECT")
-    def get(self, request, slug, project_id, asset_id):
-        try:
-            asset = FileAsset.objects.get(
-                id=asset_id,
-                workspace__slug=slug,
-                project_id=project_id,
-                is_uploaded=True,
-            )
-        except FileAsset.DoesNotExist:
-            return Response(
-                {"error": "The requested asset could not be found."},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-
-        storage = S3Storage(request=request)
-        signed_url = storage.generate_presigned_url(
-            object_name=asset.asset.name,
-            disposition=f"attachment; filename={asset.asset.name}",
-        )
-
-        return HttpResponseRedirect(signed_url)

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

@@ -944,33 +944,9 @@ class IssueDetailEndpoint(BaseAPIView):
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
     def get(self, request, slug, project_id):
         filters = issue_filters(request.query_params, "GET")
-
-        # check for the project member role, if the role is 5 then check for the guest_view_all_features
-        #  if it is true then show all the issues else show only the issues created by the user
-        project_member_subquery = ProjectMember.objects.filter(
-            project_id=OuterRef("project_id"),
-            member=self.request.user,
-            is_active=True,
-        ).filter(
-            Q(role__gt=ROLE.GUEST.value) 
-            | Q(
-                role=ROLE.GUEST.value, project__guest_view_all_features=True
-            )
-        )
-
-        # Main issue query
         issue = (
             Issue.issue_objects.filter(workspace__slug=slug, project_id=project_id)
-            .filter(
-                Q(Exists(project_member_subquery))
-                | Q(
-                    project__project_projectmember__member=self.request.user,
-                    project__project_projectmember__is_active=True,
-                    project__project_projectmember__role=ROLE.GUEST.value,
-                    project__guest_view_all_features=False,
-                    created_by=self.request.user,
-                )
-            )
+            .select_related("workspace", "project", "state", "parent")
             .prefetch_related("assignees", "labels", "issue_module__module")
             .annotate(
                 cycle_id=Subquery(
@@ -1038,7 +1014,6 @@ class IssueDetailEndpoint(BaseAPIView):
                 .values("count")
             )
         )
-
         issue = issue.filter(**filters)
         order_by_param = request.GET.get("order_by", "-created_at")
         # Issue queryset

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

@@ -15,7 +15,6 @@ 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
 
 
@@ -45,9 +44,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 +55,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 +66,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 +80,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/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,
             )
 
@@ -451,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/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/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):
@@ -95,8 +92,6 @@ class WorkSpaceViewSet(BaseViewSet):
                     status=status.HTTP_403_FORBIDDEN,
                 )
 
-            serializer = WorkSpaceSerializer(data=request.data)
-
             slug = request.data.get("slug", False)
             name = request.data.get("name", False)
 
@@ -112,11 +107,8 @@ 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,
-                )
+            # Validate the serializer
+            serializer = WorkSpaceSerializer(data=request.data)
 
             if serializer.is_valid(raise_exception=True):
                 serializer.save(owner=request.user)
@@ -159,18 +151,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 +160,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/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/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/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/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/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/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/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/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/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/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,120 +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 create_bot_user(db):
-    """Create and return a bot user instance"""
-    from uuid import uuid4
-
-    unique_id = uuid4().hex[:8]
-    user = User.objects.create(
-        email=f"bot-{unique_id}@plane.so",
-        username=f"bot_user_{unique_id}",
-        first_name="Bot",
-        last_name="User",
-        is_bot=True,
-    )
-    user.set_password("bot@123")
-    user.save()
-    return user
-
-
-@pytest.fixture
-def api_token_data():
-    """Return sample API token data for testing"""
-    from django.utils import timezone
-    from datetime import timedelta
-
-    return {
-        "label": "Test API Token",
-        "description": "Test description for API token",
-        "expired_at": (timezone.now() + timedelta(days=30)).isoformat(),
-    }
-
-
-@pytest.fixture
-def create_api_token_for_user(db, create_user):
-    """Create and return an API token for a specific user"""
-    return APIToken.objects.create(
-        label="Test Token",
-        description="Test token description",
-        user=create_user,
-        user_type=0,
-    )
-
-
-@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_api_token.py

@@ -1,372 +0,0 @@
-import pytest
-from datetime import timedelta
-from uuid import uuid4
-from django.urls import reverse
-from django.utils import timezone
-from rest_framework import status
-
-from plane.db.models import APIToken, User
-
-
-@pytest.mark.contract
-class TestApiTokenEndpoint:
-    """Test cases for ApiTokenEndpoint"""
-
-    # POST /user/api-tokens/ tests
-    @pytest.mark.django_db
-    def test_create_api_token_success(
-        self, session_client, create_user, api_token_data
-    ):
-        """Test successful API token creation"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens")
-
-        # Act
-        response = session_client.post(url, api_token_data, format="json")
-
-        # Assert
-        assert response.status_code == status.HTTP_201_CREATED
-        assert "token" in response.data
-        assert response.data["label"] == api_token_data["label"]
-        assert response.data["description"] == api_token_data["description"]
-        assert response.data["user_type"] == 0  # Human user
-
-        # Verify token was created in database
-        token = APIToken.objects.get(pk=response.data["id"])
-        assert token.user == create_user
-        assert token.label == api_token_data["label"]
-
-    @pytest.mark.django_db
-    def test_create_api_token_for_bot_user(
-        self, session_client, create_bot_user, api_token_data
-    ):
-        """Test API token creation for bot user"""
-        # Arrange
-        session_client.force_authenticate(user=create_bot_user)
-        url = reverse("api-tokens")
-
-        # Act
-        response = session_client.post(url, api_token_data, format="json")
-
-        # Assert
-        assert response.status_code == status.HTTP_201_CREATED
-        assert response.data["user_type"] == 1  # Bot user
-
-    @pytest.mark.django_db
-    def test_create_api_token_minimal_data(self, session_client, create_user):
-        """Test API token creation with minimal data"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens")
-
-        # Act
-        response = session_client.post(url, {}, format="json")
-
-        # Assert
-        assert response.status_code == status.HTTP_201_CREATED
-        assert "token" in response.data
-        assert len(response.data["label"]) == 32  # UUID hex length
-        assert response.data["description"] == ""
-
-    @pytest.mark.django_db
-    def test_create_api_token_with_expiry(self, session_client, create_user):
-        """Test API token creation with expiry date"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens")
-        future_date = timezone.now() + timedelta(days=30)
-        data = {"label": "Expiring Token", "expired_at": future_date.isoformat()}
-
-        # Act
-        response = session_client.post(url, data, format="json")
-
-        # Assert
-        assert response.status_code == status.HTTP_201_CREATED
-
-        # Verify expiry date was set
-        token = APIToken.objects.get(pk=response.data["id"])
-        assert token.expired_at is not None
-
-    @pytest.mark.django_db
-    def test_create_api_token_unauthenticated(self, api_client, api_token_data):
-        """Test API token creation without authentication"""
-        # Arrange
-        url = reverse("api-tokens")
-
-        # Act
-        response = api_client.post(url, api_token_data, format="json")
-
-        # Assert
-        assert response.status_code == status.HTTP_401_UNAUTHORIZED
-
-    # GET /user/api-tokens/ tests
-    @pytest.mark.django_db
-    def test_get_all_api_tokens(self, session_client, create_user):
-        """Test retrieving all API tokens for user"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-
-        # Create multiple tokens
-        APIToken.objects.create(label="Token 1", user=create_user, user_type=0)
-        APIToken.objects.create(label="Token 2", user=create_user, user_type=0)
-        # Create a service token (should be excluded)
-        APIToken.objects.create(
-            label="Service Token", user=create_user, user_type=0, is_service=True
-        )
-        url = reverse("api-tokens")
-
-        # Act
-        response = session_client.get(url)
-
-        # Assert
-        assert response.status_code == status.HTTP_200_OK
-        assert len(response.data) == 2  # Only non-service tokens
-        assert all(token["is_service"] is False for token in response.data)
-
-    @pytest.mark.django_db
-    def test_get_empty_api_tokens_list(self, session_client, create_user):
-        """Test retrieving API tokens when none exist"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens")
-
-        # Act
-        response = session_client.get(url)
-
-        # Assert
-        assert response.status_code == status.HTTP_200_OK
-        assert response.data == []
-
-    # GET /user/api-tokens/<pk>/ tests
-    @pytest.mark.django_db
-    def test_get_specific_api_token(
-        self, session_client, create_user, create_api_token_for_user
-    ):
-        """Test retrieving a specific API token"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens", kwargs={"pk": create_api_token_for_user.pk})
-
-        # Act
-        response = session_client.get(url)
-
-        # Assert
-        assert response.status_code == status.HTTP_200_OK
-        assert str(response.data["id"]) == str(create_api_token_for_user.pk)
-        assert response.data["label"] == create_api_token_for_user.label
-        assert (
-            "token" not in response.data
-        )  # Token should not be visible in read serializer
-
-    @pytest.mark.django_db
-    def test_get_nonexistent_api_token(self, session_client, create_user):
-        """Test retrieving a non-existent API token"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        fake_pk = uuid4()
-        url = reverse("api-tokens", kwargs={"pk": fake_pk})
-
-        # Act
-        response = session_client.get(url)
-
-        # Assert
-        assert response.status_code == status.HTTP_404_NOT_FOUND
-
-    @pytest.mark.django_db
-    def test_get_other_users_api_token(self, session_client, create_user, db):
-        """Test retrieving another user's API token (should fail)"""
-        # Arrange
-        # Create another user and their token with unique email and username
-        unique_id = uuid4().hex[:8]
-        unique_email = f"other-{unique_id}@plane.so"
-        unique_username = f"other_user_{unique_id}"
-        other_user = User.objects.create(email=unique_email, username=unique_username)
-        other_token = APIToken.objects.create(
-            label="Other Token", user=other_user, user_type=0
-        )
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens", kwargs={"pk": other_token.pk})
-
-        # Act
-        response = session_client.get(url)
-
-        # Assert
-        assert response.status_code == status.HTTP_404_NOT_FOUND
-
-    # DELETE /user/api-tokens/<pk>/ tests
-    @pytest.mark.django_db
-    def test_delete_api_token_success(
-        self, session_client, create_user, create_api_token_for_user
-    ):
-        """Test successful API token deletion"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens", kwargs={"pk": create_api_token_for_user.pk})
-
-        # Act
-        response = session_client.delete(url)
-
-        # Assert
-        assert response.status_code == status.HTTP_204_NO_CONTENT
-        assert not APIToken.objects.filter(pk=create_api_token_for_user.pk).exists()
-
-    @pytest.mark.django_db
-    def test_delete_nonexistent_api_token(self, session_client, create_user):
-        """Test deleting a non-existent API token"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        fake_pk = uuid4()
-        url = reverse("api-tokens", kwargs={"pk": fake_pk})
-
-        # Act
-        response = session_client.delete(url)
-
-        # Assert
-        assert response.status_code == status.HTTP_404_NOT_FOUND
-
-    @pytest.mark.django_db
-    def test_delete_other_users_api_token(self, session_client, create_user, db):
-        """Test deleting another user's API token (should fail)"""
-        # Arrange
-        # Create another user and their token with unique email and username
-        unique_id = uuid4().hex[:8]
-        unique_email = f"delete-other-{unique_id}@plane.so"
-        unique_username = f"delete_other_user_{unique_id}"
-        other_user = User.objects.create(email=unique_email, username=unique_username)
-        other_token = APIToken.objects.create(
-            label="Other Token", user=other_user, user_type=0
-        )
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens", kwargs={"pk": other_token.pk})
-
-        # Act
-        response = session_client.delete(url)
-
-        # Assert
-        assert response.status_code == status.HTTP_404_NOT_FOUND
-        # Verify token still exists
-        assert APIToken.objects.filter(pk=other_token.pk).exists()
-
-    @pytest.mark.django_db
-    def test_delete_service_api_token_forbidden(self, session_client, create_user):
-        """Test deleting a service API token (should fail)"""
-        # Arrange
-        service_token = APIToken.objects.create(
-            label="Service Token", user=create_user, user_type=0, is_service=True
-        )
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens", kwargs={"pk": service_token.pk})
-
-        # Act
-        response = session_client.delete(url)
-
-        # Assert
-        assert response.status_code == status.HTTP_404_NOT_FOUND
-        # Verify token still exists
-        assert APIToken.objects.filter(pk=service_token.pk).exists()
-
-    # PATCH /user/api-tokens/<pk>/ tests
-    @pytest.mark.django_db
-    def test_patch_api_token_success(
-        self, session_client, create_user, create_api_token_for_user
-    ):
-        """Test successful API token update"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens", kwargs={"pk": create_api_token_for_user.pk})
-        update_data = {
-            "label": "Updated Token Label",
-            "description": "Updated description",
-        }
-
-        # Act
-        response = session_client.patch(url, update_data, format="json")
-
-        # Assert
-        assert response.status_code == status.HTTP_200_OK
-        assert response.data["label"] == update_data["label"]
-        assert response.data["description"] == update_data["description"]
-
-        # Verify database was updated
-        create_api_token_for_user.refresh_from_db()
-        assert create_api_token_for_user.label == update_data["label"]
-        assert create_api_token_for_user.description == update_data["description"]
-
-    @pytest.mark.django_db
-    def test_patch_api_token_partial_update(
-        self, session_client, create_user, create_api_token_for_user
-    ):
-        """Test partial API token update"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens", kwargs={"pk": create_api_token_for_user.pk})
-        original_description = create_api_token_for_user.description
-        update_data = {"label": "Only Label Updated"}
-
-        # Act
-        response = session_client.patch(url, update_data, format="json")
-
-        # Assert
-        assert response.status_code == status.HTTP_200_OK
-        assert response.data["label"] == update_data["label"]
-        assert response.data["description"] == original_description
-
-    @pytest.mark.django_db
-    def test_patch_nonexistent_api_token(self, session_client, create_user):
-        """Test updating a non-existent API token"""
-        # Arrange
-        session_client.force_authenticate(user=create_user)
-        fake_pk = uuid4()
-        url = reverse("api-tokens", kwargs={"pk": fake_pk})
-        update_data = {"label": "New Label"}
-
-        # Act
-        response = session_client.patch(url, update_data, format="json")
-
-        # Assert
-        assert response.status_code == status.HTTP_404_NOT_FOUND
-
-    @pytest.mark.django_db
-    def test_patch_other_users_api_token(self, session_client, create_user, db):
-        """Test updating another user's API token (should fail)"""
-        # Arrange
-        # Create another user and their token with unique email and username
-        unique_id = uuid4().hex[:8]
-        unique_email = f"patch-other-{unique_id}@plane.so"
-        unique_username = f"patch_other_user_{unique_id}"
-        other_user = User.objects.create(email=unique_email, username=unique_username)
-        other_token = APIToken.objects.create(
-            label="Other Token", user=other_user, user_type=0
-        )
-        session_client.force_authenticate(user=create_user)
-        url = reverse("api-tokens", kwargs={"pk": other_token.pk})
-        update_data = {"label": "Hacked Label"}
-
-        # Act
-        response = session_client.patch(url, update_data, format="json")
-
-        # Assert
-        assert response.status_code == status.HTTP_404_NOT_FOUND
-
-        # Verify token was not updated
-        other_token.refresh_from_db()
-        assert other_token.label == "Other Token"
-
-    # Authentication tests
-    @pytest.mark.django_db
-    def test_all_endpoints_require_authentication(self, api_client):
-        """Test that all endpoints require authentication"""
-        # Arrange
-        endpoints = [
-            (reverse("api-tokens"), "get"),
-            (reverse("api-tokens"), "post"),
-            (reverse("api-tokens", kwargs={"pk": uuid4()}), "get"),
-            (reverse("api-tokens", kwargs={"pk": uuid4()}), "patch"),
-            (reverse("api-tokens", kwargs={"pk": uuid4()}), "delete"),
-        ]
-
-        # Act & Assert
-        for url, method in endpoints:
-            response = getattr(api_client, method)(url)
-            assert response.status_code == status.HTTP_401_UNAUTHORIZED

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)

apiserver/plane/tests/smoke/test_auth_smoke.py

@@ -1,100 +0,0 @@
-import pytest
-import requests
-from django.urls import reverse
-
-
-@pytest.mark.smoke
-class TestAuthSmoke:
-    """Smoke tests for authentication endpoints"""
-
-    @pytest.mark.django_db
-    def test_login_endpoint_available(self, plane_server, create_user, user_data):
-        """Test that the login endpoint is available and responds correctly"""
-        # Get the sign-in URL
-        relative_url = reverse("sign-in")
-        url = f"{plane_server.url}{relative_url}"
-
-        # 1. Test bad login - test with wrong password
-        response = requests.post(
-            url,
-            data={
-                "email": user_data["email"],
-                "password": "wrong-password"
-            }
-        )
-
-        # For bad credentials, any of these status codes would be valid
-        # The test shouldn't be brittle to minor implementation changes
-        assert response.status_code != 500, "Authentication should not cause server errors"
-        assert response.status_code != 404, "Authentication endpoint should exist"
-
-        if response.status_code == 200:
-            # If API returns 200 for failures, check the response body for error indication
-            if hasattr(response, 'json'):
-                try:
-                    data = response.json()
-                    # JSON response might indicate error in its structure
-                    assert "error" in data or "error_code" in data or "detail" in data or response.url.endswith("sign-in"), \
-                        "Error response should contain error details"
-                except ValueError:
-                    # It's ok if response isn't JSON format
-                    pass
-        elif response.status_code in [302, 303]:
-            # If it's a redirect, it should redirect to a login page or error page
-            redirect_url = response.headers.get('Location', '')
-            assert "error" in redirect_url or "sign-in" in redirect_url, \
-                "Failed login should redirect to login page or error page"
-
-        # 2. Test good login with correct credentials
-        response = requests.post(
-            url,
-            data={
-                "email": user_data["email"],
-                "password": user_data["password"]
-            },
-            allow_redirects=False  # Don't follow redirects
-        )
-
-        # Successful auth should not be a client error or server error
-        assert response.status_code not in range(400, 600), \
-            f"Authentication with valid credentials failed with status {response.status_code}"
-
-        # Specific validation based on response type
-        if response.status_code in [302, 303]:
-            # Redirect-based auth: check that redirect URL doesn't contain error
-            redirect_url = response.headers.get('Location', '')
-            assert "error" not in redirect_url and "error_code" not in redirect_url, \
-                "Successful login redirect should not contain error parameters"
-
-        elif response.status_code == 200:
-            # API token-based auth: check for tokens or user session
-            if hasattr(response, 'json'):
-                try:
-                    data = response.json()
-                    # If it's a token response
-                    if "access_token" in data:
-                        assert "refresh_token" in data, "JWT auth should return both access and refresh tokens"
-                    # If it's a user session response
-                    elif "user" in data:
-                        assert "is_authenticated" in data and data["is_authenticated"], \
-                            "User session response should indicate authentication"
-                    # Otherwise it should at least indicate success
-                    else:
-                        assert not any(error_key in data for error_key in ["error", "error_code", "detail"]), \
-                            "Success response should not contain error keys"
-                except ValueError:
-                    # Non-JSON is acceptable if it's a redirect or HTML response
-                    pass
-
-
-@pytest.mark.smoke
-class TestHealthCheckSmoke:
-    """Smoke test for health check endpoint"""
-
-    def test_healthcheck_endpoint(self, plane_server):
-        """Test that the health check endpoint is available and responds correctly"""
-        # Make a request to the health check endpoint
-        response = requests.get(f"{plane_server.url}/")
-
-        # Should be OK
-        assert response.status_code == 200, "Health check endpoint should return 200 OK"

apiserver/plane/tests/unit/models/test_workspace_model.py

@@ -1,50 +0,0 @@
-import pytest
-from uuid import uuid4
-
-from plane.db.models import Workspace, WorkspaceMember, User
-
-
-@pytest.mark.unit
-class TestWorkspaceModel:
-    """Test the Workspace model"""
-
-    @pytest.mark.django_db
-    def test_workspace_creation(self, create_user):
-        """Test creating a workspace"""
-        # Create a workspace
-        workspace = Workspace.objects.create(
-            name="Test Workspace",
-            slug="test-workspace",
-            id=uuid4(),
-            owner=create_user
-        )
-
-        # Verify it was created
-        assert workspace.id is not None
-        assert workspace.name == "Test Workspace"
-        assert workspace.slug == "test-workspace"
-        assert workspace.owner == create_user
-
-    @pytest.mark.django_db
-    def test_workspace_member_creation(self, create_user):
-        """Test creating a workspace member"""
-        # Create a workspace
-        workspace = Workspace.objects.create(
-            name="Test Workspace",
-            slug="test-workspace",
-            id=uuid4(),
-            owner=create_user
-        )
-
-        # Create a workspace member
-        workspace_member = WorkspaceMember.objects.create(
-            workspace=workspace,
-            member=create_user,
-            role=20  # Admin role
-        )
-
-        # Verify it was created
-        assert workspace_member.id is not None
-        assert workspace_member.workspace == workspace
-        assert workspace_member.member == create_user
-        assert workspace_member.role == 20

apiserver/plane/tests/unit/serializers/test_issue_recent_visit.py

@@ -1,75 +0,0 @@
-import pytest
-
-from plane.db.models import (
-    Workspace,
-    Project,
-    Issue,
-    User,
-    IssueAssignee,
-    WorkspaceMember,
-    ProjectMember,
-)
-from plane.app.serializers.workspace import IssueRecentVisitSerializer
-from django.utils import timezone
-
-
-@pytest.mark.unit
-class TestIssueRecentVisitSerializer:
-    """Test the IssueRecentVisitSerializer"""
-
-    def test_issue_recent_visit_serializer_fields(self, db):
-        """Test that the serializer includes the correct fields"""
-
-        test_user_1 = User.objects.create(
-            email="test_user_1@example.com", first_name="Test", last_name="User"
-        )
-
-        # To test for deleted issue assignee
-        test_user_2 = User.objects.create(
-            email="test_user_2@example.com",
-            first_name="Other",
-            last_name="User",
-            username="some user name",
-        )
-
-        workspace = Workspace.objects.create(
-            name="Test Workspace", slug="test-workspace", owner=test_user_1
-        )
-
-        WorkspaceMember.objects.create(member=test_user_2, role=15, workspace=workspace)
-
-        project = Project.objects.create(
-            name="Test Project", identifier="test-project", workspace=workspace
-        )
-        ProjectMember.objects.create(project=project, member=test_user_2)
-
-        issue = Issue.objects.create(
-            name="Test Issue",
-            workspace=workspace,
-            project=project,
-        )
-
-        IssueAssignee.objects.create(issue=issue, assignee=test_user_1, project=project)
-
-        # Deleted issue assignee
-        IssueAssignee.objects.create(
-            issue=issue,
-            assignee=test_user_2,
-            project=project,
-            deleted_at=timezone.now(),
-        )
-
-        serialized_data = IssueRecentVisitSerializer(
-            issue,
-        ).data
-
-        # Check fields are present and correct
-        assert "name" in serialized_data
-        assert "assignees" in serialized_data
-        assert "project_identifier" in serialized_data
-
-        assert serialized_data["name"] == "Test Issue"
-        assert serialized_data["project_identifier"] == "TEST-PROJECT"
-
-        # Only including non-deleted issue assignees
-        assert serialized_data["assignees"] == [test_user_1.id]

apiserver/plane/tests/unit/serializers/test_workspace.py

@@ -1,71 +0,0 @@
-import pytest
-from uuid import uuid4
-
-from plane.api.serializers import WorkspaceLiteSerializer
-from plane.db.models import Workspace, User
-
-
-@pytest.mark.unit
-class TestWorkspaceLiteSerializer:
-    """Test the WorkspaceLiteSerializer"""
-
-    def test_workspace_lite_serializer_fields(self, db):
-        """Test that the serializer includes the correct fields"""
-        # Create a user to be the owner
-        owner = User.objects.create(
-            email="test@example.com",
-            first_name="Test",
-            last_name="User"
-        )
-
-        # Create a workspace with explicit ID to test serialization
-        workspace_id = uuid4()
-        workspace = Workspace.objects.create(
-            name="Test Workspace",
-            slug="test-workspace",
-            id=workspace_id,
-            owner=owner
-        )
-
-        # Serialize the workspace
-        serialized_data = WorkspaceLiteSerializer(workspace).data
-
-        # Check fields are present and correct
-        assert "name" in serialized_data
-        assert "slug" in serialized_data
-        assert "id" in serialized_data
-
-        assert serialized_data["name"] == "Test Workspace"
-        assert serialized_data["slug"] == "test-workspace"
-        assert str(serialized_data["id"]) == str(workspace_id)
-
-    def test_workspace_lite_serializer_read_only(self, db):
-        """Test that the serializer fields are read-only"""
-        # Create a user to be the owner
-        owner = User.objects.create(
-            email="test2@example.com",
-            first_name="Test",
-            last_name="User"
-        )
-
-        # Create a workspace
-        workspace = Workspace.objects.create(
-            name="Test Workspace",
-            slug="test-workspace",
-            id=uuid4(),
-            owner=owner
-        )
-
-        # Try to update via serializer
-        serializer = WorkspaceLiteSerializer(
-            workspace,
-            data={"name": "Updated Name", "slug": "updated-slug"}
-        )
-
-        # Serializer should be valid (since read-only fields are ignored)
-        assert serializer.is_valid()
-
-        # Save should not update the read-only fields
-        updated_workspace = serializer.save()
-        assert updated_workspace.name == "Test Workspace"
-        assert updated_workspace.slug == "test-workspace"

apiserver/plane/tests/unit/utils/test_uuid.py

@@ -1,49 +0,0 @@
-import uuid
-import pytest
-from plane.utils.uuid import is_valid_uuid, convert_uuid_to_integer
-
-
-@pytest.mark.unit
-class TestUUIDUtils:
-    """Test the UUID utilities"""
-
-    def test_is_valid_uuid_with_valid_uuid(self):
-        """Test is_valid_uuid with a valid UUID"""
-        # Generate a valid UUID
-        valid_uuid = str(uuid.uuid4())
-        assert is_valid_uuid(valid_uuid) is True
-
-    def test_is_valid_uuid_with_invalid_uuid(self):
-        """Test is_valid_uuid with invalid UUID strings"""
-        # Test with different invalid formats
-        assert is_valid_uuid("not-a-uuid") is False
-        assert is_valid_uuid("123456789") is False
-        assert is_valid_uuid("") is False
-        assert is_valid_uuid("00000000-0000-0000-0000-000000000000") is False  # This is a valid UUID but version 1
-
-    def test_convert_uuid_to_integer(self):
-        """Test convert_uuid_to_integer function"""
-        # Create a known UUID
-        test_uuid = uuid.UUID("f47ac10b-58cc-4372-a567-0e02b2c3d479")
-
-        # Convert to integer
-        result = convert_uuid_to_integer(test_uuid)
-
-        # Check that the result is an integer
-        assert isinstance(result, int)
-
-        # Ensure consistent results with the same input
-        assert convert_uuid_to_integer(test_uuid) == result
-
-        # Different UUIDs should produce different integers
-        different_uuid = uuid.UUID("550e8400-e29b-41d4-a716-446655440000")
-        assert convert_uuid_to_integer(different_uuid) != result
-
-    def test_convert_uuid_to_integer_string_input(self):
-        """Test convert_uuid_to_integer handles string UUID"""
-        # Test with a UUID string
-        test_uuid_str = "f47ac10b-58cc-4372-a567-0e02b2c3d479"
-        test_uuid = uuid.UUID(test_uuid_str)
-
-        # Should get the same result whether passing UUID or string
-        assert convert_uuid_to_integer(test_uuid) == convert_uuid_to_integer(test_uuid_str)

apiserver/plane/utils/url.py

@@ -4,14 +4,6 @@ from typing import Optional
 from urllib.parse import urlparse, urlunparse
 
 
-def contains_url(value: str) -> bool:
-    """
-    Check if the value contains a URL.
-    """
-    url_pattern = re.compile(r"https?://|www\\.")
-    return bool(url_pattern.search(value))
-
-
 def is_valid_url(url: str) -> bool:
     """
     Validates whether the given string is a well-formed URL.
@@ -85,3 +77,31 @@ def normalize_url_path(url: str) -> str:
     normalized_path = re.sub(r"/+", "/", parts.path)
     # Reconstruct the URL
     return urlunparse(parts._replace(path=normalized_path))
+
+
+def clean_value(value: str) -> str:
+    """
+    Clean the value by removing URLs and domain patterns.
+
+    Args:
+        value (str): The value to clean.
+
+    Returns:
+        str: The cleaned value.
+    """
+
+    if not value:
+        return value
+
+    url_pattern = r"(https?:\/\/)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)|[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"  # noqa
+
+    # Remove URLs and domains
+    cleaned_value = re.sub(url_pattern, "", value)
+
+    # Keep only alphanumeric characters and spaces
+    cleaned_value = re.sub(r"[^a-zA-Z0-9\s]", "", cleaned_value)
+
+    # Remove extra spaces and trim
+    cleaned_value = " ".join(cleaned_value.split())
+
+    return cleaned_value

apiserver/pytest.ini

@@ -1,17 +0,0 @@
-[pytest]
-DJANGO_SETTINGS_MODULE = plane.settings.test
-python_files = test_*.py
-python_classes = Test*
-python_functions = test_*
-
-markers =
-    unit: Unit tests for models, serializers, and utility functions
-    contract: Contract tests for API endpoints
-    smoke: Smoke tests for critical functionality
-    slow: Tests that are slow and might be skipped in some contexts
-
-addopts = 
-    --strict-markers
-    --reuse-db
-    --nomigrations
-    -vs 

apiserver/requirements/base.txt

@@ -1,7 +1,7 @@
 # base requirements
 
 # django
-Django==4.2.22
+Django==4.2.21
 # rest framework
 djangorestframework==3.15.2
 # postgres

apiserver/requirements/test.txt

@@ -1,12 +1,4 @@
 -r base.txt
-# test framework
-pytest==7.4.0
-pytest-django==4.5.2
-pytest-cov==4.1.0
-pytest-xdist==3.3.1
-pytest-mock==3.11.1
-factory-boy==3.3.0
-freezegun==1.2.2
-coverage==7.2.7
-httpx==0.24.1
-requests==2.32.4
+# test checker
+pytest==7.1.2
+coverage==6.5.0

apiserver/run_tests.py

@@ -1,91 +0,0 @@
-#!/usr/bin/env python
-import argparse
-import subprocess
-import sys
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Run Plane tests")
-    parser.add_argument(
-        "-u", "--unit", 
-        action="store_true", 
-        help="Run unit tests only"
-    )
-    parser.add_argument(
-        "-c", "--contract", 
-        action="store_true", 
-        help="Run contract tests only"
-    )
-    parser.add_argument(
-        "-s", "--smoke", 
-        action="store_true", 
-        help="Run smoke tests only"
-    )
-    parser.add_argument(
-        "-o", "--coverage", 
-        action="store_true", 
-        help="Generate coverage report"
-    )
-    parser.add_argument(
-        "-p", "--parallel", 
-        action="store_true", 
-        help="Run tests in parallel"
-    )
-    parser.add_argument(
-        "-v", "--verbose", 
-        action="store_true", 
-        help="Verbose output"
-    )
-    args = parser.parse_args()
-
-    # Build command
-    cmd = ["python", "-m", "pytest"]
-    markers = []
-
-    # Add test markers
-    if args.unit:
-        markers.append("unit")
-    if args.contract:
-        markers.append("contract")
-    if args.smoke:
-        markers.append("smoke")
-
-    # Add markers filter
-    if markers:
-        cmd.extend(["-m", " or ".join(markers)])
-
-    # Add coverage
-    if args.coverage:
-        cmd.extend(["--cov=plane", "--cov-report=term", "--cov-report=html"])
-
-    # Add parallel
-    if args.parallel:
-        cmd.extend(["-n", "auto"])
-
-    # Add verbose
-    if args.verbose:
-        cmd.append("-v")
-
-    # Add common flags
-    cmd.extend(["--reuse-db", "--nomigrations"])
-
-    # Print command
-    print(f"Running: {' '.join(cmd)}")
-    
-    # Execute command
-    result = subprocess.run(cmd)
-    
-    # Check coverage thresholds if coverage is enabled
-    if args.coverage:
-        print("Checking coverage thresholds...")
-        coverage_cmd = ["python", "-m", "coverage", "report", "--fail-under=90"]
-        coverage_result = subprocess.run(coverage_cmd)
-        if coverage_result.returncode != 0:
-            print("Coverage below threshold (90%)")
-            sys.exit(coverage_result.returncode)
-            
-    sys.exit(result.returncode)
-
-
-if __name__ == "__main__":
-    main() 

apiserver/run_tests.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-# This is a simple wrapper script that calls the main test runner in the tests directory
-exec tests/run_tests.sh "$@" 

apiserver/templates/emails/notifications/issue-updates.html

@@ -3,7 +3,7 @@
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Updates on {{entity_type}}</title>
+    <title>Updates on issue</title>
     <style type="text/css" emogrify="no"> html { font-family: system-ui; } p, h1, h2, h3, h4, ol, ul { margin: 0; } h-full { height: 100%; } a:hover { color: #3358d4 !important; } </style>
     <style> *[class="gmail-fix"] { display: none !important; } </style>
     <style type="text/css" emogrify="no"> @media (max-width: 600px) { .gmx-killpill { content: " \03D1"; } } </style>
@@ -37,7 +37,7 @@
           {% else %} 
           <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> {{summary}} <span style="font-size: 1rem; font-weight: 700; line-height: 28px"> {% if data|length > 0 %} {{ data.0.actor_detail.first_name}} {{data.0.actor_detail.last_name}} {% else %} {{ comments.0.actor_detail.first_name}} {{comments.0.actor_detail.last_name}} {% endif %} </span>and others. </p>
           {% endif %} <!-- {% if actors_involved == 1 %} {% if data|length > 0 and comments|length == 0 %} <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> <span style="font-size: 1rem; font-weight: 700; line-height: 28px"> {{ data.0.actor_detail.first_name}} {{data.0.actor_detail.last_name }} </span> made {{total_updates}} {% if total_updates > 1 %}updates{% else %}update{% endif %} to the issue. </p> {% elif data|length == 0 and comments|length > 0 %} <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> <span style="font-size: 1rem; font-weight: 700; line-height: 28px"> {{ comments.0.actor_detail.first_name}} {{comments.0.actor_detail.last_name }} </span> added {{total_comments}} new {% if total_comments > 1 %}comments{% else %}comment{% endif %}. </p> {% elif data|length > 0 and comments|length > 0 %} <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> <span style="font-size: 1rem; font-weight: 700; line-height: 28px"> {{ data.0.actor_detail.first_name}} {{data.0.actor_detail.last_name }} </span> made {{total_updates}} {% if total_updates > 1 %}updates{% else %}update{% endif %} and added {{total_comments}} new {% if total_comments > 1 %}comments{% else %}comment{% endif %} on the issue. </p> {% endif %} {% else %} <p style="font-size: 1rem;color: #1f2d5c; line-height: 28px"> There are {{ total_updates }} new updates and {{total_comments}} new comments on the issue. </p> {% endif %} --> {% for update in data %} {% if update.changes.name %} <!-- Issue title updated --> 
-          <p style="font-size: 1rem; line-height: 28px; color: #1f2d5c"> The {{entity_type}} title has been updated to {{ issue.name}} </p>
+          <p style="font-size: 1rem; line-height: 28px; color: #1f2d5c"> The issue title has been updated to {{ issue.name}} </p>
           {% endif %} <!-- Outer update Box start --> {% if data %} 
           <div style=" background-color: #f7f9ff; border-radius: 8px; border-style: solid; border-width: 1px; border-color: #c1d0ff; padding: 20px; margin-top: 15px; max-width: 100%; " >
             <!-- Block Heading --> 
@@ -209,7 +209,7 @@
                     {% for actor_comment in comment.actor_comments.new_value %} 
                     <tr>
                       <td>
-                        <div style=" padding: 6px 10px; margin-left: 10px; background-color: white; font-size: 0.8rem; color: #525252; margin-top: 5px; border-radius: 4px; overflow-x: scroll; max-width: 430px;" >
+                        <div style=" padding: 6px 10px; margin-left: 10px; background-color: white; font-size: 0.8rem; color: #525252; margin-top: 5px; border-radius: 4px; display: flex; align-items: center; " >
                           <p> {{ actor_comment|safe }} </p>
                         </div>
                       </td>
@@ -224,7 +224,7 @@
           {% endif %} 
         </div>
         <a href="{{ issue_url }}" style="text-decoration: none;">
-          <div style=" max-width: min-content; white-space: nowrap; background-color: #3e63dd; padding: 10px 15px; border: 1px solid #2f4ba8; border-radius: 4px; margin-top: 15px; cursor: pointer; font-size: 0.8rem; color: white; " > View {{entity_type}} </div>
+          <div style=" max-width: min-content; white-space: nowrap; background-color: #3e63dd; padding: 10px 15px; border: 1px solid #2f4ba8; border-radius: 4px; margin-top: 15px; cursor: pointer; font-size: 0.8rem; color: white; " > View issue </div>
         </a>
       </div>
       <!-- Footer --> 
@@ -232,7 +232,7 @@
         <tr>
           <td>
             <div style="font-size: 0.8rem; color: #1c2024">
-              This email was sent to <a href="mailto:{{receiver.email}}" style="color: #3a5bc7; font-weight: 500; text-decoration: none" >{{ receiver.email }}.</a > If you'd rather not receive this kind of email, <a href="{{ issue_url }}" style="color: #3a5bc7; text-decoration: none" >you can unsubscribe to the {{entity_type}}</a > or <a href="{{ user_preference }}" style="color: #3a5bc7; text-decoration: none" >manage your email preferences</a >. <!-- Github | LinkedIn | Twitter --> 
+              This email was sent to <a href="mailto:{{receiver.email}}" style="color: #3a5bc7; font-weight: 500; text-decoration: none" >{{ receiver.email }}.</a > If you'd rather not receive this kind of email, <a href="{{ issue_url }}" style="color: #3a5bc7; text-decoration: none" >you can unsubscribe to the issue</a > or <a href="{{ user_preference }}" style="color: #3a5bc7; text-decoration: none" >manage your email preferences</a >. <!-- Github | LinkedIn | Twitter --> 
               <div style="margin-top: 60px; float: right"> <a href="https://github.com/makeplane" target="_blank" style="margin-left: 10px; text-decoration: none" > <img src="https://creative-assets.mailinblue.com/editor/social-icons/rounded_colored/github_32px.png" width="25" height="25" border="0" style="display: inline-block" /> </a> <a href="https://www.linkedin.com/company/planepowers/" target="_blank" style="margin-left: 10px; text-decoration: none" > <img src="https://creative-assets.mailinblue.com/editor/social-icons/rounded_colored/linkedin_32px.png" width="25" height="25" border="0" style="display: inline-block" /> </a> <a href="https://twitter.com/planepowers" target="_blank" style="margin-left: 10px; text-decoration: none" > <img src="https://creative-assets.mailinblue.com/editor/social-icons/rounded_colored/twitter_32px.png" width="25" height="25" border="0" style="display: inline-block" /> </a> </div>
             </div>
           </td>

caddy/Caddyfile.template

@@ -1,34 +0,0 @@
-(plane_proxy) {
-	request_body {
-		max_size {$FILE_SIZE_LIMIT}
-	}
-
-	reverse_proxy /spaces/* space:3000
-
-	reverse_proxy /god-mode/* admin:3000
-	
-	reverse_proxy /live/* live:3000
-
-	reverse_proxy /api/* api:8000
-
-	reverse_proxy /auth/* api:8000
-
-	reverse_proxy /{$BUCKET_NAME}/* plane-minio:9000
-
-	reverse_proxy /* web:3000
-}
-
-{
-	email {$CERT_EMAIL:admin@example.com}
-	acme_ca {$CERT_ACME_CA} 
-	{$CERT_ACME_DNS}
-	servers {
-		max_header_size 5MB
-		client_ip_headers X-Forwarded-For X-Real-IP
-		trusted_proxies static {$TRUSTED_PROXIES:0.0.0.0/0}
-	}
-}
-
-{$SITE_ADDRESS} {
-	import plane_proxy
-}

caddy/Dockerfile

@@ -1,9 +0,0 @@
-FROM makeplane/caddy:latest
-
-COPY ./Caddyfile.template /etc/caddy/Caddyfile
-
-COPY ./caddy.sh /docker-entrypoint.sh
-
-RUN chmod +x /docker-entrypoint.sh
-
-CMD ["/docker-entrypoint.sh"]

caddy/caddy.sh

@@ -1,11 +0,0 @@
-#!/bin/sh
-
-if [ "$APP_DOMAIN" == "localhost" ]; then
-    export SITE_ADDRESS=":${LISTEN_HTTP_PORT}"
-elif [ "$SSL" == "true" ]; then
-    export SITE_ADDRESS="${APP_DOMAIN}:${LISTEN_HTTPS_PORT}"
-else
-    export SITE_ADDRESS="http://${APP_DOMAIN}:${LISTEN_HTTP_PORT}"
-fi
-
-exec caddy run --config /etc/caddy/Caddyfile

deploy/selfhost/README.md

@@ -58,7 +58,7 @@ Installing plane is a very easy and minimal step process.
 ### Downloading Latest Release
 
 ```
-mkdir -p plane-selfhost && cd plane-selfhost
+mkdir plane-selfhost
 
 cd plane-selfhost
 ```
@@ -144,15 +144,11 @@ Again the `options [1-7]` will be popped up, and this time hit `7` to exit.
 Before proceeding, we suggest used to review `.env` file and set the values.
 Below are the most import keys you must refer to. _<span style="color: #fcba03">You can use any text editor to edit this file</span>_.
 
-> `APP_DOMAIN` - Set the Fully Qualified Domain Name here. (eg. `plane.example.com`)
-> 
-> `LISTEN_PORT` - This is default set to `80`. Make sure the port you choose to use is not preoccupied. (e.g `LISTEN_PORT=8080`)
-> 
-> `LISTEN_SSL_PORT` - This is default set to `443`. Make sure the port you choose to use is not preoccupied. (e.g `LISTEN_SSL_PORT=8443`)
-> 
-> `WEB_URL` - This is default set to `http://localhost`. Change this to the FQDN you plan to use along with LISTEN_PORT/LISTEN_SSL_PORT (eg. `https://plane.example.com:8443` or `http://[IP-ADDRESS]:8080`)
-> 
-> `CORS_ALLOWED_ORIGINS` - This is default set to `http://${APP_DOMAIN},https://${APP_DOMAIN}`. Change this to the FQDN you plan to use along with LISTEN_PORT and  LISTEN_SSL_PORT (eg. `http://plane.example.com:8080,https://plane.example.com:8443`)
+> `NGINX_PORT` - This is default set to `80`. Make sure the port you choose to use is not preoccupied. (e.g `NGINX_PORT=8080`)
+
+> `WEB_URL` - This is default set to `http://localhost`. Change this to the FQDN you plan to use along with NGINX_PORT (eg. `https://plane.example.com:8080` or `http://[IP-ADDRESS]:8080`)
+
+> `CORS_ALLOWED_ORIGINS` - This is default set to `http://localhost`. Change this to the FQDN you plan to use along with NGINX_PORT (eg. `https://plane.example.com:8080` or `http://[IP-ADDRESS]:8080`)
 
 There are many other settings you can play with, but we suggest you configure `EMAIL SETTINGS` as it will enable you to invite your teammates onto the platform.
 
@@ -176,8 +172,6 @@ Select a Action you want to perform:
 Action [2]: 2
 ```
 
-> You can also choose to run `./setup.sh start` as direct command.
-
 Expect something like this.  
 ![Downloading docker images](images/download.png)
 
@@ -213,8 +207,6 @@ Select a Action you want to perform:
 Action [2]: 3
 ```
 
-> You can also choose to run `./setup.sh stop` as direct command.
-
 If all goes well, you must see something like this
 
 ![Stop Services](images/stopped.png)
@@ -261,8 +253,6 @@ Select a Action you want to perform:
 Action [2]: 4
 ```
 
-> You can also choose to run `./setup.sh restart` as direct command.
-
 If all goes well, you must see something like this
 
 ![Restart Services](images/restart.png)
@@ -307,8 +297,6 @@ Select a Action you want to perform:
 Action [2]: 5
 ```
 
-> You can also choose to run `./setup.sh upgrade` as direct command.
-
 By choosing this, it will stop the services and then will download the latest `docker-compose.yaml` and `plane.env`.
 
 You must expect the below message
@@ -477,8 +465,6 @@ Select a Action you want to perform:
 Action [2]: 7
 ```
 
-> You can also choose to run `./setup.sh backup` as direct command.
-
 In response, you can find the backup folder
 
 ```bash
@@ -500,7 +486,7 @@ When you want to restore the previously backed-up data, follow the instructions
 1. Download the restore script using the command below. We suggest downloading it in the same folder as `setup.sh`.
 
    ```bash
-   curl -fsSL -o restore.sh https://github.com/makeplane/plane/releases/latest/download/restore.sh
+   curl -fsSL -o restore.sh https://raw.githubusercontent.com/makeplane/plane/master/deploy/selfhost/restore.sh
    chmod +x restore.sh
    ```
 
@@ -543,31 +529,6 @@ When you want to restore the previously backed-up data, follow the instructions
 
 ---
 
-### Restore for Commercial Air-Gapped (Docker Compose)
-
-When you want to restore the previously backed-up data on Plane Commercial Air-Gapped version, follow the instructions below.
-
-1. Download the restore script using the command below
-
-   ```bash
-   curl -fsSL -o restore-airgapped.sh https://github.com/makeplane/plane/releases/latest/download/restore-airgapped.sh
-   chmod +x restore-airgapped.sh
-   ```
-
-1. Copy the backup folder and the `restore-airgapped.sh` to `Commercial Airgapped Edition` server
-
-1. Make sure that Plane Commercial (Airgapped) is extracted and ready to get started. In case it is running, you would need to stop that.
-
-1. Execute the command below to restore your data.
-
-   ```bash
-   ./restore-airgapped.sh <path to backup folder containing *.tar.gz files>
-   ```
-
-1. After restoration, you are ready to start Plane Commercial (Airgapped) will all your previously saved data. 
-
----
-
 <details>
    <summary><h2>Upgrading from v0.13.2 to v0.14.x</h2></summary>
 

deploy/selfhost/build.yml

@@ -17,12 +17,6 @@ services:
       context: ./
       dockerfile: ./admin/Dockerfile.admin
 
-  live:
-    image: ${DOCKERHUB_USER:-local}/plane-live:${APP_RELEASE:-latest}
-    build:
-      context: .
-      dockerfile: ./live/Dockerfile.live
-
   api:
     image: ${DOCKERHUB_USER:-local}/plane-backend:${APP_RELEASE:-latest}
     build:
@@ -32,5 +26,5 @@ services:
   proxy:
     image: ${DOCKERHUB_USER:-local}/plane-proxy:${APP_RELEASE:-latest}
     build:
-      context: ./caddy
+      context: ./nginx
       dockerfile: ./Dockerfile

deploy/selfhost/docker-compose.yml

@@ -24,14 +24,9 @@ x-aws-s3-env: &aws-s3-env
   AWS_S3_BUCKET_NAME: ${AWS_S3_BUCKET_NAME:-uploads}
 
 x-proxy-env: &proxy-env
-  SSL: ${SSL:-false}
-  APP_DOMAIN: ${APP_DOMAIN:-localhost}
-  FILE_SIZE_LIMIT: ${FILE_SIZE_LIMIT:-5242880}
-  CERT_EMAIL: ${CERT_EMAIL:-admin@example.com}
-  CERT_ACME_CA: ${CERT_ACME_CA:-}
-  LISTEN_HTTP_PORT: ${LISTEN_PORT:-80}
-  LISTEN_HTTPS_PORT: ${LISTEN_SSL_PORT:-443}
+  NGINX_PORT: ${NGINX_PORT:-80}
   BUCKET_NAME: ${AWS_S3_BUCKET_NAME:-uploads}
+  FILE_SIZE_LIMIT: ${FILE_SIZE_LIMIT:-5242880}
 
 x-mq-env: &mq-env # RabbitMQ Settings
   RABBITMQ_HOST: ${RABBITMQ_HOST:-plane-mq}
@@ -217,31 +212,22 @@ services:
 
   # Comment this if you already have a reverse proxy running
   proxy:
-    image: artifacts.plane.so/makeplane/plane-proxy:${APP_RELEASE_VERSION}
+    image: artifacts.plane.so/makeplane/plane-proxy:${APP_RELEASE:-stable}
+    ports:
+      - target: 80
+        published: ${NGINX_PORT:-80}
+        protocol: tcp
+        mode: host
+    environment:
+      <<: *proxy-env
     deploy:
       replicas: 1
       restart_policy:
         condition: on-failure
-    environment:
-      <<: *proxy-env
-    ports:
-    - target: 80
-      published: ${LISTEN_HTTP_PORT:-80}
-      protocol: tcp
-      mode: host
-    - target: 443
-      published: ${LISTEN_HTTPS_PORT:-443}
-      protocol: tcp
-      mode: host
-    volumes:
-    - proxy_config:/config
-    - proxy_data:/data
     depends_on:
-    - web
-    - api
-    - space
-    - admin
-    - live
+      - web
+      - api
+      - space
 
 volumes:
   pgdata:
@@ -251,6 +237,4 @@ volumes:
   logs_worker:
   logs_beat-worker:
   logs_migrator:
-  caddy_config:
-  caddy_data:
   rabbitmq_data:

deploy/selfhost/install.sh

@@ -1,7 +1,6 @@
 #!/bin/bash
 
 BRANCH=${BRANCH:-master}
-RELEASE_TAG=${RELEASE_TAG:-v0.22-dev}
 SCRIPT_DIR=$PWD
 SERVICE_FOLDER=plane-app
 PLANE_INSTALL_DIR=$PWD/$SERVICE_FOLDER
@@ -178,13 +177,11 @@ function syncEnvFile(){
                 updateEnvFile "$key" "$value" "$DOCKER_ENV_PATH"
             fi
         done < "$DOCKER_ENV_PATH"
-        # Replace APP_RELEASE with the latest value
-        updateEnvFile "APP_RELEASE" "$APP_RELEASE" "$DOCKER_ENV_PATH"
     fi
     echo "Environment variables synced successfully" >&2
 }
 
-function buildYourOwnImage() {
+function buildYourOwnImage(){
     echo "Building images locally..."
 
     export DOCKERHUB_USER="myplane"
@@ -426,7 +423,7 @@ function upgrade() {
     stopServices
 
     echo
-    echo "***** DOWNLOADING $APP_RELEASE VERSION ****"
+    echo "***** DOWNLOADING STABLE VERSION ****"
     install
 
     echo "***** PLEASE VALIDATE AND START SERVICES ****"

deploy/selfhost/restore-airgapped.sh

@@ -1,144 +0,0 @@
-#!/bin/bash
-+set -euo pipefail
-
-function print_header() {
-clear
-
-cat <<"EOF"
---------------------------------------------
- ____  _                          ///////// 
-|  _ \| | __ _ _ __   ___         ///////// 
-| |_) | |/ _` | '_ \ / _ \   /////    ///// 
-|  __/| | (_| | | | |  __/   /////    ///// 
-|_|   |_|\__,_|_| |_|\___|        ////      
-                                  ////      
---------------------------------------------
-Project management tool from the future
---------------------------------------------
-EOF
-}
-
-function restoreData() {
-
-    echo ""
-    echo "****************************************************"
-    echo "We are about to restore your data from the backup files."
-    echo "****************************************************"
-    echo ""
-
-    # set the backup folder path
-    BACKUP_FOLDER=${1}
-
-    if [ -z "$BACKUP_FOLDER" ]; then
-        BACKUP_FOLDER="$PWD/backup"
-        read -p "Enter the backup folder path [$BACKUP_FOLDER]: " BACKUP_FOLDER
-        if [ -z "$BACKUP_FOLDER" ]; then
-            BACKUP_FOLDER="$PWD/backup"
-        fi
-    fi
-
-    # check if the backup folder exists
-    if [ ! -d "$BACKUP_FOLDER" ]; then
-        echo "Error: Backup folder not found at $BACKUP_FOLDER"
-        exit 1
-    fi
-
-    # check if there are any .tar.gz files in the backup folder
-    if ! ls "$BACKUP_FOLDER"/*.tar.gz 1> /dev/null 2>&1; then
-        echo "Error: Backup folder does not contain .tar.gz files"
-        exit 1
-    fi
-
-    echo ""
-    echo "Using backup folder: $BACKUP_FOLDER"
-    echo ""
-
-    # ask for current install path
-    AIRGAPPED_INSTALL_PATH="$HOME/planeairgapped"
-    read -p "Enter the airgapped instance install path [$AIRGAPPED_INSTALL_PATH]: " AIRGAPPED_INSTALL_PATH
-    if [ -z "$AIRGAPPED_INSTALL_PATH" ]; then
-        AIRGAPPED_INSTALL_PATH="$HOME/planeairgapped"
-    fi
-
-    # check if the airgapped instance install path exists
-    if [ ! -d "$AIRGAPPED_INSTALL_PATH" ]; then
-        echo "Error: Airgapped instance install path not found at $AIRGAPPED_INSTALL_PATH"
-        exit 1
-    fi
-
-    echo ""
-    echo "Using airgapped instance install path: $AIRGAPPED_INSTALL_PATH"
-    echo ""
-
-    # check if the docker-compose.yaml exists
-    if [ ! -f "$AIRGAPPED_INSTALL_PATH/docker-compose.yml" ]; then
-        echo "Error: docker-compose.yml not found at $AIRGAPPED_INSTALL_PATH/docker-compose.yml"
-        exit 1
-    fi
-
-    local dockerServiceStatus
-    if command -v jq &> /dev/null; then
-        dockerServiceStatus=$($COMPOSE_CMD ls --filter name=plane-airgapped --format=json | jq -r .[0].Status)
-    else
-        dockerServiceStatus=$($COMPOSE_CMD ls --filter name=plane-airgapped | grep -o "running" | head -n 1)
-    fi
-
-    if [[ $dockerServiceStatus == "running" ]]; then
-        echo "Plane Airgapped is running. Please STOP the Plane Airgapped before restoring data."
-        exit 1
-    fi
-
-    CURRENT_USER_ID=$(id -u)
-    CURRENT_GROUP_ID=$(id -g)
-
-    # if the data folder not exists, create it
-    if [ ! -d "$AIRGAPPED_INSTALL_PATH/data" ]; then
-        mkdir -p "$AIRGAPPED_INSTALL_PATH/data"
-        chown -R $CURRENT_USER_ID:$CURRENT_GROUP_ID "$AIRGAPPED_INSTALL_PATH/data"
-    fi
-
-    for BACKUP_FILE in "$BACKUP_FOLDER/*.tar.gz"; do
-        if [ -e "$BACKUP_FILE" ]; then
-
-            # get the basefilename without the extension
-            BASE_FILE_NAME=$(basename "$BACKUP_FILE" ".tar.gz")
-
-            # extract the restoreFile to the airgapped instance install path
-            echo "Restoring $BASE_FILE_NAME"
-            rm -rf "$AIRGAPPED_INSTALL_PATH/data/$BASE_FILE_NAME" || true
-            
-            tar -xvzf "$BACKUP_FILE" -C "$AIRGAPPED_INSTALL_PATH/data/"
-            if [ $? -ne 0 ]; then
-                echo "Error: Failed to extract $BACKUP_FILE"
-                exit 1
-            fi
-            chown -R $CURRENT_USER_ID:$CURRENT_GROUP_ID "$AIRGAPPED_INSTALL_PATH/data/$BASE_FILE_NAME"
-            if [ $? -ne 0 ]; then
-                echo "Error: Failed to change ownership of $AIRGAPPED_INSTALL_PATH/data/$BASE_FILE_NAME"
-                exit 1
-            fi
-        else
-            echo "No .tar.gz files found in the current directory."
-            echo ""
-            echo "Please provide the path to the backup file."
-            echo ""
-            echo "Usage: $0 /path/to/backup"  
-            exit 1
-        fi
-    done
-
-    echo ""
-    echo "Restore completed successfully."
-    echo ""
-}
-
-# if docker-compose is installed
-if command -v docker-compose &> /dev/null
-then
-    COMPOSE_CMD="docker-compose"
-else
-    COMPOSE_CMD="docker compose"
-fi
-
-print_header
-restoreData "$@"

deploy/selfhost/variables.env

@@ -1,6 +1,5 @@
 APP_DOMAIN=localhost
 APP_RELEASE=stable
-SSL=false
 
 WEB_REPLICAS=1
 SPACE_REPLICAS=1
@@ -10,11 +9,10 @@ WORKER_REPLICAS=1
 BEAT_WORKER_REPLICAS=1
 LIVE_REPLICAS=1
 
-LISTEN_PORT=80
-LISTEN_SSL_PORT=443
+NGINX_PORT=80
 WEB_URL=http://${APP_DOMAIN}
 DEBUG=0
-CORS_ALLOWED_ORIGINS=http://${APP_DOMAIN},https://${APP_DOMAIN}
+CORS_ALLOWED_ORIGINS=http://${APP_DOMAIN}
 API_BASE_URL=http://api:8000
 
 #DB SETTINGS
@@ -32,11 +30,6 @@ REDIS_HOST=plane-redis
 REDIS_PORT=6379
 REDIS_URL=
 
-# If SSL Cert to be generated, set CERT_EMAIL and APP_PROTOCOL to https
-CERT_EMAIL=
-CERT_ACME_CA=https://acme-v02.api.letsencrypt.org/directory
-TRUSTED_PROXIES=0.0.0.0/0
-
 # RabbitMQ Settings
 RABBITMQ_HOST=plane-mq
 RABBITMQ_PORT=5672

live/package.json

@@ -1,6 +1,6 @@
 {
   "name": "live",
-  "version": "0.26.1",
+  "version": "0.26.0",
   "license": "AGPL-3.0",
   "description": "A realtime collaborative server powers Plane's rich text editor",
   "main": "./src/server.ts",
@@ -57,7 +57,7 @@
     "concurrently": "^9.0.1",
     "nodemon": "^3.1.7",
     "ts-node": "^10.9.2",
-    "tsup": "8.4.0",
-    "typescript": "5.8.3"
+    "tsup": "^8.4.0",
+    "typescript": "5.3.3"
   }
 }

package.json

@@ -2,7 +2,7 @@
   "name": "plane",
   "description": "Open-source project management that unlocks customer value",
   "repository": "https://github.com/makeplane/plane.git",
-  "version": "0.26.1",
+  "version": "0.26.0",
   "license": "AGPL-3.0",
   "private": true,
   "workspaces": [
@@ -24,16 +24,13 @@
   "devDependencies": {
     "prettier": "latest",
     "prettier-plugin-tailwindcss": "^0.5.4",
-    "turbo": "^2.5.4"
+    "turbo": "^2.5.3"
   },
   "resolutions": {
-    "brace-expansion": "2.0.2",
     "nanoid": "3.3.8",
     "esbuild": "0.25.0",
     "@babel/helpers": "7.26.10",
-    "@babel/runtime": "7.26.10",
-    "chokidar": "3.6.0",
-    "tar-fs": "3.0.9"
+    "@babel/runtime": "7.26.10"
   },
   "packageManager": "yarn@1.22.22"
 }

packages/constants/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plane/constants",
-  "version": "0.26.1",
+  "version": "0.26.0",
   "private": true,
   "main": "./src/index.ts",
   "license": "AGPL-3.0"

packages/constants/src/analytics-v2/common.ts

@@ -0,0 +1,105 @@
+import { TAnalyticsTabsV2Base } from "@plane/types";
+import { ChartXAxisProperty, ChartYAxisMetric } from "../chart";
+
+export const insightsFields: Record<TAnalyticsTabsV2Base, string[]> = {
+  overview: [
+    "total_users",
+    "total_admins",
+    "total_members",
+    "total_guests",
+    "total_projects",
+    "total_work_items",
+    "total_cycles",
+    "total_intake",
+  ],
+  "work-items": [
+    "total_work_items",
+    "started_work_items",
+    "backlog_work_items",
+    "un_started_work_items",
+    "completed_work_items",
+  ],
+};
+
+export const ANALYTICS_V2_DURATION_FILTER_OPTIONS = [
+  {
+    name: "Yesterday",
+    value: "yesterday",
+  },
+  {
+    name: "Last 7 days",
+    value: "last_7_days",
+  },
+  {
+    name: "Last 30 days",
+    value: "last_30_days",
+  },
+  {
+    name: "Last 3 months",
+    value: "last_3_months",
+  },
+];
+
+export const ANALYTICS_V2_X_AXIS_VALUES: { value: ChartXAxisProperty; label: string }[] = [
+  {
+    value: ChartXAxisProperty.STATES,
+    label: "State name",
+  },
+  {
+    value: ChartXAxisProperty.STATE_GROUPS,
+    label: "State group",
+  },
+  {
+    value: ChartXAxisProperty.PRIORITY,
+    label: "Priority",
+  },
+  {
+    value: ChartXAxisProperty.LABELS,
+    label: "Label",
+  },
+  {
+    value: ChartXAxisProperty.ASSIGNEES,
+    label: "Assignee",
+  },
+  {
+    value: ChartXAxisProperty.ESTIMATE_POINTS,
+    label: "Estimate point",
+  },
+  {
+    value: ChartXAxisProperty.CYCLES,
+    label: "Cycle",
+  },
+  {
+    value: ChartXAxisProperty.MODULES,
+    label: "Module",
+  },
+  {
+    value: ChartXAxisProperty.COMPLETED_AT,
+    label: "Completed date",
+  },
+  {
+    value: ChartXAxisProperty.TARGET_DATE,
+    label: "Due date",
+  },
+  {
+    value: ChartXAxisProperty.START_DATE,
+    label: "Start date",
+  },
+  {
+    value: ChartXAxisProperty.CREATED_AT,
+    label: "Created date",
+  },
+];
+
+export const ANALYTICS_V2_Y_AXIS_VALUES: { value: ChartYAxisMetric; label: string }[] = [
+  {
+    value: ChartYAxisMetric.WORK_ITEM_COUNT,
+    label: "Work item",
+  },
+  {
+    value: ChartYAxisMetric.ESTIMATE_POINT_COUNT,
+    label: "Estimate",
+  },
+];
+
+export const ANALYTICS_V2_DATE_KEYS = ["completed_at", "target_date", "start_date", "created_at"];

packages/constants/src/analytics.ts

@@ -0,0 +1,81 @@
+// types
+import { TXAxisValues, TYAxisValues } from "@plane/types";
+
+export const ANALYTICS_TABS = [
+  {
+    key: "scope_and_demand",
+    i18n_title: "workspace_analytics.tabs.scope_and_demand",
+  },
+  { key: "custom", i18n_title: "workspace_analytics.tabs.custom" },
+];
+
+export const ANALYTICS_X_AXIS_VALUES: { value: TXAxisValues; label: string }[] =
+  [
+    {
+      value: "state_id",
+      label: "State name",
+    },
+    {
+      value: "state__group",
+      label: "State group",
+    },
+    {
+      value: "priority",
+      label: "Priority",
+    },
+    {
+      value: "labels__id",
+      label: "Label",
+    },
+    {
+      value: "assignees__id",
+      label: "Assignee",
+    },
+    {
+      value: "estimate_point__value",
+      label: "Estimate point",
+    },
+    {
+      value: "issue_cycle__cycle_id",
+      label: "Cycle",
+    },
+    {
+      value: "issue_module__module_id",
+      label: "Module",
+    },
+    {
+      value: "completed_at",
+      label: "Completed date",
+    },
+    {
+      value: "target_date",
+      label: "Due date",
+    },
+    {
+      value: "start_date",
+      label: "Start date",
+    },
+    {
+      value: "created_at",
+      label: "Created date",
+    },
+  ];
+
+export const ANALYTICS_Y_AXIS_VALUES: { value: TYAxisValues; label: string }[] =
+  [
+    {
+      value: "issue_count",
+      label: "Work item Count",
+    },
+    {
+      value: "estimate",
+      label: "Estimate",
+    },
+  ];
+
+export const ANALYTICS_DATE_KEYS = [
+  "completed_at",
+  "target_date",
+  "start_date",
+  "created_at",
+];