Sync issues in sequence.

* Separated environment variables for specific app containers.

* updated env

* cleanup

* Separated environment variables for specific app containers.

* updated env

* cleanup

---------

Co-authored-by: Akshat Jain <akshatjain9782@gmail.com>

.github/pull_request_template.md

@@ -0,0 +1,20 @@
+### Description
+<!-- Provide a detailed description of the changes in this PR -->
+
+### Type of Change
+<!-- Put an 'x' in the boxes that apply -->
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] Feature (non-breaking change which adds functionality)
+- [ ] Improvement (change that would cause existing functionality to not work as expected)
+- [ ] Code refactoring
+- [ ] Performance improvements
+- [ ] Documentation update
+
+### Screenshots and Media (if applicable)
+<!-- Add screenshots to help explain your changes, ideally showcasing before and after -->
+
+### Test Scenarios 
+<!-- Please describe the tests that you ran to verify your changes -->
+
+### References
+<!-- Link related issues if there are any -->

.github/workflows/build-branch.yml

@@ -25,9 +25,6 @@ on:
         required: false
         default: false
         type: boolean
-  # push:
-  #   branches:
-  #     - master
 
 env:
   TARGET_BRANCH: ${{ github.ref_name }}
@@ -317,8 +314,8 @@ jobs:
           buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
   attach_assets_to_build:
-    if: ${{ needs.branch_build_setup.outputs.build_type == 'Build' }}
-    name: Attach Assets to Build
+    if: ${{ needs.branch_build_setup.outputs.build_type == 'Release' }}
+    name: Attach Assets to Release
     runs-on: ubuntu-20.04
     needs: [branch_build_setup]
     steps:
@@ -354,6 +351,7 @@ jobs:
         branch_build_push_live,
         branch_build_push_apiserver,
         branch_build_push_proxy,
+        attach_assets_to_build,
       ]
     env:
       REL_VERSION: ${{ needs.branch_build_setup.outputs.release_version }}

admin/app/ai/form.tsx

@@ -121,7 +121,12 @@ export const InstanceAIForm: FC<IInstanceAIForm> = (props) => {
 
         <div className="relative inline-flex items-center gap-2 rounded border border-custom-primary-100/20 bg-custom-primary-100/10 px-4 py-2 text-xs text-custom-primary-200">
           <Lightbulb height="14" width="14" />
-          <div>If you have a preferred AI models vendor, please get in touch with us.</div>
+          <div>
+            If you have a preferred AI models vendor, please get in{" "}
+            <a className="underline font-medium" href="https://plane.so/contact">
+              touch with us.
+            </a>
+          </div>
         </div>
       </div>
     </div>

admin/app/authentication/github/form.tsx

@@ -195,7 +195,7 @@ export const InstanceGithubConfigForm: FC<Props> = (props) => {
                 </Button>
                 <Link
                   href="/authentication"
-                  className={cn(getButtonStyling("link-neutral", "md"), "font-medium")}
+                  className={cn(getButtonStyling("neutral-primary", "md"), "font-medium")}
                   onClick={handleGoBack}
                 >
                   Go back

admin/app/authentication/github/page.tsx

@@ -44,7 +44,7 @@ const InstanceGithubAuthenticationPage = observer(() => {
       loading: "Saving Configuration...",
       success: {
         title: "Configuration saved",
-        message: () => `Github authentication is now ${value ? "active" : "disabled"}.`,
+        message: () => `GitHub authentication is now ${value ? "active" : "disabled"}.`,
       },
       error: {
         title: "Error",
@@ -67,8 +67,8 @@ const InstanceGithubAuthenticationPage = observer(() => {
       <div className="relative container mx-auto w-full h-full p-4 py-4 space-y-6 flex flex-col">
         <div className="border-b border-custom-border-100 mx-4 py-4 space-y-1 flex-shrink-0">
           <AuthenticationMethodCard
-            name="Github"
-            description="Allow members to login or sign up to plane with their Github accounts."
+            name="GitHub"
+            description="Allow members to login or sign up to plane with their GitHub accounts."
             icon={
               <Image
                 src={resolveGeneralTheme(resolvedTheme) === "dark" ? githubDarkModeImage : githubLightModeImage}

admin/app/authentication/gitlab/form.tsx

@@ -191,7 +191,7 @@ export const InstanceGitlabConfigForm: FC<Props> = (props) => {
                 </Button>
                 <Link
                   href="/authentication"
-                  className={cn(getButtonStyling("link-neutral", "md"), "font-medium")}
+                  className={cn(getButtonStyling("neutral-primary", "md"), "font-medium")}
                   onClick={handleGoBack}
                 >
                   Go back

admin/app/authentication/google/form.tsx

@@ -192,7 +192,7 @@ export const InstanceGoogleConfigForm: FC<Props> = (props) => {
                 </Button>
                 <Link
                   href="/authentication"
-                  className={cn(getButtonStyling("link-neutral", "md"), "font-medium")}
+                  className={cn(getButtonStyling("neutral-primary", "md"), "font-medium")}
                   onClick={handleGoBack}
                 >
                   Go back

admin/app/authentication/page.tsx

@@ -60,7 +60,7 @@ const InstanceAuthenticationPage = observer(() => {
         <div className="border-b border-custom-border-100 mx-4 py-4 space-y-1 flex-shrink-0">
           <div className="text-xl font-medium text-custom-text-100">Manage authentication modes for your instance</div>
           <div className="text-sm font-normal text-custom-text-300">
-            Configure authentication modes for your team and restrict sign ups to be invite only.
+            Configure authentication modes for your team and restrict sign-ups to be invite only.
           </div>
         </div>
         <div className="flex-grow overflow-hidden overflow-y-scroll vertical-scrollbar scrollbar-md px-4">
@@ -80,9 +80,11 @@ const InstanceAuthenticationPage = observer(() => {
                     <ToggleSwitch
                       value={Boolean(parseInt(enableSignUpConfig))}
                       onChange={() => {
-                        Boolean(parseInt(enableSignUpConfig)) === true
-                          ? updateConfig("ENABLE_SIGNUP", "0")
-                          : updateConfig("ENABLE_SIGNUP", "1");
+                        if (Boolean(parseInt(enableSignUpConfig)) === true) {
+                          updateConfig("ENABLE_SIGNUP", "0");
+                        } else {
+                          updateConfig("ENABLE_SIGNUP", "1");
+                        }
                       }}
                       size="sm"
                       disabled={isSubmitting}
@@ -90,7 +92,7 @@ const InstanceAuthenticationPage = observer(() => {
                   </div>
                 </div>
               </div>
-              <div className="text-lg font-medium pt-6">Authentication modes</div>
+              <div className="text-lg font-medium pt-6">Available authentication modes</div>
               <AuthenticationModes disabled={isSubmitting} updateConfig={updateConfig} />
             </div>
           ) : (

admin/app/email/email-config-form.tsx

@@ -72,7 +72,7 @@ export const InstanceEmailForm: FC<IInstanceEmailForm> = (props) => {
     {
       key: "EMAIL_FROM",
       type: "text",
-      label: "Sender email address",
+      label: "Sender's email address",
       description:
         "This is the email address your users will see when getting emails from this instance. You will need to verify this address.",
       placeholder: "no-reply@projectplane.so",
@@ -174,12 +174,12 @@ export const InstanceEmailForm: FC<IInstanceEmailForm> = (props) => {
           </div>
         </div>
         <div className="flex flex-col gap-6 my-6 pt-4 border-t border-custom-border-100">
-          <div className="flex w-full max-w-md flex-col gap-y-10 px-1">
+          <div className="flex w-full max-w-xl flex-col gap-y-10 px-1">
             <div className="mr-8 flex items-center gap-10 pt-4">
               <div className="grow">
-                <div className="text-sm font-medium text-custom-text-100">Authentication (optional)</div>
+                <div className="text-sm font-medium text-custom-text-100">Authentication</div>
                 <div className="text-xs font-normal text-custom-text-300">
-                  We recommend setting up a username password for your SMTP server
+                  This is optional, but we recommend setting up a username and a password for your SMTP server.
                 </div>
               </div>
             </div>

admin/app/general/form.tsx

@@ -117,17 +117,18 @@ export const GeneralConfigurationForm: FC<IGeneralConfigurationForm> = observer(
             </div>
             <div className="grow">
               <div className="text-sm font-medium text-custom-text-100 leading-5">
-                Allow Plane to collect anonymous usage events
+                Let Plane collect anonymous usage data
               </div>
               <div className="text-xs font-normal text-custom-text-300 leading-5">
-                We collect usage events without any PII to analyse and improve Plane.{" "}
+                No PII is collected.This anonymized data is used to understand how you use Plane and build new features
+                in line with{" "}
                 <a
                   href="https://docs.plane.so/self-hosting/telemetry"
                   target="_blank"
                   className="text-custom-primary-100 hover:underline"
                   rel="noreferrer"
                 >
-                  Know more.
+                  our Telemetry Policy.
                 </a>
               </div>
             </div>

admin/app/general/intercom.tsx

@@ -60,9 +60,9 @@ export const IntercomConfig: FC<TIntercomConfig> = observer((props) => {
           </div>
 
           <div className="grow">
-            <div className="text-sm font-medium text-custom-text-100 leading-5">Talk to Plane</div>
+            <div className="text-sm font-medium text-custom-text-100 leading-5">Chat with us</div>
             <div className="text-xs font-normal text-custom-text-300 leading-5">
-              Let your members chat with us via Intercom or another service. Toggling Telemetry off turns this off
+              Let your users chat with us via Intercom or another service. Toggling Telemetry off turns this off
               automatically.
             </div>
           </div>

admin/app/workspace/create/form.tsx

@@ -0,0 +1,214 @@
+import { useState, useEffect } from "react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { Controller, useForm } from "react-hook-form";
+// constants
+import { ORGANIZATION_SIZE, RESTRICTED_URLS } from "@plane/constants";
+// types
+import { IWorkspace } from "@plane/types";
+// components
+import { Button, CustomSelect, getButtonStyling, Input, setToast, TOAST_TYPE } from "@plane/ui";
+// helpers
+import { WEB_BASE_URL } from "@/helpers/common.helper";
+// hooks
+import { useWorkspace } from "@/hooks/store";
+// services
+import { WorkspaceService } from "@/services/workspace.service";
+
+const workspaceService = new WorkspaceService();
+
+export const WorkspaceCreateForm = () => {
+  // router
+  const router = useRouter();
+  // states
+  const [slugError, setSlugError] = useState(false);
+  const [invalidSlug, setInvalidSlug] = useState(false);
+  const [defaultValues, setDefaultValues] = useState<Partial<IWorkspace>>({
+    name: "",
+    slug: "",
+    organization_size: "",
+  });
+  // store hooks
+  const { createWorkspace } = useWorkspace();
+  // form info
+  const {
+    handleSubmit,
+    control,
+    setValue,
+    getValues,
+    formState: { errors, isSubmitting, isValid },
+  } = useForm<IWorkspace>({ defaultValues, mode: "onChange" });
+  // derived values
+  const workspaceBaseURL = encodeURI(WEB_BASE_URL || window.location.origin + "/");
+
+  const handleCreateWorkspace = async (formData: IWorkspace) => {
+    await workspaceService
+      .workspaceSlugCheck(formData.slug)
+      .then(async (res) => {
+        if (res.status === true && !RESTRICTED_URLS.includes(formData.slug)) {
+          setSlugError(false);
+          await createWorkspace(formData)
+            .then(async () => {
+              setToast({
+                type: TOAST_TYPE.SUCCESS,
+                title: "Success!",
+                message: "Workspace created successfully.",
+              });
+              router.push(`/workspace`);
+            })
+            .catch(() => {
+              setToast({
+                type: TOAST_TYPE.ERROR,
+                title: "Error!",
+                message: "Workspace could not be created. Please try again.",
+              });
+            });
+        } else setSlugError(true);
+      })
+      .catch(() => {
+        setToast({
+          type: TOAST_TYPE.ERROR,
+          title: "Error!",
+          message: "Some error occurred while creating workspace. Please try again.",
+        });
+      });
+  };
+
+  useEffect(
+    () => () => {
+      // when the component unmounts set the default values to whatever user typed in
+      setDefaultValues(getValues());
+    },
+    [getValues, setDefaultValues]
+  );
+
+  return (
+    <div className="space-y-8">
+      <div className="grid-col grid w-full max-w-4xl grid-cols-1 items-start justify-between gap-x-10 gap-y-6 lg:grid-cols-2">
+        <div className="flex flex-col gap-1">
+          <h4 className="text-sm text-custom-text-300">Name your workspace</h4>
+          <div className="flex flex-col gap-1">
+            <Controller
+              control={control}
+              name="name"
+              rules={{
+                required: "This is a required field.",
+                validate: (value) =>
+                  /^[\w\s-]*$/.test(value) ||
+                  `Workspaces names can contain only (" "), ( - ), ( _ ) and alphanumeric characters.`,
+                maxLength: {
+                  value: 80,
+                  message: "Limit your name to 80 characters.",
+                },
+              }}
+              render={({ field: { value, ref, onChange } }) => (
+                <Input
+                  id="workspaceName"
+                  type="text"
+                  value={value}
+                  onChange={(e) => {
+                    onChange(e.target.value);
+                    setValue("name", e.target.value);
+                    setValue("slug", e.target.value.toLocaleLowerCase().trim().replace(/ /g, "-"), {
+                      shouldValidate: true,
+                    });
+                  }}
+                  ref={ref}
+                  hasError={Boolean(errors.name)}
+                  placeholder="Something familiar and recognizable is always best."
+                  className="w-full"
+                />
+              )}
+            />
+            <span className="text-xs text-red-500">{errors?.name?.message}</span>
+          </div>
+        </div>
+        <div className="flex flex-col gap-1">
+          <h4 className="text-sm text-custom-text-300">Set your workspace&apos;s URL</h4>
+          <div className="flex gap-0.5 w-full items-center rounded-md border-[0.5px] border-custom-border-200 px-3">
+            <span className="whitespace-nowrap text-sm text-custom-text-200">{workspaceBaseURL}</span>
+            <Controller
+              control={control}
+              name="slug"
+              rules={{
+                required: "The URL is a required field.",
+                maxLength: {
+                  value: 48,
+                  message: "Limit your URL to 48 characters.",
+                },
+              }}
+              render={({ field: { onChange, value, ref } }) => (
+                <Input
+                  id="workspaceUrl"
+                  type="text"
+                  value={value.toLocaleLowerCase().trim().replace(/ /g, "-")}
+                  onChange={(e) => {
+                    if (/^[a-zA-Z0-9_-]+$/.test(e.target.value)) setInvalidSlug(false);
+                    else setInvalidSlug(true);
+                    onChange(e.target.value.toLowerCase());
+                  }}
+                  ref={ref}
+                  hasError={Boolean(errors.slug)}
+                  placeholder="workspace-name"
+                  className="block w-full rounded-md border-none bg-transparent !px-0 py-2 text-sm"
+                />
+              )}
+            />
+          </div>
+          {slugError && <p className="text-sm text-red-500">This URL is taken. Try something else.</p>}
+          {invalidSlug && (
+            <p className="text-sm text-red-500">{`URLs can contain only ( - ), ( _ ) and alphanumeric characters.`}</p>
+          )}
+          {errors.slug && <span className="text-xs text-red-500">{errors.slug.message}</span>}
+        </div>
+        <div className="flex flex-col gap-1">
+          <h4 className="text-sm text-custom-text-300">How many people will use this workspace?</h4>
+          <div className="w-full">
+            <Controller
+              name="organization_size"
+              control={control}
+              rules={{ required: "This is a required field." }}
+              render={({ field: { value, onChange } }) => (
+                <CustomSelect
+                  value={value}
+                  onChange={onChange}
+                  label={
+                    ORGANIZATION_SIZE.find((c) => c === value) ?? (
+                      <span className="text-custom-text-400">Select a range</span>
+                    )
+                  }
+                  buttonClassName="!border-[0.5px] !border-custom-border-200 !shadow-none"
+                  input
+                  optionsClassName="w-full"
+                >
+                  {ORGANIZATION_SIZE.map((item) => (
+                    <CustomSelect.Option key={item} value={item}>
+                      {item}
+                    </CustomSelect.Option>
+                  ))}
+                </CustomSelect>
+              )}
+            />
+            {errors.organization_size && (
+              <span className="text-sm text-red-500">{errors.organization_size.message}</span>
+            )}
+          </div>
+        </div>
+      </div>
+      <div className="flex max-w-4xl items-center py-1 gap-4">
+        <Button
+          variant="primary"
+          size="sm"
+          onClick={handleSubmit(handleCreateWorkspace)}
+          disabled={!isValid}
+          loading={isSubmitting}
+        >
+          {isSubmitting ? "Creating workspace" : "Create workspace"}
+        </Button>
+        <Link className={getButtonStyling("neutral-primary", "sm")} href="/workspace">
+          Go back
+        </Link>
+      </div>
+    </div>
+  );
+};

admin/app/workspace/create/page.tsx

@@ -0,0 +1,21 @@
+"use client";
+
+import { observer } from "mobx-react";
+// components
+import { WorkspaceCreateForm } from "./form";
+
+const WorkspaceCreatePage = observer(() => (
+  <div className="relative container mx-auto w-full h-full p-4 py-4 space-y-6 flex flex-col">
+    <div className="border-b border-custom-border-100 mx-4 py-4 space-y-1 flex-shrink-0">
+      <div className="text-xl font-medium text-custom-text-100">Create a new workspace on this instance.</div>
+      <div className="text-sm font-normal text-custom-text-300">
+        You will need to invite users from Workspace Settings after you create this workspace.
+      </div>
+    </div>
+    <div className="flex-grow overflow-hidden overflow-y-scroll vertical-scrollbar scrollbar-md px-4">
+      <WorkspaceCreateForm />
+    </div>
+  </div>
+));
+
+export default WorkspaceCreatePage;

admin/app/workspace/layout.tsx

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+import { Metadata } from "next";
+// layouts
+import { AdminLayout } from "@/layouts/admin-layout";
+
+export const metadata: Metadata = {
+  title: "Workspace Management - Plane Web",
+};
+
+export default function WorkspaceManagementLayout({ children }: { children: ReactNode }) {
+  return <AdminLayout>{children}</AdminLayout>;
+}

admin/app/workspace/page.tsx

@@ -0,0 +1,169 @@
+"use client";
+
+import { useState } from "react";
+import { observer } from "mobx-react";
+import Link from "next/link";
+import useSWR from "swr";
+import { Loader as LoaderIcon } from "lucide-react";
+// types
+import { TInstanceConfigurationKeys } from "@plane/types";
+// ui
+import { Button, getButtonStyling, Loader, setPromiseToast, ToggleSwitch } from "@plane/ui";
+// components
+import { WorkspaceListItem } from "@/components/workspace";
+// helpers
+import { cn } from "@/helpers/common.helper";
+// hooks
+import { useInstance, useWorkspace } from "@/hooks/store";
+
+const WorkspaceManagementPage = observer(() => {
+  // states
+  const [isSubmitting, setIsSubmitting] = useState<boolean>(false);
+  // store
+  const { formattedConfig, fetchInstanceConfigurations, updateInstanceConfigurations } = useInstance();
+  const {
+    workspaceIds,
+    loader: workspaceLoader,
+    paginationInfo,
+    fetchWorkspaces,
+    fetchNextWorkspaces,
+  } = useWorkspace();
+  // derived values
+  const disableWorkspaceCreation = formattedConfig?.DISABLE_WORKSPACE_CREATION ?? "";
+  const hasNextPage = paginationInfo?.next_page_results && paginationInfo?.next_cursor !== undefined;
+
+  // fetch data
+  useSWR("INSTANCE_CONFIGURATIONS", () => fetchInstanceConfigurations());
+  useSWR("INSTANCE_WORKSPACES", () => fetchWorkspaces());
+
+  const updateConfig = async (key: TInstanceConfigurationKeys, value: string) => {
+    setIsSubmitting(true);
+
+    const payload = {
+      [key]: value,
+    };
+
+    const updateConfigPromise = updateInstanceConfigurations(payload);
+
+    setPromiseToast(updateConfigPromise, {
+      loading: "Saving configuration",
+      success: {
+        title: "Success",
+        message: () => "Configuration saved successfully",
+      },
+      error: {
+        title: "Error",
+        message: () => "Failed to save configuration",
+      },
+    });
+
+    await updateConfigPromise
+      .then(() => {
+        setIsSubmitting(false);
+      })
+      .catch((err) => {
+        console.error(err);
+        setIsSubmitting(false);
+      });
+  };
+
+  return (
+    <div className="relative container mx-auto w-full h-full p-4 py-4 space-y-6 flex flex-col">
+      <div className="flex items-center justify-between gap-4 border-b border-custom-border-100 mx-4 py-4 space-y-1 flex-shrink-0">
+        <div className="flex flex-col gap-1">
+          <div className="text-xl font-medium text-custom-text-100">Workspaces on this instance</div>
+          <div className="text-sm font-normal text-custom-text-300">
+            See all workspaces and control who can create them.
+          </div>
+        </div>
+      </div>
+      <div className="flex-grow overflow-hidden overflow-y-scroll vertical-scrollbar scrollbar-md px-4">
+        <div className="space-y-3">
+          {formattedConfig ? (
+            <div className={cn("w-full flex items-center gap-14 rounded")}>
+              <div className="flex grow items-center gap-4">
+                <div className="grow">
+                  <div className="text-lg font-medium pb-1">Prevent anyone else from creating a workspace.</div>
+                  <div className={cn("font-normal leading-5 text-custom-text-300 text-xs")}>
+                    Toggling this on will let only you create workspaces. You will have to invite users to new
+                    workspaces.
+                  </div>
+                </div>
+              </div>
+              <div className={`shrink-0 pr-4 ${isSubmitting && "opacity-70"}`}>
+                <div className="flex items-center gap-4">
+                  <ToggleSwitch
+                    value={Boolean(parseInt(disableWorkspaceCreation))}
+                    onChange={() => {
+                      if (Boolean(parseInt(disableWorkspaceCreation)) === true) {
+                        updateConfig("DISABLE_WORKSPACE_CREATION", "0");
+                      } else {
+                        updateConfig("DISABLE_WORKSPACE_CREATION", "1");
+                      }
+                    }}
+                    size="sm"
+                    disabled={isSubmitting}
+                  />
+                </div>
+              </div>
+            </div>
+          ) : (
+            <Loader>
+              <Loader.Item height="50px" width="100%" />
+            </Loader>
+          )}
+          {workspaceLoader !== "init-loader" ? (
+            <>
+              <div className="pt-6 flex items-center justify-between gap-2">
+                <div className="flex flex-col items-start gap-x-2">
+                  <div className="flex items-center gap-2 text-lg font-medium">
+                    All workspaces on this instance{" "}
+                    <span className="text-custom-text-300">• {workspaceIds.length}</span>
+                    {workspaceLoader && ["mutation", "pagination"].includes(workspaceLoader) && (
+                      <LoaderIcon className="w-4 h-4 animate-spin" />
+                    )}
+                  </div>
+                  <div className={cn("font-normal leading-5 text-custom-text-300 text-xs")}>
+                    You can&apos;t yet delete workspaces and you can only go to the workspace if you are an Admin or a
+                    Member.
+                  </div>
+                </div>
+                <div className="flex items-center gap-2">
+                  <Link href="/workspace/create" className={getButtonStyling("primary", "sm")}>
+                    Create workspace
+                  </Link>
+                </div>
+              </div>
+              <div className="flex flex-col gap-4 py-2">
+                {workspaceIds.map((workspaceId) => (
+                  <WorkspaceListItem key={workspaceId} workspaceId={workspaceId} />
+                ))}
+              </div>
+              {hasNextPage && (
+                <div className="flex justify-center">
+                  <Button
+                    variant="link-primary"
+                    onClick={() => fetchNextWorkspaces()}
+                    disabled={workspaceLoader === "pagination"}
+                  >
+                    Load more
+                    {workspaceLoader === "pagination" && <LoaderIcon className="w-3 h-3 animate-spin" />}
+                  </Button>
+                </div>
+              )}
+            </>
+          ) : (
+            <Loader className="space-y-10 py-8">
+              <Loader.Item height="24px" width="20%" />
+              <Loader.Item height="92px" width="100%" />
+              <Loader.Item height="92px" width="100%" />
+              <Loader.Item height="92px" width="100%" />
+            </Loader>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+});
+
+export default WorkspaceManagementPage;

admin/ce/components/common/upgrade-button.tsx

@@ -9,8 +9,8 @@ import { getButtonStyling } from "@plane/ui";
 import { cn } from "@/helpers/common.helper";
 
 export const UpgradeButton: React.FC = () => (
-  <a href="https://plane.so/one" target="_blank" className={cn(getButtonStyling("primary", "sm"))}>
-    Available on One
+  <a href="https://plane.so/pricing?mode=self-hosted" target="_blank" className={cn(getButtonStyling("primary", "sm"))}>
+    Upgrade
     <SquareArrowOutUpRight className="h-3.5 w-3.5 p-0.5" />
   </a>
 );

admin/core/components/admin-sidebar/help-section.tsx

@@ -52,13 +52,13 @@ export const HelpSection: FC = observer(() => {
       )}
     >
       <div className={`flex items-center gap-1 ${isSidebarCollapsed ? "flex-col justify-center" : "w-full"}`}>
-        <Tooltip tooltipContent="Redirect to plane" position="right" className="ml-4" disabled={!isSidebarCollapsed}>
+        <Tooltip tooltipContent="Redirect to Plane" position="right" className="ml-4" disabled={!isSidebarCollapsed}>
           <a
             href={redirectionLink}
             className={`relative px-2 py-1.5 flex items-center gap-2 font-medium rounded border border-custom-primary-100/20 bg-custom-primary-100/10 text-xs text-custom-primary-200 whitespace-nowrap`}
           >
             <ExternalLink size={14} />
-            {!isSidebarCollapsed && "Redirect to plane"}
+            {!isSidebarCollapsed && "Redirect to Plane"}
           </a>
         </Tooltip>
         <Tooltip tooltipContent="Help" position={isSidebarCollapsed ? "right" : "top"} className="ml-4">

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

@@ -3,7 +3,7 @@
 import { FC, useEffect, useRef } from "react";
 import { observer } from "mobx-react";
 // plane helpers
-import { useOutsideClickDetector } from "@plane/helpers";
+import { useOutsideClickDetector } from "@plane/hooks";
 // components
 import { HelpSection, SidebarMenu, SidebarDropdown } from "@/components/admin-sidebar";
 // hooks

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

@@ -4,7 +4,7 @@ import { observer } from "mobx-react";
 import Link from "next/link";
 import { usePathname } from "next/navigation";
 import { Image, BrainCog, Cog, Lock, Mail } from "lucide-react";
-import { Tooltip } from "@plane/ui";
+import { Tooltip, WorkspaceIcon } from "@plane/ui";
 // hooks
 import { cn } from "@/helpers/common.helper";
 import { useTheme } from "@/hooks/store";
@@ -14,31 +14,37 @@ const INSTANCE_ADMIN_LINKS = [
   {
     Icon: Cog,
     name: "General",
-    description: "Identify your instances and get key details",
+    description: "Identify your instances and get key details.",
     href: `/general/`,
   },
+  {
+    Icon: WorkspaceIcon,
+    name: "Workspaces",
+    description: "Manage all workspaces on this instance.",
+    href: `/workspace/`,
+  },
   {
     Icon: Mail,
     name: "Email",
-    description: "Set up emails to your users",
+    description: "Configure your SMTP controls.",
     href: `/email/`,
   },
   {
     Icon: Lock,
     name: "Authentication",
-    description: "Configure authentication modes",
+    description: "Configure authentication modes.",
     href: `/authentication/`,
   },
   {
     Icon: BrainCog,
     name: "Artificial intelligence",
-    description: "Configure your OpenAI creds",
+    description: "Configure your OpenAI creds.",
     href: `/ai/`,
   },
   {
     Icon: Image,
     name: "Images in Plane",
-    description: "Allow third-party image libraries",
+    description: "Allow third-party image libraries.",
     href: `/image/`,
   },
 ];

admin/core/components/auth-header.tsx

@@ -30,9 +30,13 @@ export const InstanceHeader: FC = observer(() => {
       case "google":
         return "Google";
       case "github":
-        return "Github";
+        return "GitHub";
       case "gitlab":
         return "GitLab";
+      case "workspace":
+        return "Workspace";
+      case "create":
+        return "Create";
       default:
         return pathName.toUpperCase();
     }

admin/core/components/new-user-popup.tsx

@@ -1,13 +1,13 @@
 "use client";
 
 import React from "react";
+import { resolveGeneralTheme } from "helpers/common.helper";
 import { observer } from "mobx-react";
 import Image from "next/image";
+import Link from "next/link";
 import { useTheme as nextUseTheme } from "next-themes";
 // ui
 import { Button, getButtonStyling } from "@plane/ui";
-// helpers
-import { WEB_BASE_URL, resolveGeneralTheme } from "helpers/common.helper";
 // hooks
 import { useTheme } from "@/hooks/store";
 // icons
@@ -20,8 +20,6 @@ export const NewUserPopup: React.FC = observer(() => {
   // theme
   const { resolvedTheme } = nextUseTheme();
 
-  const redirectionLink = encodeURI(WEB_BASE_URL + "/create-workspace");
-
   if (!isNewUserPopup) return <></>;
   return (
     <div className="absolute bottom-8 right-8 p-6 w-96 border border-custom-border-100 shadow-md rounded-lg bg-custom-background-100">
@@ -30,12 +28,12 @@ export const NewUserPopup: React.FC = observer(() => {
           <div className="text-base font-semibold">Create workspace</div>
           <div className="py-2 text-sm font-medium text-custom-text-300">
             Instance setup done! Welcome to Plane instance portal. Start your journey with by creating your first
-            workspace, you will need to login again.
+            workspace.
           </div>
           <div className="flex items-center gap-4 pt-2">
-            <a href={redirectionLink} className={getButtonStyling("primary", "sm")}>
+            <Link href="/workspace/create" className={getButtonStyling("primary", "sm")}>
               Create workspace
-            </a>
+            </Link>
             <Button variant="neutral-primary" size="sm" onClick={toggleNewUserPopup}>
               Close
             </Button>

admin/core/components/workspace/index.ts

@@ -0,0 +1 @@
+export * from "./list-item";

admin/core/components/workspace/list-item.tsx

@@ -0,0 +1,81 @@
+import { observer } from "mobx-react";
+import { ExternalLink } from "lucide-react";
+// helpers
+import { Tooltip } from "@plane/ui";
+import { WEB_BASE_URL } from "@/helpers/common.helper";
+import { getFileURL } from "@/helpers/file.helper";
+// hooks
+import { useWorkspace } from "@/hooks/store";
+
+type TWorkspaceListItemProps = {
+  workspaceId: string;
+};
+
+export const WorkspaceListItem = observer(({ workspaceId }: TWorkspaceListItemProps) => {
+  // store hooks
+  const { getWorkspaceById } = useWorkspace();
+  // derived values
+  const workspace = getWorkspaceById(workspaceId);
+
+  if (!workspace) return null;
+  return (
+    <a
+      key={workspaceId}
+      href={`${WEB_BASE_URL}/${encodeURIComponent(workspace.slug)}`}
+      target="_blank"
+      className="group flex items-center justify-between p-4 gap-2.5 truncate border border-custom-border-200/70 hover:border-custom-border-200 hover:bg-custom-background-90 rounded-md"
+    >
+      <div className="flex items-start gap-4">
+        <span
+          className={`relative flex h-8 w-8 flex-shrink-0 items-center justify-center p-2 mt-1 text-xs uppercase ${
+            !workspace?.logo_url && "rounded bg-custom-primary-500 text-white"
+          }`}
+        >
+          {workspace?.logo_url && workspace.logo_url !== "" ? (
+            <img
+              src={getFileURL(workspace.logo_url)}
+              className="absolute left-0 top-0 h-full w-full rounded object-cover"
+              alt="Workspace Logo"
+            />
+          ) : (
+            (workspace?.name?.[0] ?? "...")
+          )}
+        </span>
+        <div className="flex flex-col items-start gap-1">
+          <div className="flex flex-wrap w-full items-center gap-2.5">
+            <h3 className={`text-base font-medium capitalize`}>{workspace.name}</h3>/
+            <Tooltip tooltipContent="The unique URL of your workspace">
+              <h4 className="text-sm text-custom-text-300">[{workspace.slug}]</h4>
+            </Tooltip>
+          </div>
+          {workspace.owner.email && (
+            <div className="flex items-center gap-1 text-xs">
+              <h3 className="text-custom-text-200 font-medium">Owned by:</h3>
+              <h4 className="text-custom-text-300">{workspace.owner.email}</h4>
+            </div>
+          )}
+          <div className="flex items-center gap-2.5 text-xs">
+            {workspace.total_projects !== null && (
+              <span className="flex items-center gap-1">
+                <h3 className="text-custom-text-200 font-medium">Total projects:</h3>
+                <h4 className="text-custom-text-300">{workspace.total_projects}</h4>
+              </span>
+            )}
+            {workspace.total_members !== null && (
+              <>
+                •
+                <span className="flex items-center gap-1">
+                  <h3 className="text-custom-text-200 font-medium">Total members:</h3>
+                  <h4 className="text-custom-text-300">{workspace.total_members}</h4>
+                </span>
+              </>
+            )}
+          </div>
+        </div>
+      </div>
+      <div className="flex-shrink-0">
+        <ExternalLink size={14} className="text-custom-text-400 group-hover:text-custom-text-200" />
+      </div>
+    </a>
+  );
+});

admin/core/hooks/store/index.ts

@@ -1,3 +1,4 @@
 export * from "./use-theme";
 export * from "./use-instance";
 export * from "./use-user";
+export * from "./use-workspace";

admin/core/hooks/store/use-workspace.tsx

@@ -0,0 +1,10 @@
+import { useContext } from "react";
+// store
+import { StoreContext } from "@/lib/store-provider";
+import { IWorkspaceStore } from "@/store/workspace.store";
+
+export const useWorkspace = (): IWorkspaceStore => {
+  const context = useContext(StoreContext);
+  if (context === undefined) throw new Error("useWorkspace must be used within StoreProvider");
+  return context.workspace;
+};

admin/core/services/workspace.service.ts

@@ -0,0 +1,53 @@
+// types
+import type { IWorkspace, TWorkspacePaginationInfo } from "@plane/types";
+// helpers
+import { API_BASE_URL } from "@/helpers/common.helper";
+// services
+import { APIService } from "@/services/api.service";
+
+export class WorkspaceService extends APIService {
+  constructor() {
+    super(API_BASE_URL);
+  }
+
+  /**
+   * @description Fetches all workspaces
+   * @returns Promise<TWorkspacePaginationInfo>
+   */
+  async getWorkspaces(nextPageCursor?: string): Promise<TWorkspacePaginationInfo> {
+    return this.get<TWorkspacePaginationInfo>("/api/instances/workspaces/", {
+      cursor: nextPageCursor,
+    })
+      .then((response) => response.data)
+      .catch((error) => {
+        throw error?.response?.data;
+      });
+  }
+
+  /**
+   * @description Checks if a slug is available
+   * @param slug - string
+   * @returns Promise<any>
+   */
+  async workspaceSlugCheck(slug: string): Promise<any> {
+    const params = new URLSearchParams({ slug });
+    return this.get(`/api/instances/workspace-slug-check/?${params.toString()}`)
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data;
+      });
+  }
+
+  /**
+   * @description Creates a new workspace
+   * @param data - IWorkspace
+   * @returns Promise<IWorkspace>
+   */
+  async createWorkspace(data: IWorkspace): Promise<IWorkspace> {
+    return this.post<IWorkspace, IWorkspace>("/api/instances/workspaces/", data)
+      .then((response) => response.data)
+      .catch((error) => {
+        throw error?.response?.data;
+      });
+  }
+}

admin/core/store/root.store.ts

@@ -3,6 +3,7 @@ import { enableStaticRendering } from "mobx-react";
 import { IInstanceStore, InstanceStore } from "./instance.store";
 import { IThemeStore, ThemeStore } from "./theme.store";
 import { IUserStore, UserStore } from "./user.store";
+import { IWorkspaceStore, WorkspaceStore } from "./workspace.store";
 
 enableStaticRendering(typeof window === "undefined");
 
@@ -10,17 +11,20 @@ export abstract class CoreRootStore {
   theme: IThemeStore;
   instance: IInstanceStore;
   user: IUserStore;
+  workspace: IWorkspaceStore;
 
   constructor() {
     this.theme = new ThemeStore(this);
     this.instance = new InstanceStore(this);
     this.user = new UserStore(this);
+    this.workspace = new WorkspaceStore(this);
   }
 
   hydrate(initialData: any) {
     this.theme.hydrate(initialData.theme);
     this.instance.hydrate(initialData.instance);
     this.user.hydrate(initialData.user);
+    this.workspace.hydrate(initialData.workspace);
   }
 
   resetOnSignOut() {
@@ -28,5 +32,6 @@ export abstract class CoreRootStore {
     this.instance = new InstanceStore(this);
     this.user = new UserStore(this);
     this.theme = new ThemeStore(this);
+    this.workspace = new WorkspaceStore(this);
   }
 }

admin/core/store/workspace.store.ts

@@ -0,0 +1,150 @@
+import set from "lodash/set";
+import { action, observable, runInAction, makeObservable, computed } from "mobx";
+import { IWorkspace, TLoader, TPaginationInfo } from "@plane/types";
+// services
+import { WorkspaceService } from "@/services/workspace.service";
+// root store
+import { CoreRootStore } from "@/store/root.store";
+
+export interface IWorkspaceStore {
+  // observables
+  loader: TLoader;
+  workspaces: Record<string, IWorkspace>;
+  paginationInfo: TPaginationInfo | undefined;
+  // computed
+  workspaceIds: string[];
+  // helper actions
+  hydrate: (data: Record<string, IWorkspace>) => void;
+  getWorkspaceById: (workspaceId: string) => IWorkspace | undefined;
+  // fetch actions
+  fetchWorkspaces: () => Promise<IWorkspace[]>;
+  fetchNextWorkspaces: () => Promise<IWorkspace[]>;
+  // curd actions
+  createWorkspace: (data: IWorkspace) => Promise<IWorkspace>;
+}
+
+export class WorkspaceStore implements IWorkspaceStore {
+  // observables
+  loader: TLoader = "init-loader";
+  workspaces: Record<string, IWorkspace> = {};
+  paginationInfo: TPaginationInfo | undefined = undefined;
+  // services
+  workspaceService;
+
+  constructor(private store: CoreRootStore) {
+    makeObservable(this, {
+      // observables
+      loader: observable,
+      workspaces: observable,
+      paginationInfo: observable,
+      // computed
+      workspaceIds: computed,
+      // helper actions
+      hydrate: action,
+      getWorkspaceById: action,
+      // fetch actions
+      fetchWorkspaces: action,
+      fetchNextWorkspaces: action,
+      // curd actions
+      createWorkspace: action,
+    });
+    this.workspaceService = new WorkspaceService();
+  }
+
+  // computed
+  get workspaceIds() {
+    return Object.keys(this.workspaces);
+  }
+
+  // helper actions
+  /**
+   * @description Hydrates the workspaces
+   * @param data - Record<string, IWorkspace>
+   */
+  hydrate = (data: Record<string, IWorkspace>) => {
+    if (data) this.workspaces = data;
+  };
+
+  /**
+   * @description Gets a workspace by id
+   * @param workspaceId - string
+   * @returns IWorkspace | undefined
+   */
+  getWorkspaceById = (workspaceId: string) => this.workspaces[workspaceId];
+
+  // fetch actions
+  /**
+   * @description Fetches all workspaces
+   * @returns Promise<>
+   */
+  fetchWorkspaces = async (): Promise<IWorkspace[]> => {
+    try {
+      if (this.workspaceIds.length > 0) {
+        this.loader = "mutation";
+      } else {
+        this.loader = "init-loader";
+      }
+      const paginatedWorkspaceData = await this.workspaceService.getWorkspaces();
+      runInAction(() => {
+        const { results, ...paginationInfo } = paginatedWorkspaceData;
+        results.forEach((workspace: IWorkspace) => {
+          set(this.workspaces, [workspace.id], workspace);
+        });
+        set(this, "paginationInfo", paginationInfo);
+      });
+      return paginatedWorkspaceData.results;
+    } catch (error) {
+      console.error("Error fetching workspaces", error);
+      throw error;
+    } finally {
+      this.loader = "loaded";
+    }
+  };
+
+  /**
+   * @description Fetches the next page of workspaces
+   * @returns Promise<IWorkspace[]>
+   */
+  fetchNextWorkspaces = async (): Promise<IWorkspace[]> => {
+    if (!this.paginationInfo || this.paginationInfo.next_page_results === false) return [];
+    try {
+      this.loader = "pagination";
+      const paginatedWorkspaceData = await this.workspaceService.getWorkspaces(this.paginationInfo.next_cursor);
+      runInAction(() => {
+        const { results, ...paginationInfo } = paginatedWorkspaceData;
+        results.forEach((workspace: IWorkspace) => {
+          set(this.workspaces, [workspace.id], workspace);
+        });
+        set(this, "paginationInfo", paginationInfo);
+      });
+      return paginatedWorkspaceData.results;
+    } catch (error) {
+      console.error("Error fetching next workspaces", error);
+      throw error;
+    } finally {
+      this.loader = "loaded";
+    }
+  };
+
+  // curd actions
+  /**
+   * @description Creates a new workspace
+   * @param data - IWorkspace
+   * @returns Promise<IWorkspace>
+   */
+  createWorkspace = async (data: IWorkspace): Promise<IWorkspace> => {
+    try {
+      this.loader = "mutation";
+      const workspace = await this.workspaceService.createWorkspace(data);
+      runInAction(() => {
+        set(this.workspaces, [workspace.id], workspace);
+      });
+      return workspace;
+    } catch (error) {
+      console.error("Error creating workspace", error);
+      throw error;
+    } finally {
+      this.loader = "loaded";
+    }
+  };
+}

admin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "admin",
-  "version": "0.23.1",
+  "version": "0.24.1",
   "private": true,
   "scripts": {
     "dev": "turbo run develop",
@@ -14,9 +14,10 @@
   "dependencies": {
     "@headlessui/react": "^1.7.19",
     "@plane/constants": "*",
-    "@plane/helpers": "*",
+    "@plane/hooks": "*",
     "@plane/types": "*",
     "@plane/ui": "*",
+    "@plane/utils": "*",
     "@sentry/nextjs": "^8.32.0",
     "@tailwindcss/typography": "^0.5.9",
     "@types/lodash": "^4.17.0",
@@ -26,7 +27,7 @@
     "lucide-react": "^0.356.0",
     "mobx": "^6.12.0",
     "mobx-react": "^9.1.1",
-    "next": "^14.2.12",
+    "next": "^14.2.20",
     "next-themes": "^0.2.1",
     "postcss": "^8.4.38",
     "react": "^18.3.1",

apiserver/Dockerfile.api

@@ -4,7 +4,7 @@ FROM python:3.12.5-alpine AS backend
 ENV PYTHONDONTWRITEBYTECODE 1
 ENV PYTHONUNBUFFERED 1
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
-ENV INSTANCE_CHANGELOG_URL https://api.plane.so/api/public/anchor/8e1c2e4c7bc5493eb7731be3862f6960/pages/
+ENV INSTANCE_CHANGELOG_URL https://sites.plane.so/pages/691ef037bcfe416a902e48cb55f59891/
 
 WORKDIR /code
 

apiserver/Dockerfile.dev

@@ -4,7 +4,7 @@ FROM python:3.12.5-alpine AS backend
 ENV PYTHONDONTWRITEBYTECODE 1
 ENV PYTHONUNBUFFERED 1
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
-ENV INSTANCE_CHANGELOG_URL https://api.plane.so/api/public/anchor/8e1c2e4c7bc5493eb7731be3862f6960/pages/
+ENV INSTANCE_CHANGELOG_URL https://sites.plane.so/pages/691ef037bcfe416a902e48cb55f59891/
 
 RUN apk --no-cache add \
     "bash~=5.2" \

apiserver/package.json

@@ -1,4 +1,4 @@
 {
   "name": "plane-api",
-  "version": "0.23.1"
+  "version": "0.24.1"
 }

apiserver/plane/api/serializers/cycle.py

@@ -4,7 +4,7 @@ from rest_framework import serializers
 # Module imports
 from .base import BaseSerializer
 from plane.db.models import Cycle, CycleIssue
-
+from plane.utils.timezone_converter import convert_to_utc
 
 class CycleSerializer(BaseSerializer):
     total_issues = serializers.IntegerField(read_only=True)
@@ -24,6 +24,18 @@ class CycleSerializer(BaseSerializer):
             and data.get("start_date", None) > data.get("end_date", None)
         ):
             raise serializers.ValidationError("Start date cannot exceed end date")
+
+        if (
+            data.get("start_date", None) is not None
+            and data.get("end_date", None) is not None
+        ):
+            project_id = self.initial_data.get("project_id") or self.instance.project_id
+            data["start_date"] = convert_to_utc(
+                str(data.get("start_date").date()), project_id, is_start_date=True
+            )
+            data["end_date"] = convert_to_utc(
+                str(data.get("end_date", None).date()), project_id
+            )
         return data
 
     class Meta:

apiserver/plane/api/views/project.py

@@ -258,9 +258,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                 ProjectSerializer(project).data, cls=DjangoJSONEncoder
             )
 
-            intake_view = request.data.get(
-                "inbox_view", request.data.get("intake_view", False)
-            )
+            intake_view = request.data.get("inbox_view", project.intake_view)
 
             if project.archived_at:
                 return Response(

apiserver/plane/app/serializers/__init__.py

@@ -13,7 +13,6 @@ from .user import (
 from .workspace import (
     WorkSpaceSerializer,
     WorkSpaceMemberSerializer,
-    TeamSerializer,
     WorkSpaceMemberInviteSerializer,
     WorkspaceLiteSerializer,
     WorkspaceThemeSerializer,

apiserver/plane/app/serializers/cycle.py

@@ -5,6 +5,7 @@ from rest_framework import serializers
 from .base import BaseSerializer
 from .issue import IssueStateSerializer
 from plane.db.models import Cycle, CycleIssue, CycleUserProperties
+from plane.utils.timezone_converter import convert_to_utc
 
 
 class CycleWriteSerializer(BaseSerializer):
@@ -15,6 +16,17 @@ class CycleWriteSerializer(BaseSerializer):
             and data.get("start_date", None) > data.get("end_date", None)
         ):
             raise serializers.ValidationError("Start date cannot exceed end date")
+        if (
+            data.get("start_date", None) is not None
+            and data.get("end_date", None) is not None
+        ):
+            project_id = self.initial_data.get("project_id") or self.instance.project_id
+            data["start_date"] = convert_to_utc(
+                str(data.get("start_date").date()), project_id, is_start_date=True
+            )
+            data["end_date"] = convert_to_utc(
+                str(data.get("end_date", None).date()), project_id
+            )
         return data
 
     class Meta:

apiserver/plane/app/serializers/workspace.py

@@ -6,11 +6,8 @@ from .base import BaseSerializer, DynamicBaseSerializer
 from .user import UserLiteSerializer, UserAdminLiteSerializer
 
 from plane.db.models import (
-    User,
     Workspace,
     WorkspaceMember,
-    Team,
-    TeamMember,
     WorkspaceMemberInvite,
     WorkspaceTheme,
     WorkspaceUserProperties,
@@ -97,52 +94,6 @@ class WorkSpaceMemberInviteSerializer(BaseSerializer):
         ]
 
 
-class TeamSerializer(BaseSerializer):
-    members_detail = UserLiteSerializer(read_only=True, source="members", many=True)
-    members = serializers.ListField(
-        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
-        write_only=True,
-        required=False,
-    )
-
-    class Meta:
-        model = Team
-        fields = "__all__"
-        read_only_fields = [
-            "workspace",
-            "created_by",
-            "updated_by",
-            "created_at",
-            "updated_at",
-        ]
-
-    def create(self, validated_data, **kwargs):
-        if "members" in validated_data:
-            members = validated_data.pop("members")
-            workspace = self.context["workspace"]
-            team = Team.objects.create(**validated_data, workspace=workspace)
-            team_members = [
-                TeamMember(member=member, team=team, workspace=workspace)
-                for member in members
-            ]
-            TeamMember.objects.bulk_create(team_members, batch_size=10)
-            return team
-        team = Team.objects.create(**validated_data)
-        return team
-
-    def update(self, instance, validated_data):
-        if "members" in validated_data:
-            members = validated_data.pop("members")
-            TeamMember.objects.filter(team=instance).delete()
-            team_members = [
-                TeamMember(member=member, team=instance, workspace=instance.workspace)
-                for member in members
-            ]
-            TeamMember.objects.bulk_create(team_members, batch_size=10)
-            return super().update(instance, validated_data)
-        return super().update(instance, validated_data)
-
-
 class WorkspaceThemeSerializer(BaseSerializer):
     class Meta:
         model = WorkspaceTheme

apiserver/plane/app/urls/project.py

@@ -7,7 +7,6 @@ from plane.app.views import (
     ProjectMemberViewSet,
     ProjectMemberUserEndpoint,
     ProjectJoinEndpoint,
-    AddTeamToProjectEndpoint,
     ProjectUserViewsEndpoint,
     ProjectIdentifierEndpoint,
     ProjectFavoritesViewSet,
@@ -83,11 +82,6 @@ urlpatterns = [
         ProjectMemberViewSet.as_view({"post": "leave"}),
         name="project-member",
     ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/team-invite/",
-        AddTeamToProjectEndpoint.as_view(),
-        name="projects",
-    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/project-views/",
         ProjectUserViewsEndpoint.as_view(),

apiserver/plane/app/urls/workspace.py

@@ -10,7 +10,6 @@ from plane.app.views import (
     WorkspaceMemberUserEndpoint,
     WorkspaceMemberUserViewsEndpoint,
     WorkSpaceAvailabilityCheckEndpoint,
-    TeamMemberViewSet,
     UserLastProjectWithWorkspaceEndpoint,
     WorkspaceThemeViewSet,
     WorkspaceUserProfileStatsEndpoint,
@@ -100,23 +99,6 @@ urlpatterns = [
         WorkSpaceMemberViewSet.as_view({"post": "leave"}),
         name="leave-workspace-members",
     ),
-    path(
-        "workspaces/<str:slug>/teams/",
-        TeamMemberViewSet.as_view({"get": "list", "post": "create"}),
-        name="workspace-team-members",
-    ),
-    path(
-        "workspaces/<str:slug>/teams/<uuid:pk>/",
-        TeamMemberViewSet.as_view(
-            {
-                "put": "update",
-                "patch": "partial_update",
-                "delete": "destroy",
-                "get": "retrieve",
-            }
-        ),
-        name="workspace-team-members",
-    ),
     path(
         "users/last-visited-workspace/",
         UserLastProjectWithWorkspaceEndpoint.as_view(),

apiserver/plane/app/views/__init__.py

@@ -16,7 +16,6 @@ from .project.invite import (
 
 from .project.member import (
     ProjectMemberViewSet,
-    AddTeamToProjectEndpoint,
     ProjectMemberUserEndpoint,
     UserProjectRolesEndpoint,
 )
@@ -49,7 +48,6 @@ from .workspace.favorite import (
 
 from .workspace.member import (
     WorkSpaceMemberViewSet,
-    TeamMemberViewSet,
     WorkspaceMemberUserEndpoint,
     WorkspaceProjectMemberEndpoint,
     WorkspaceMemberUserViewsEndpoint,
@@ -88,8 +86,6 @@ from .cycle.base import (
     CycleFavoriteViewSet,
     TransferCycleIssueEndpoint,
     CycleUserPropertiesEndpoint,
-    CycleViewSet,
-    TransferCycleIssueEndpoint,
     CycleAnalyticsEndpoint,
     CycleProgressEndpoint,
 )
@@ -206,6 +202,5 @@ from .dashboard.base import DashboardEndpoint, WidgetsEndpoint
 
 from .error_404 import custom_404_view
 
-from .exporter.base import ExportIssuesEndpoint
 from .notification.base import MarkAllReadNotificationViewSet
 from .user.base import AccountEndpoint, ProfileEndpoint, UserSessionEndpoint

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

@@ -1,5 +1,7 @@
 # Python imports
 import json
+import pytz
+
 
 # Django imports
 from django.contrib.postgres.aggregates import ArrayAgg
@@ -52,6 +54,11 @@ from plane.bgtasks.recent_visited_task import recent_visited_task
 # Module imports
 from .. import BaseAPIView, BaseViewSet
 from plane.bgtasks.webhook_task import model_activity
+from plane.utils.timezone_converter import (
+    convert_utc_to_project_timezone,
+    convert_to_utc,
+    user_timezone_converter,
+)
 
 
 class CycleViewSet(BaseViewSet):
@@ -67,6 +74,19 @@ class CycleViewSet(BaseViewSet):
             project_id=self.kwargs.get("project_id"),
             workspace__slug=self.kwargs.get("slug"),
         )
+
+        project = Project.objects.get(id=self.kwargs.get("project_id"))
+
+        # Fetch project for the specific record or pass project_id dynamically
+        project_timezone = project.timezone
+
+        # Convert the current time (timezone.now()) to the project's timezone
+        local_tz = pytz.timezone(project_timezone)
+        current_time_in_project_tz = timezone.now().astimezone(local_tz)
+
+        # Convert project local time back to UTC for comparison (start_date is stored in UTC)
+        current_time_in_utc = current_time_in_project_tz.astimezone(pytz.utc)
+
         return self.filter_queryset(
             super()
             .get_queryset()
@@ -119,12 +139,15 @@ class CycleViewSet(BaseViewSet):
             .annotate(
                 status=Case(
                     When(
-                        Q(start_date__lte=timezone.now())
-                        & Q(end_date__gte=timezone.now()),
+                        Q(start_date__lte=current_time_in_utc)
+                        & Q(end_date__gte=current_time_in_utc),
                         then=Value("CURRENT"),
                     ),
-                    When(start_date__gt=timezone.now(), then=Value("UPCOMING")),
-                    When(end_date__lt=timezone.now(), then=Value("COMPLETED")),
+                    When(
+                        start_date__gt=current_time_in_utc,
+                        then=Value("UPCOMING"),
+                    ),
+                    When(end_date__lt=current_time_in_utc, then=Value("COMPLETED")),
                     When(
                         Q(start_date__isnull=True) & Q(end_date__isnull=True),
                         then=Value("DRAFT"),
@@ -160,10 +183,22 @@ class CycleViewSet(BaseViewSet):
         # Update the order by
         queryset = queryset.order_by("-is_favorite", "-created_at")
 
+        project = Project.objects.get(id=self.kwargs.get("project_id"))
+
+        # Fetch project for the specific record or pass project_id dynamically
+        project_timezone = project.timezone
+
+        # Convert the current time (timezone.now()) to the project's timezone
+        local_tz = pytz.timezone(project_timezone)
+        current_time_in_project_tz = timezone.now().astimezone(local_tz)
+
+        # Convert project local time back to UTC for comparison (start_date is stored in UTC)
+        current_time_in_utc = current_time_in_project_tz.astimezone(pytz.utc)
+
         # Current Cycle
         if cycle_view == "current":
             queryset = queryset.filter(
-                start_date__lte=timezone.now(), end_date__gte=timezone.now()
+                start_date__lte=current_time_in_utc, end_date__gte=current_time_in_utc
             )
 
             data = queryset.values(
@@ -191,6 +226,8 @@ class CycleViewSet(BaseViewSet):
                 "version",
                 "created_by",
             )
+            datetime_fields = ["start_date", "end_date"]
+            data = user_timezone_converter(data, datetime_fields, project_timezone)
 
             if data:
                 return Response(data, status=status.HTTP_200_OK)
@@ -221,6 +258,8 @@ class CycleViewSet(BaseViewSet):
             "version",
             "created_by",
         )
+        datetime_fields = ["start_date", "end_date"]
+        data = user_timezone_converter(data, datetime_fields, request.user.user_timezone)
         return Response(data, status=status.HTTP_200_OK)
 
     @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
@@ -417,6 +456,8 @@ class CycleViewSet(BaseViewSet):
             )
 
         queryset = queryset.first()
+        datetime_fields = ["start_date", "end_date"]
+        data = user_timezone_converter(data, datetime_fields, request.user.user_timezone)
 
         recent_visited_task.delay(
             slug=slug,
@@ -492,6 +533,9 @@ class CycleDateCheckEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        start_date = convert_to_utc(str(start_date), project_id, is_start_date=True)
+        end_date = convert_to_utc(str(end_date), project_id)
+
         # Check if any cycle intersects in the given interval
         cycles = Cycle.objects.filter(
             Q(workspace__slug=slug)

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

@@ -15,8 +15,6 @@ from django.db.models import (
     UUIDField,
     Value,
     Subquery,
-    Case,
-    When,
 )
 from django.db.models.functions import Coalesce
 from django.utils import timezone
@@ -56,10 +54,11 @@ from plane.utils.issue_filters import issue_filters
 from plane.utils.order_queryset import order_issue_queryset
 from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPaginator
 from .. import BaseAPIView, BaseViewSet
-from plane.utils.user_timezone_converter import user_timezone_converter
+from plane.utils.timezone_converter import user_timezone_converter
 from plane.bgtasks.recent_visited_task import recent_visited_task
 from plane.utils.global_paginator import paginate
 from plane.bgtasks.webhook_task import model_activity
+from plane.bgtasks.issue_description_version_task import issue_description_version_task
 
 
 class IssueListEndpoint(BaseAPIView):
@@ -430,6 +429,13 @@ class IssueViewSet(BaseViewSet):
                 slug=slug,
                 origin=request.META.get("HTTP_ORIGIN"),
             )
+            # updated issue description version
+            issue_description_version_task.delay(
+                updated_issue=json.dumps(request.data, cls=DjangoJSONEncoder),
+                issue_id=str(serializer.data["id"]),
+                user_id=request.user.id,
+                is_creating=True,
+            )
             return Response(issue, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
@@ -445,12 +451,10 @@ class IssueViewSet(BaseViewSet):
             .select_related("workspace", "project", "state", "parent")
             .prefetch_related("assignees", "labels", "issue_module__module")
             .annotate(
-                cycle_id=Case(
-                    When(
-                        issue_cycle__cycle__deleted_at__isnull=True,
-                        then=F("issue_cycle__cycle_id"),
-                    ),
-                    default=None,
+                cycle_id=Subquery(
+                    CycleIssue.objects.filter(issue=OuterRef("id")).values("cycle_id")[
+                        :1
+                    ]
                 )
             )
             .annotate(
@@ -653,6 +657,12 @@ class IssueViewSet(BaseViewSet):
                 slug=slug,
                 origin=request.META.get("HTTP_ORIGIN"),
             )
+            # updated issue description version
+            issue_description_version_task.delay(
+                updated_issue=current_instance,
+                issue_id=str(serializer.data.get("id", None)),
+                user_id=request.user.id,
+            )
             return Response(status=status.HTTP_204_NO_CONTENT)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 

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

@@ -20,7 +20,7 @@ from plane.app.serializers import IssueSerializer
 from plane.app.permissions import ProjectEntityPermission
 from plane.db.models import Issue, IssueLink, FileAsset, CycleIssue
 from plane.bgtasks.issue_activities_task import issue_activity
-from plane.utils.user_timezone_converter import user_timezone_converter
+from plane.utils.timezone_converter import user_timezone_converter
 from collections import defaultdict
 
 

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

@@ -28,7 +28,7 @@ from plane.app.permissions import ProjectEntityPermission
 from plane.app.serializers import ModuleDetailSerializer
 from plane.db.models import Issue, Module, ModuleLink, UserFavorite, Project
 from plane.utils.analytics_plot import burndown_plot
-from plane.utils.user_timezone_converter import user_timezone_converter
+from plane.utils.timezone_converter import user_timezone_converter
 
 
 # Module imports

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

@@ -56,7 +56,7 @@ from plane.db.models import (
     Project,
 )
 from plane.utils.analytics_plot import burndown_plot
-from plane.utils.user_timezone_converter import user_timezone_converter
+from plane.utils.timezone_converter import user_timezone_converter
 from plane.bgtasks.webhook_task import model_activity
 from .. import BaseAPIView, BaseViewSet
 from plane.bgtasks.recent_visited_task import recent_visited_task

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

@@ -114,7 +114,7 @@ class PageViewSet(BaseViewSet):
             .distinct()
         )
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
     def create(self, request, slug, project_id):
         serializer = PageSerializer(
             data=request.data,
@@ -134,7 +134,7 @@ class PageViewSet(BaseViewSet):
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
     def partial_update(self, request, slug, project_id, pk):
         try:
             page = Page.objects.get(
@@ -234,7 +234,7 @@ class PageViewSet(BaseViewSet):
             )
             return Response(data, status=status.HTTP_200_OK)
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
     def lock(self, request, slug, project_id, pk):
         page = Page.objects.filter(
             pk=pk, workspace__slug=slug, projects__id=project_id
@@ -244,7 +244,7 @@ class PageViewSet(BaseViewSet):
         page.save()
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
     def unlock(self, request, slug, project_id, pk):
         page = Page.objects.filter(
             pk=pk, workspace__slug=slug, projects__id=project_id
@@ -255,7 +255,7 @@ class PageViewSet(BaseViewSet):
 
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
     def access(self, request, slug, project_id, pk):
         access = request.data.get("access", 0)
         page = Page.objects.filter(
@@ -296,7 +296,7 @@ class PageViewSet(BaseViewSet):
         pages = PageSerializer(queryset, many=True).data
         return Response(pages, status=status.HTTP_200_OK)
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
     def archive(self, request, slug, project_id, pk):
         page = Page.objects.get(pk=pk, workspace__slug=slug, projects__id=project_id)
 
@@ -323,7 +323,7 @@ class PageViewSet(BaseViewSet):
 
         return Response({"archived_at": str(datetime.now())}, status=status.HTTP_200_OK)
 
-    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
     def unarchive(self, request, slug, project_id, pk):
         page = Page.objects.get(pk=pk, workspace__slug=slug, projects__id=project_id)
 
@@ -348,7 +348,7 @@ class PageViewSet(BaseViewSet):
 
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-    @allow_permission([ROLE.ADMIN], creator=True, model=Page)
+    @allow_permission([ROLE.ADMIN], model=Page, creator=True)
     def destroy(self, request, slug, project_id, pk):
         page = Page.objects.get(pk=pk, workspace__slug=slug, projects__id=project_id)
 

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

@@ -384,11 +384,9 @@ class ProjectViewSet(BaseViewSet):
                 )
 
             workspace = Workspace.objects.get(slug=slug)
-            intake_view = request.data.get(
-                "inbox_view", request.data.get("intake_view", False)
-            )
 
             project = Project.objects.get(pk=pk)
+            intake_view = request.data.get("inbox_view", project.intake_view)
             current_instance = json.dumps(
                 ProjectSerializer(project).data, cls=DjangoJSONEncoder
             )

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

@@ -136,7 +136,7 @@ class UserProjectInvitationsViewset(BaseViewSet):
             member=request.user, workspace__slug=slug, is_active=True
         )
 
-        if workspace_member.role != ROLE.ADMIN:
+        if workspace_member.role not in [ROLE.ADMIN.value, ROLE.MEMBER.value]:
             return Response(
                 {"error": "You do not have permission to join the project"},
                 status=status.HTTP_403_FORBIDDEN,

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

@@ -11,20 +11,12 @@ from plane.app.serializers import (
 )
 
 from plane.app.permissions import (
-    ProjectBasePermission,
     ProjectMemberPermission,
     ProjectLitePermission,
     WorkspaceUserPermission,
 )
 
-from plane.db.models import (
-    Project,
-    ProjectMember,
-    Workspace,
-    TeamMember,
-    IssueUserProperty,
-    WorkspaceMember,
-)
+from plane.db.models import Project, ProjectMember, IssueUserProperty, WorkspaceMember
 from plane.bgtasks.project_add_user_email_task import project_add_user_email
 from plane.utils.host import base_host
 from plane.app.permissions.base import allow_permission, ROLE
@@ -309,53 +301,6 @@ class ProjectMemberViewSet(BaseViewSet):
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
-class AddTeamToProjectEndpoint(BaseAPIView):
-    permission_classes = [ProjectBasePermission]
-
-    def post(self, request, slug, project_id):
-        team_members = TeamMember.objects.filter(
-            workspace__slug=slug, team__in=request.data.get("teams", [])
-        ).values_list("member", flat=True)
-
-        if len(team_members) == 0:
-            return Response(
-                {"error": "No such team exists"}, status=status.HTTP_400_BAD_REQUEST
-            )
-
-        workspace = Workspace.objects.get(slug=slug)
-
-        project_members = []
-        issue_props = []
-        for member in team_members:
-            project_members.append(
-                ProjectMember(
-                    project_id=project_id,
-                    member_id=member,
-                    workspace=workspace,
-                    created_by=request.user,
-                )
-            )
-            issue_props.append(
-                IssueUserProperty(
-                    project_id=project_id,
-                    user_id=member,
-                    workspace=workspace,
-                    created_by=request.user,
-                )
-            )
-
-        ProjectMember.objects.bulk_create(
-            project_members, batch_size=10, ignore_conflicts=True
-        )
-
-        _ = IssueUserProperty.objects.bulk_create(
-            issue_props, batch_size=10, ignore_conflicts=True
-        )
-
-        serializer = ProjectMemberSerializer(project_members, many=True)
-        return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-
 class ProjectMemberUserEndpoint(BaseAPIView):
     def get(self, request, slug, project_id):
         project_member = ProjectMember.objects.get(

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

@@ -1,6 +1,7 @@
 # Python imports
 import csv
 import io
+import os
 from datetime import date
 
 from dateutil.relativedelta import relativedelta
@@ -38,6 +39,7 @@ from django.utils.decorators import method_decorator
 from django.views.decorators.cache import cache_control
 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
 
 
 class WorkSpaceViewSet(BaseViewSet):
@@ -80,6 +82,21 @@ class WorkSpaceViewSet(BaseViewSet):
 
     def create(self, request):
         try:
+            (DISABLE_WORKSPACE_CREATION,) = get_configuration_value(
+                [
+                    {
+                        "key": "DISABLE_WORKSPACE_CREATION",
+                        "default": os.environ.get("DISABLE_WORKSPACE_CREATION", "0"),
+                    }
+                ]
+            )
+
+            if DISABLE_WORKSPACE_CREATION == "1":
+                return Response(
+                    {"error": "Workspace creation is not allowed"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
             serializer = WorkSpaceSerializer(data=request.data)
 
             slug = request.data.get("slug", False)
@@ -337,6 +354,7 @@ class ExportWorkspaceUserActivityEndpoint(BaseAPIView):
             workspace__slug=slug,
             created_at__date=request.data.get("date"),
             project__project_projectmember__member=request.user,
+            project__project_projectmember__is_active=True,
             actor_id=user_id,
         ).select_related("actor", "workspace", "issue", "project")[:10000]
 

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

@@ -10,7 +10,7 @@ from plane.app.views.base import BaseAPIView
 from plane.db.models import Cycle
 from plane.app.permissions import WorkspaceViewerPermission
 from plane.app.serializers.cycle import CycleSerializer
-
+from plane.utils.timezone_converter import user_timezone_converter
 
 class WorkspaceCyclesEndpoint(BaseAPIView):
     permission_classes = [WorkspaceViewerPermission]

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

@@ -1,38 +1,22 @@
 # Django imports
-from django.db.models import CharField, Count, Q, OuterRef, Subquery, IntegerField
+from django.db.models import Count, Q, OuterRef, Subquery, IntegerField
 from django.db.models.functions import Coalesce
-from django.db.models.functions import Cast
 
 # Third party modules
 from rest_framework import status
 from rest_framework.response import Response
 
-from plane.app.permissions import (
-    WorkSpaceAdminPermission,
-    WorkspaceEntityPermission,
-    allow_permission,
-    ROLE,
-)
+from plane.app.permissions import WorkspaceEntityPermission, allow_permission, ROLE
 
 # Module imports
 from plane.app.serializers import (
     ProjectMemberRoleSerializer,
-    TeamSerializer,
-    UserLiteSerializer,
     WorkspaceMemberAdminSerializer,
     WorkspaceMemberMeSerializer,
     WorkSpaceMemberSerializer,
 )
 from plane.app.views.base import BaseAPIView
-from plane.db.models import (
-    Project,
-    ProjectMember,
-    Team,
-    User,
-    Workspace,
-    WorkspaceMember,
-    DraftIssue,
-)
+from plane.db.models import Project, ProjectMember, WorkspaceMember, DraftIssue
 from plane.utils.cache import invalidate_cache
 
 from .. import BaseViewSet
@@ -284,53 +268,3 @@ class WorkspaceProjectMemberEndpoint(BaseAPIView):
             project_members_dict[str(project_id)].append(project_member)
 
         return Response(project_members_dict, status=status.HTTP_200_OK)
-
-
-class TeamMemberViewSet(BaseViewSet):
-    serializer_class = TeamSerializer
-    model = Team
-    permission_classes = [WorkSpaceAdminPermission]
-
-    search_fields = ["member__display_name", "member__first_name"]
-
-    def get_queryset(self):
-        return self.filter_queryset(
-            super()
-            .get_queryset()
-            .filter(workspace__slug=self.kwargs.get("slug"))
-            .select_related("workspace", "workspace__owner")
-            .prefetch_related("members")
-        )
-
-    def create(self, request, slug):
-        members = list(
-            WorkspaceMember.objects.filter(
-                workspace__slug=slug,
-                member__id__in=request.data.get("members", []),
-                is_active=True,
-            )
-            .annotate(member_str_id=Cast("member", output_field=CharField()))
-            .distinct()
-            .values_list("member_str_id", flat=True)
-        )
-
-        if len(members) != len(request.data.get("members", [])):
-            users = list(set(request.data.get("members", [])).difference(members))
-            users = User.objects.filter(pk__in=users)
-
-            serializer = UserLiteSerializer(users, many=True)
-            return Response(
-                {
-                    "error": f"{len(users)} of the member(s) are not a part of the workspace",
-                    "members": serializer.data,
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        workspace = Workspace.objects.get(slug=slug)
-
-        serializer = TeamSerializer(data=request.data, context={"workspace": workspace})
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

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

@@ -60,6 +60,9 @@ class EmailCheckEndpoint(APIView):
             )
             return Response(exc.get_error_dict(), status=status.HTTP_400_BAD_REQUEST)
 
+        # Lower the email
+        email = str(email).lower().strip()
+
         # Validate email
         try:
             validate_email(email)

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

@@ -60,6 +60,7 @@ class EmailCheckSpaceEndpoint(APIView):
             )
             return Response(exc.get_error_dict(), status=status.HTTP_400_BAD_REQUEST)
 
+        email = str(email).lower().strip()
         # Validate email
         try:
             validate_email(email)

apiserver/plane/bgtasks/deletion_task.py

@@ -3,7 +3,8 @@ from django.utils import timezone
 from django.apps import apps
 from django.conf import settings
 from django.db import models
-from django.core.exceptions import ObjectDoesNotExist
+from django.db.models.fields.related import OneToOneRel
+
 
 # Third party imports
 from celery import shared_task
@@ -11,31 +12,98 @@ from celery import shared_task
 
 @shared_task
 def soft_delete_related_objects(app_label, model_name, instance_pk, using=None):
+    """
+    Soft delete related objects for a given model instance
+    """
+    # Get the model class using app registry
     model_class = apps.get_model(app_label, model_name)
-    instance = model_class.all_objects.get(pk=instance_pk)
-    related_fields = instance._meta.get_fields()
-    for field in related_fields:
-        if field.one_to_many or field.one_to_one:
-            try:
-                # Check if the field has CASCADE on delete
-                if (
-                    not hasattr(field.remote_field, "on_delete")
-                    or field.remote_field.on_delete == models.CASCADE
-                ):
-                    if field.one_to_many:
-                        related_objects = getattr(instance, field.name).all()
-                    elif field.one_to_one:
-                        related_object = getattr(instance, field.name)
-                        related_objects = (
-                            [related_object] if related_object is not None else []
-                        )
 
-                    for obj in related_objects:
-                        if obj:
-                            obj.deleted_at = timezone.now()
-                            obj.save(using=using)
-            except ObjectDoesNotExist:
-                pass
+    # Get the instance using all_objects to ensure we can get even if it's already soft deleted
+    try:
+        instance = model_class.all_objects.get(pk=instance_pk)
+    except model_class.DoesNotExist:
+        return
+
+    # Get all related fields that are reverse relationships
+    all_related = [
+        f
+        for f in instance._meta.get_fields()
+        if (f.one_to_many or f.one_to_one) and f.auto_created and not f.concrete
+    ]
+
+    # Handle each related field
+    for relation in all_related:
+        related_name = relation.get_accessor_name()
+
+        # Skip if the relation doesn't exist
+        if not hasattr(instance, related_name):
+            continue
+
+        # Get the on_delete behavior name
+        on_delete_name = (
+            relation.on_delete.__name__
+            if hasattr(relation.on_delete, "__name__")
+            else ""
+        )
+
+        if on_delete_name == "DO_NOTHING":
+            continue
+
+        elif on_delete_name == "SET_NULL":
+            # Handle SET_NULL relationships
+            if isinstance(relation, OneToOneRel):
+                # For OneToOne relationships
+                related_obj = getattr(instance, related_name, None)
+                if related_obj and isinstance(related_obj, models.Model):
+                    setattr(related_obj, relation.remote_field.name, None)
+                    related_obj.save(update_fields=[relation.remote_field.name])
+            else:
+                # For other relationships
+                related_queryset = getattr(instance, related_name).all()
+                related_queryset.update(**{relation.remote_field.name: None})
+
+        else:
+            # Handle CASCADE and other delete behaviors
+            try:
+                if relation.one_to_one:
+                    # Handle OneToOne relationships
+                    related_obj = getattr(instance, related_name, None)
+                    if related_obj:
+                        if hasattr(related_obj, "deleted_at"):
+                            if not related_obj.deleted_at:
+                                related_obj.deleted_at = timezone.now()
+                                related_obj.save()
+                                # Recursively handle related objects
+                                soft_delete_related_objects(
+                                    related_obj._meta.app_label,
+                                    related_obj._meta.model_name,
+                                    related_obj.pk,
+                                    using,
+                                )
+                else:
+                    # Handle other relationships
+                    related_queryset = getattr(instance, related_name).all()
+                    for related_obj in related_queryset:
+                        if hasattr(related_obj, "deleted_at"):
+                            if not related_obj.deleted_at:
+                                related_obj.deleted_at = timezone.now()
+                                related_obj.save()
+                                # Recursively handle related objects
+                                soft_delete_related_objects(
+                                    related_obj._meta.app_label,
+                                    related_obj._meta.model_name,
+                                    related_obj.pk,
+                                    using,
+                                )
+            except Exception as e:
+                # Log the error or handle as needed
+                print(f"Error handling relation {related_name}: {str(e)}")
+                continue
+
+    # Finally, soft delete the instance itself if it hasn't been deleted yet
+    if hasattr(instance, "deleted_at") and not instance.deleted_at:
+        instance.deleted_at = timezone.now()
+        instance.save()
 
 
 # @shared_task

apiserver/plane/bgtasks/export_task.py

@@ -162,8 +162,7 @@ def generate_table_row(issue):
         issue["priority"],
         (
             f"{issue['created_by__first_name']} {issue['created_by__last_name']}"
-            if issue["created_by__first_name"]
-            and issue["created_by__last_name"]
+            if issue["created_by__first_name"] and issue["created_by__last_name"]
             else ""
         ),
         (
@@ -197,8 +196,7 @@ def generate_json_row(issue):
         "Priority": issue["priority"],
         "Created By": (
             f"{issue['created_by__first_name']} {issue['created_by__last_name']}"
-            if issue["created_by__first_name"]
-            and issue["created_by__last_name"]
+            if issue["created_by__first_name"] and issue["created_by__last_name"]
             else ""
         ),
         "Assignee": (
@@ -208,17 +206,11 @@ def generate_json_row(issue):
         ),
         "Labels": issue["labels__name"] if issue["labels__name"] else "",
         "Cycle Name": issue["issue_cycle__cycle__name"],
-        "Cycle Start Date": dateConverter(
-            issue["issue_cycle__cycle__start_date"]
-        ),
+        "Cycle Start Date": dateConverter(issue["issue_cycle__cycle__start_date"]),
         "Cycle End Date": dateConverter(issue["issue_cycle__cycle__end_date"]),
         "Module Name": issue["issue_module__module__name"],
-        "Module Start Date": dateConverter(
-            issue["issue_module__module__start_date"]
-        ),
-        "Module Target Date": dateConverter(
-            issue["issue_module__module__target_date"]
-        ),
+        "Module Start Date": dateConverter(issue["issue_module__module__start_date"]),
+        "Module Target Date": dateConverter(issue["issue_module__module__target_date"]),
         "Created At": dateTimeConverter(issue["created_at"]),
         "Updated At": dateTimeConverter(issue["updated_at"]),
         "Completed At": dateTimeConverter(issue["completed_at"]),

apiserver/plane/bgtasks/issue_description_version_sync.py

@@ -0,0 +1,125 @@
+# Python imports
+from typing import Optional
+import logging
+
+# Django imports
+from django.utils import timezone
+from django.db import transaction
+
+# Third party imports
+from celery import shared_task
+
+# Module imports
+from plane.db.models import Issue, IssueDescriptionVersion, ProjectMember
+from plane.utils.exception_logger import log_exception
+
+
+def get_owner_id(issue: Issue) -> Optional[int]:
+    """Get the owner ID of the issue"""
+
+    if issue.updated_by_id:
+        return issue.updated_by_id
+
+    if issue.created_by_id:
+        return issue.created_by_id
+
+    # Find project admin as fallback
+    project_member = ProjectMember.objects.filter(
+        project_id=issue.project_id,
+        role=20,  # Admin role
+    ).first()
+
+    return project_member.member_id if project_member else None
+
+
+@shared_task
+def sync_issue_description_version(batch_size=5000, offset=0, countdown=300):
+    """Task to create IssueDescriptionVersion records for existing Issues in batches"""
+    try:
+        with transaction.atomic():
+            base_query = Issue.objects
+            total_issues_count = base_query.count()
+
+            if total_issues_count == 0:
+                return
+
+            # Calculate batch range
+            end_offset = min(offset + batch_size, total_issues_count)
+
+            # Fetch issues with related data
+            issues_batch = (
+                base_query.order_by("created_at")
+                .select_related("workspace", "project")
+                .only(
+                    "id",
+                    "workspace_id",
+                    "project_id",
+                    "created_by_id",
+                    "updated_by_id",
+                    "description_binary",
+                    "description_html",
+                    "description_stripped",
+                    "description",
+                )[offset:end_offset]
+            )
+
+            if not issues_batch:
+                return
+
+            version_objects = []
+            for issue in issues_batch:
+                # Validate required fields
+                if not issue.workspace_id or not issue.project_id:
+                    logging.warning(
+                        f"Skipping {issue.id} - missing workspace_id or project_id"
+                    )
+                    continue
+
+                # Determine owned_by_id
+                owned_by_id = get_owner_id(issue)
+                if owned_by_id is None:
+                    logging.warning(f"Skipping issue {issue.id} - missing owned_by")
+                    continue
+
+                # Create version object
+                version_objects.append(
+                    IssueDescriptionVersion(
+                        workspace_id=issue.workspace_id,
+                        project_id=issue.project_id,
+                        created_by_id=issue.created_by_id,
+                        updated_by_id=issue.updated_by_id,
+                        owned_by_id=owned_by_id,
+                        last_saved_at=timezone.now(),
+                        issue_id=issue.id,
+                        description_binary=issue.description_binary,
+                        description_html=issue.description_html,
+                        description_stripped=issue.description_stripped,
+                        description_json=issue.description,
+                    )
+                )
+
+            # Bulk create version objects
+            if version_objects:
+                IssueDescriptionVersion.objects.bulk_create(version_objects)
+
+            # Schedule next batch if needed
+            if end_offset < total_issues_count:
+                sync_issue_description_version.apply_async(
+                    kwargs={
+                        "batch_size": batch_size,
+                        "offset": end_offset,
+                        "countdown": countdown,
+                    },
+                    countdown=countdown,
+                )
+        return
+    except Exception as e:
+        log_exception(e)
+        return
+
+
+@shared_task
+def schedule_issue_description_version(batch_size=5000, countdown=300):
+    sync_issue_description_version.delay(
+        batch_size=int(batch_size), countdown=countdown
+    )

apiserver/plane/bgtasks/issue_description_version_task.py

@@ -0,0 +1,84 @@
+from celery import shared_task
+from django.db import transaction
+from django.utils import timezone
+from typing import Optional, Dict
+import json
+
+from plane.db.models import Issue, IssueDescriptionVersion
+from plane.utils.exception_logger import log_exception
+
+
+def should_update_existing_version(
+    version: IssueDescriptionVersion, user_id: str, max_time_difference: int = 600
+) -> bool:
+    if not version:
+        return
+
+    time_difference = (timezone.now() - version.last_saved_at).total_seconds()
+    return (
+        str(version.owned_by_id) == str(user_id)
+        and time_difference <= max_time_difference
+    )
+
+
+def update_existing_version(version: IssueDescriptionVersion, issue) -> None:
+    version.description_json = issue.description
+    version.description_html = issue.description_html
+    version.description_binary = issue.description_binary
+    version.description_stripped = issue.description_stripped
+    version.last_saved_at = timezone.now()
+
+    version.save(
+        update_fields=[
+            "description_json",
+            "description_html",
+            "description_binary",
+            "description_stripped",
+            "last_saved_at",
+        ]
+    )
+
+
+@shared_task
+def issue_description_version_task(
+    updated_issue, issue_id, user_id, is_creating=False
+) -> Optional[bool]:
+    try:
+        # Parse updated issue data
+        current_issue: Dict = json.loads(updated_issue) if updated_issue else {}
+
+        # Get current issue
+        issue = Issue.objects.get(id=issue_id)
+
+        # Check if description has changed
+        if (
+            current_issue.get("description_html") == issue.description_html
+            and not is_creating
+        ):
+            return
+
+        with transaction.atomic():
+            # Get latest version
+            latest_version = (
+                IssueDescriptionVersion.objects.filter(issue_id=issue_id)
+                .order_by("-last_saved_at")
+                .first()
+            )
+
+            # Determine whether to update existing or create new version
+            if should_update_existing_version(version=latest_version, user_id=user_id):
+                update_existing_version(latest_version, issue)
+            else:
+                IssueDescriptionVersion.log_issue_description_version(issue, user_id)
+
+            return
+
+    except Issue.DoesNotExist:
+        # Issue no longer exists, skip processing
+        return
+    except json.JSONDecodeError as e:
+        log_exception(f"Invalid JSON for updated_issue: {e}")
+        return
+    except Exception as e:
+        log_exception(f"Error processing issue description version: {e}")
+        return

apiserver/plane/bgtasks/issue_version_sync.py

@@ -0,0 +1,254 @@
+# Python imports
+import json
+from typing import Optional, List, Dict
+from uuid import UUID
+from itertools import groupby
+import logging
+
+# Django imports
+from django.utils import timezone
+from django.db import transaction
+
+# Third party imports
+from celery import shared_task
+
+# Module imports
+from plane.db.models import (
+    Issue,
+    IssueVersion,
+    ProjectMember,
+    CycleIssue,
+    ModuleIssue,
+    IssueActivity,
+    IssueAssignee,
+    IssueLabel,
+)
+from plane.utils.exception_logger import log_exception
+
+
+@shared_task
+def issue_task(updated_issue, issue_id, user_id):
+    try:
+        current_issue = json.loads(updated_issue) if updated_issue else {}
+        issue = Issue.objects.get(id=issue_id)
+
+        updated_current_issue = {}
+        for key, value in current_issue.items():
+            if getattr(issue, key) != value:
+                updated_current_issue[key] = value
+
+        if updated_current_issue:
+            issue_version = (
+                IssueVersion.objects.filter(issue_id=issue_id)
+                .order_by("-last_saved_at")
+                .first()
+            )
+
+            if (
+                issue_version
+                and str(issue_version.owned_by) == str(user_id)
+                and (timezone.now() - issue_version.last_saved_at).total_seconds()
+                <= 600
+            ):
+                for key, value in updated_current_issue.items():
+                    setattr(issue_version, key, value)
+                issue_version.last_saved_at = timezone.now()
+                issue_version.save(
+                    update_fields=list(updated_current_issue.keys()) + ["last_saved_at"]
+                )
+            else:
+                IssueVersion.log_issue_version(issue, user_id)
+
+        return
+    except Issue.DoesNotExist:
+        return
+    except Exception as e:
+        log_exception(e)
+        return
+
+
+def get_owner_id(issue: Issue) -> Optional[int]:
+    """Get the owner ID of the issue"""
+
+    if issue.updated_by_id:
+        return issue.updated_by_id
+
+    if issue.created_by_id:
+        return issue.created_by_id
+
+    # Find project admin as fallback
+    project_member = ProjectMember.objects.filter(
+        project_id=issue.project_id,
+        role=20,  # Admin role
+    ).first()
+
+    return project_member.member_id if project_member else None
+
+
+def get_related_data(issue_ids: List[UUID]) -> Dict:
+    """Get related data for the given issue IDs"""
+
+    cycle_issues = {
+        ci.issue_id: ci.cycle_id
+        for ci in CycleIssue.objects.filter(issue_id__in=issue_ids)
+    }
+
+    # Get assignees with proper grouping
+    assignee_records = list(
+        IssueAssignee.objects.filter(issue_id__in=issue_ids)
+        .values_list("issue_id", "assignee_id")
+        .order_by("issue_id")
+    )
+    assignees = {}
+    for issue_id, group in groupby(assignee_records, key=lambda x: x[0]):
+        assignees[issue_id] = [str(g[1]) for g in group]
+
+    # Get labels with proper grouping
+    label_records = list(
+        IssueLabel.objects.filter(issue_id__in=issue_ids)
+        .values_list("issue_id", "label_id")
+        .order_by("issue_id")
+    )
+    labels = {}
+    for issue_id, group in groupby(label_records, key=lambda x: x[0]):
+        labels[issue_id] = [str(g[1]) for g in group]
+
+    # Get modules with proper grouping
+    module_records = list(
+        ModuleIssue.objects.filter(issue_id__in=issue_ids)
+        .values_list("issue_id", "module_id")
+        .order_by("issue_id")
+    )
+    modules = {}
+    for issue_id, group in groupby(module_records, key=lambda x: x[0]):
+        modules[issue_id] = [str(g[1]) for g in group]
+
+    # Get latest activities
+    latest_activities = {}
+    activities = IssueActivity.objects.filter(issue_id__in=issue_ids).order_by(
+        "issue_id", "-created_at"
+    )
+    for issue_id, activities_group in groupby(activities, key=lambda x: x.issue_id):
+        first_activity = next(activities_group, None)
+        if first_activity:
+            latest_activities[issue_id] = first_activity.id
+
+    return {
+        "cycle_issues": cycle_issues,
+        "assignees": assignees,
+        "labels": labels,
+        "modules": modules,
+        "activities": latest_activities,
+    }
+
+
+def create_issue_version(issue: Issue, related_data: Dict) -> Optional[IssueVersion]:
+    """Create IssueVersion object from the given issue and related data"""
+
+    try:
+        if not issue.workspace_id or not issue.project_id:
+            logging.warning(
+                f"Skipping issue {issue.id} - missing workspace_id or project_id"
+            )
+            return None
+
+        owned_by_id = get_owner_id(issue)
+        if owned_by_id is None:
+            logging.warning(f"Skipping issue {issue.id} - missing owned_by")
+            return None
+
+        return IssueVersion(
+            workspace_id=issue.workspace_id,
+            project_id=issue.project_id,
+            created_by_id=issue.created_by_id,
+            updated_by_id=issue.updated_by_id,
+            owned_by_id=owned_by_id,
+            last_saved_at=timezone.now(),
+            activity_id=related_data["activities"].get(issue.id),
+            properties=getattr(issue, "properties", {}),
+            meta=getattr(issue, "meta", {}),
+            issue_id=issue.id,
+            parent=issue.parent_id,
+            state=issue.state_id,
+            estimate_point=issue.estimate_point_id,
+            name=issue.name,
+            priority=issue.priority,
+            start_date=issue.start_date,
+            target_date=issue.target_date,
+            assignees=related_data["assignees"].get(issue.id, []),
+            sequence_id=issue.sequence_id,
+            labels=related_data["labels"].get(issue.id, []),
+            sort_order=issue.sort_order,
+            completed_at=issue.completed_at,
+            archived_at=issue.archived_at,
+            is_draft=issue.is_draft,
+            external_source=issue.external_source,
+            external_id=issue.external_id,
+            type=issue.type_id,
+            cycle=related_data["cycle_issues"].get(issue.id),
+            modules=related_data["modules"].get(issue.id, []),
+        )
+    except Exception as e:
+        log_exception(e)
+        return None
+
+
+@shared_task
+def sync_issue_version(batch_size=5000, offset=0, countdown=300):
+    """Task to create IssueVersion records for existing Issues in batches"""
+
+    try:
+        with transaction.atomic():
+            base_query = Issue.objects
+            total_issues_count = base_query.count()
+
+            if total_issues_count == 0:
+                return
+
+            end_offset = min(offset + batch_size, total_issues_count)
+
+            # Get issues batch with optimized queries
+            issues_batch = list(
+                base_query.order_by("created_at")
+                .select_related("workspace", "project")
+                .all()[offset:end_offset]
+            )
+
+            if not issues_batch:
+                return
+
+            # Get all related data in bulk
+            issue_ids = [issue.id for issue in issues_batch]
+            related_data = get_related_data(issue_ids)
+
+            issue_versions = []
+            for issue in issues_batch:
+                version = create_issue_version(issue, related_data)
+                if version:
+                    issue_versions.append(version)
+
+            # Bulk create versions
+            if issue_versions:
+                IssueVersion.objects.bulk_create(issue_versions, batch_size=1000)
+
+            # Schedule the next batch if there are more workspaces to process
+            if end_offset < total_issues_count:
+                sync_issue_version.apply_async(
+                    kwargs={
+                        "batch_size": batch_size,
+                        "offset": end_offset,
+                        "countdown": countdown,
+                    },
+                    countdown=countdown,
+                )
+
+            logging.info(f"Processed Issues: {end_offset}")
+            return
+    except Exception as e:
+        log_exception(e)
+        return
+
+
+@shared_task
+def schedule_issue_version(batch_size=5000, countdown=300):
+    sync_issue_version.delay(batch_size=int(batch_size), countdown=countdown)

apiserver/plane/bgtasks/notification_task.py

@@ -1,6 +1,8 @@
 # Python imports
 import json
 import uuid
+from uuid import UUID
+
 
 # Module imports
 from plane.db.models import (
@@ -16,8 +18,9 @@ from plane.db.models import (
     IssueComment,
     IssueActivity,
     UserNotificationPreference,
-    ProjectMember
+    ProjectMember,
 )
+from django.db.models import Subquery
 
 # Third Party imports
 from celery import shared_task
@@ -95,7 +98,8 @@ def extract_mentions_as_subscribers(project_id, issue_id, mentions):
             ).exists()
             and not Issue.objects.filter(
                 project_id=project_id, pk=issue_id, created_by_id=mention_id
-            ).exists() and ProjectMember.objects.filter(
+            ).exists()
+            and ProjectMember.objects.filter(
                 project_id=project_id, member_id=mention_id, is_active=True
             ).exists()
         ):
@@ -242,14 +246,21 @@ def notifications(
             2. From the latest set of mentions, extract the users which are not a subscribers & make them subscribers
             """
 
+            # get the list of active project members
+            project_members = ProjectMember.objects.filter(
+                project_id=project_id, is_active=True
+            ).values_list("member_id", flat=True)
+
             # Get new mentions from the newer instance
             new_mentions = get_new_mentions(
                 requested_instance=requested_data, current_instance=current_instance
             )
-            new_mentions = list(ProjectMember.objects.filter(
-                project_id=project_id, member_id__in=new_mentions, is_active=True
-            ).values_list("member_id", flat=True))
-            new_mentions = [str(member_id) for member_id in new_mentions]
+
+            new_mentions = [
+                str(mention)
+                for mention in new_mentions
+                if mention in set(project_members)
+            ]
             removed_mention = get_removed_mentions(
                 requested_instance=requested_data, current_instance=current_instance
             )
@@ -280,6 +291,11 @@ def notifications(
                         new_value=issue_comment_new_value,
                     )
                     comment_mentions = comment_mentions + new_comment_mentions
+                    comment_mentions = [
+                        mention
+                        for mention in comment_mentions
+                        if UUID(mention) in set(project_members)
+                    ]
 
             comment_mention_subscribers = extract_mentions_as_subscribers(
                 project_id=project_id, issue_id=issue_id, mentions=all_comment_mentions
@@ -293,7 +309,11 @@ def notifications(
 
             # ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #
             issue_subscribers = list(
-                IssueSubscriber.objects.filter(project_id=project_id, issue_id=issue_id, project__project_projectmember__is_active=True,)
+                IssueSubscriber.objects.filter(
+                    project_id=project_id,
+                    issue_id=issue_id,
+                    subscriber__in=Subquery(project_members),
+                )
                 .exclude(
                     subscriber_id__in=list(new_mentions + comment_mentions + [actor_id])
                 )
@@ -314,7 +334,9 @@ def notifications(
             project = Project.objects.get(pk=project_id)
 
             issue_assignees = IssueAssignee.objects.filter(
-                issue_id=issue_id, project_id=project_id
+                issue_id=issue_id,
+                project_id=project_id,
+                assignee__in=Subquery(project_members),
             ).values_list("assignee", flat=True)
 
             issue_subscribers = list(set(issue_subscribers) - {uuid.UUID(actor_id)})

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

@@ -13,28 +13,14 @@ from plane.db.models import (
 
 
 class Command(BaseCommand):
-
     help = "Add a member to a project. If present in the workspace"
 
     def add_arguments(self, parser):
         # Positional argument
+        parser.add_argument("--project_id", type=str, nargs="?", help="Project ID")
+        parser.add_argument("--user_email", type=str, nargs="?", help="User Email")
         parser.add_argument(
-            "--project_id",
-            type=str,
-            nargs="?",
-            help="Project ID",
-        )
-        parser.add_argument(
-            "--user_email",
-            type=str,
-            nargs="?",
-            help="User Email",
-        )
-        parser.add_argument(
-            "--role",
-            type=int,
-            nargs="?",
-            help="Role of the user in the project",
+            "--role", type=int, nargs="?", help="Role of the user in the project"
         )
 
     def handle(self, *args: Any, **options: Any):
@@ -67,9 +53,7 @@ class Command(BaseCommand):
 
             # Get the smallest sort order
             smallest_sort_order = (
-                ProjectMember.objects.filter(
-                    workspace_id=project.workspace_id,
-                )
+                ProjectMember.objects.filter(workspace_id=project.workspace_id)
                 .order_by("sort_order")
                 .first()
             )
@@ -79,22 +63,15 @@ class Command(BaseCommand):
             else:
                 sort_order = 65535
 
-            if ProjectMember.objects.filter(
-                project=project,
-                member=user,
-            ).exists():
+            if ProjectMember.objects.filter(project=project, member=user).exists():
                 # Update the project member
-                ProjectMember.objects.filter(
-                    project=project,
-                    member=user,
-                ).update(is_active=True, sort_order=sort_order, role=role)
+                ProjectMember.objects.filter(project=project, member=user).update(
+                    is_active=True, sort_order=sort_order, role=role
+                )
             else:
                 # Create the project member
                 ProjectMember.objects.create(
-                    project=project,
-                    member=user,
-                    role=role,
-                    sort_order=sort_order,
+                    project=project, member=user, role=role, sort_order=sort_order
                 )
 
             # Issue Property
@@ -102,9 +79,7 @@ class Command(BaseCommand):
 
             # Success message
             self.stdout.write(
-                self.style.SUCCESS(
-                    f"User {user_email} added to project {project_id}"
-                )
+                self.style.SUCCESS(f"User {user_email} added to project {project_id}")
             )
             return
         except CommandError as e:

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

@@ -0,0 +1,23 @@
+# Django imports
+from django.core.management.base import BaseCommand
+
+# Module imports
+from plane.bgtasks.issue_description_version_sync import (
+    schedule_issue_description_version,
+)
+
+
+class Command(BaseCommand):
+    help = "Creates IssueDescriptionVersion records for existing Issues in batches"
+
+    def handle(self, *args, **options):
+        batch_size = input("Enter the batch size: ")
+        batch_countdown = input("Enter the batch countdown: ")
+
+        schedule_issue_description_version.delay(
+            batch_size=batch_size, countdown=int(batch_countdown)
+        )
+
+        self.stdout.write(
+            self.style.SUCCESS("Successfully created issue description version task")
+        )

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

@@ -0,0 +1,19 @@
+# Django imports
+from django.core.management.base import BaseCommand
+
+# Module imports
+from plane.bgtasks.issue_version_sync import schedule_issue_version
+
+
+class Command(BaseCommand):
+    help = "Creates IssueVersion records for existing Issues in batches"
+
+    def handle(self, *args, **options):
+        batch_size = input("Enter the batch size: ")
+        batch_countdown = input("Enter the batch countdown: ")
+
+        schedule_issue_version.delay(
+            batch_size=batch_size, countdown=int(batch_countdown)
+        )
+
+        self.stdout.write(self.style.SUCCESS("Successfully created issue version task"))

apiserver/plane/db/migrations/0086_issueversion_alter_teampage_unique_together_and_more.py

@@ -0,0 +1,242 @@
+# Generated by Django 4.2.15 on 2024-11-27 09:07
+
+from django.conf import settings
+import django.contrib.postgres.fields
+from django.db import migrations, models
+import django.db.models.deletion
+import django.utils.timezone
+import plane.db.models.webhook
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("db", "0085_intake_intakeissue_remove_inboxissue_created_by_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="IssueVersion",
+            fields=[
+                (
+                    "created_at",
+                    models.DateTimeField(auto_now_add=True, verbose_name="Created At"),
+                ),
+                (
+                    "updated_at",
+                    models.DateTimeField(
+                        auto_now=True, verbose_name="Last Modified At"
+                    ),
+                ),
+                (
+                    "deleted_at",
+                    models.DateTimeField(
+                        blank=True, null=True, verbose_name="Deleted At"
+                    ),
+                ),
+                (
+                    "id",
+                    models.UUIDField(
+                        db_index=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        primary_key=True,
+                        serialize=False,
+                        unique=True,
+                    ),
+                ),
+                ("parent", models.UUIDField(blank=True, null=True)),
+                ("state", models.UUIDField(blank=True, null=True)),
+                ("estimate_point", models.UUIDField(blank=True, null=True)),
+                ("name", models.CharField(max_length=255, verbose_name="Issue Name")),
+                ("description", models.JSONField(blank=True, default=dict)),
+                ("description_html", models.TextField(blank=True, default="<p></p>")),
+                ("description_stripped", models.TextField(blank=True, null=True)),
+                ("description_binary", models.BinaryField(null=True)),
+                (
+                    "priority",
+                    models.CharField(
+                        choices=[
+                            ("urgent", "Urgent"),
+                            ("high", "High"),
+                            ("medium", "Medium"),
+                            ("low", "Low"),
+                            ("none", "None"),
+                        ],
+                        default="none",
+                        max_length=30,
+                        verbose_name="Issue Priority",
+                    ),
+                ),
+                ("start_date", models.DateField(blank=True, null=True)),
+                ("target_date", models.DateField(blank=True, null=True)),
+                (
+                    "sequence_id",
+                    models.IntegerField(default=1, verbose_name="Issue Sequence ID"),
+                ),
+                ("sort_order", models.FloatField(default=65535)),
+                ("completed_at", models.DateTimeField(null=True)),
+                ("archived_at", models.DateField(null=True)),
+                ("is_draft", models.BooleanField(default=False)),
+                (
+                    "external_source",
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    "external_id",
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                ("type", models.UUIDField(blank=True, null=True)),
+                (
+                    "last_saved_at",
+                    models.DateTimeField(default=django.utils.timezone.now),
+                ),
+                ("owned_by", models.UUIDField()),
+                (
+                    "assignees",
+                    django.contrib.postgres.fields.ArrayField(
+                        base_field=models.UUIDField(),
+                        blank=True,
+                        default=list,
+                        size=None,
+                    ),
+                ),
+                (
+                    "labels",
+                    django.contrib.postgres.fields.ArrayField(
+                        base_field=models.UUIDField(),
+                        blank=True,
+                        default=list,
+                        size=None,
+                    ),
+                ),
+                ("cycle", models.UUIDField(blank=True, null=True)),
+                (
+                    "modules",
+                    django.contrib.postgres.fields.ArrayField(
+                        base_field=models.UUIDField(),
+                        blank=True,
+                        default=list,
+                        size=None,
+                    ),
+                ),
+                ("properties", models.JSONField(default=dict)),
+                ("meta", models.JSONField(default=dict)),
+                (
+                    "created_by",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="%(class)s_created_by",
+                        to=settings.AUTH_USER_MODEL,
+                        verbose_name="Created By",
+                    ),
+                ),
+                (
+                    "issue",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="versions",
+                        to="db.issue",
+                    ),
+                ),
+                (
+                    "project",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="project_%(class)s",
+                        to="db.project",
+                    ),
+                ),
+                (
+                    "updated_by",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="%(class)s_updated_by",
+                        to=settings.AUTH_USER_MODEL,
+                        verbose_name="Last Modified By",
+                    ),
+                ),
+                (
+                    "workspace",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="workspace_%(class)s",
+                        to="db.workspace",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Issue Version",
+                "verbose_name_plural": "Issue Versions",
+                "db_table": "issue_versions",
+                "ordering": ("-created_at",),
+            },
+        ),
+        migrations.AlterUniqueTogether(
+            name="teampage",
+            unique_together=None,
+        ),
+        migrations.RemoveField(
+            model_name="teampage",
+            name="created_by",
+        ),
+        migrations.RemoveField(
+            model_name="teampage",
+            name="page",
+        ),
+        migrations.RemoveField(
+            model_name="teampage",
+            name="team",
+        ),
+        migrations.RemoveField(
+            model_name="teampage",
+            name="updated_by",
+        ),
+        migrations.RemoveField(
+            model_name="teampage",
+            name="workspace",
+        ),
+        migrations.RemoveField(
+            model_name="page",
+            name="teams",
+        ),
+        migrations.RemoveField(
+            model_name="team",
+            name="members",
+        ),
+        migrations.AddField(
+            model_name="fileasset",
+            name="entity_identifier",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name="webhook",
+            name="is_internal",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AlterField(
+            model_name="fileasset",
+            name="entity_type",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AlterField(
+            model_name="webhook",
+            name="url",
+            field=models.URLField(
+                max_length=1024,
+                validators=[
+                    plane.db.models.webhook.validate_schema,
+                    plane.db.models.webhook.validate_domain,
+                ],
+            ),
+        ),
+        migrations.DeleteModel(
+            name="TeamMember",
+        ),
+        migrations.DeleteModel(
+            name="TeamPage",
+        ),
+    ]

apiserver/plane/db/migrations/0087_remove_issueversion_description_and_more.py

@@ -0,0 +1,117 @@
+# Generated by Django 4.2.17 on 2024-12-13 10:09
+
+from django.conf import settings
+import django.core.validators
+from django.db import migrations, models
+import django.db.models.deletion
+import django.utils.timezone
+import plane.db.models.user
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('db', '0086_issueversion_alter_teampage_unique_together_and_more'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='issueversion',
+            name='description',
+        ),
+        migrations.RemoveField(
+            model_name='issueversion',
+            name='description_binary',
+        ),
+        migrations.RemoveField(
+            model_name='issueversion',
+            name='description_html',
+        ),
+        migrations.RemoveField(
+            model_name='issueversion',
+            name='description_stripped',
+        ),
+        migrations.AddField(
+            model_name='issueversion',
+            name='activity',
+            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='versions', to='db.issueactivity'),
+        ),
+        migrations.AddField(
+            model_name='profile',
+            name='is_mobile_onboarded',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name='profile',
+            name='mobile_onboarding_step',
+            field=models.JSONField(default=plane.db.models.user.get_mobile_default_onboarding),
+        ),
+        migrations.AddField(
+            model_name='profile',
+            name='mobile_timezone_auto_set',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name='profile',
+            name='language',
+            field=models.CharField(default='en', max_length=255),
+        ),
+        migrations.AlterField(
+            model_name='issueversion',
+            name='owned_by',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='issue_versions', to=settings.AUTH_USER_MODEL),
+        ),
+        migrations.CreateModel(
+            name='Sticky',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, verbose_name='Created At')),
+                ('updated_at', models.DateTimeField(auto_now=True, verbose_name='Last Modified At')),
+                ('deleted_at', models.DateTimeField(blank=True, null=True, verbose_name='Deleted At')),
+                ('id', models.UUIDField(db_index=True, default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True)),
+                ('name', models.TextField()),
+                ('description', models.JSONField(blank=True, default=dict)),
+                ('description_html', models.TextField(blank=True, default='<p></p>')),
+                ('description_stripped', models.TextField(blank=True, null=True)),
+                ('description_binary', models.BinaryField(null=True)),
+                ('logo_props', models.JSONField(default=dict)),
+                ('color', models.CharField(blank=True, max_length=255, null=True)),
+                ('background_color', models.CharField(blank=True, max_length=255, null=True)),
+                ('created_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_created_by', to=settings.AUTH_USER_MODEL, verbose_name='Created By')),
+                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='stickies', to=settings.AUTH_USER_MODEL)),
+                ('updated_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_updated_by', to=settings.AUTH_USER_MODEL, verbose_name='Last Modified By')),
+                ('workspace', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='stickies', to='db.workspace')),
+            ],
+            options={
+                'verbose_name': 'Sticky',
+                'verbose_name_plural': 'Stickies',
+                'db_table': 'stickies',
+                'ordering': ('-created_at',),
+            },
+        ),
+        migrations.CreateModel(
+            name='IssueDescriptionVersion',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, verbose_name='Created At')),
+                ('updated_at', models.DateTimeField(auto_now=True, verbose_name='Last Modified At')),
+                ('deleted_at', models.DateTimeField(blank=True, null=True, verbose_name='Deleted At')),
+                ('id', models.UUIDField(db_index=True, default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True)),
+                ('description_binary', models.BinaryField(null=True)),
+                ('description_html', models.TextField(blank=True, default='<p></p>')),
+                ('description_stripped', models.TextField(blank=True, null=True)),
+                ('description_json', models.JSONField(blank=True, default=dict)),
+                ('last_saved_at', models.DateTimeField(default=django.utils.timezone.now)),
+                ('created_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_created_by', to=settings.AUTH_USER_MODEL, verbose_name='Created By')),
+                ('issue', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='description_versions', to='db.issue')),
+                ('owned_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='issue_description_versions', to=settings.AUTH_USER_MODEL)),
+                ('project', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='project_%(class)s', to='db.project')),
+                ('updated_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='%(class)s_updated_by', to=settings.AUTH_USER_MODEL, verbose_name='Last Modified By')),
+                ('workspace', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='workspace_%(class)s', to='db.workspace')),
+            ],
+            options={
+                'verbose_name': 'Issue Description Version',
+                'verbose_name_plural': 'Issue Description Versions',
+                'db_table': 'issue_description_versions',
+            },
+        ),
+    ]

apiserver/plane/db/models/__init__.py

@@ -41,6 +41,8 @@ from .issue import (
     IssueSequence,
     IssueSubscriber,
     IssueVote,
+    IssueVersion,
+    IssueDescriptionVersion,
 )
 from .module import Module, ModuleIssue, ModuleLink, ModuleMember, ModuleUserProperties
 from .notification import EmailNotificationLog, Notification, UserNotificationPreference
@@ -53,7 +55,6 @@ from .project import (
     ProjectMemberInvite,
     ProjectPublicMember,
 )
-from .deploy_board import DeployBoard
 from .session import Session
 from .social_connection import SocialLoginConnection
 from .state import State
@@ -61,8 +62,6 @@ from .user import Account, Profile, User
 from .view import IssueView
 from .webhook import Webhook, WebhookLog
 from .workspace import (
-    Team,
-    TeamMember,
     Workspace,
     WorkspaceBaseModel,
     WorkspaceMember,
@@ -71,24 +70,6 @@ from .workspace import (
     WorkspaceUserProperties,
 )
 
-from .importer import Importer
-
-from .page import Page, PageLog, PageLabel
-
-from .estimate import Estimate, EstimatePoint
-
-from .intake import Intake, IntakeIssue
-
-from .analytic import AnalyticView
-
-from .notification import Notification, UserNotificationPreference, EmailNotificationLog
-
-from .exporter import ExporterHistory
-
-from .webhook import Webhook, WebhookLog
-
-from .dashboard import Dashboard, DashboardWidget, Widget
-
 from .favorite import UserFavorite
 
 from .issue_type import IssueType
@@ -98,3 +79,5 @@ from .recent_visit import UserRecentVisit
 from .label import Label
 
 from .device import Device, DeviceSession
+
+from .sticky import Sticky

apiserver/plane/db/models/asset.py

@@ -61,9 +61,8 @@ class FileAsset(BaseModel):
     page = models.ForeignKey(
         "db.Page", on_delete=models.CASCADE, null=True, related_name="assets"
     )
-    entity_type = models.CharField(
-        max_length=255, choices=EntityTypeContext.choices, null=True, blank=True
-    )
+    entity_type = models.CharField(max_length=255, null=True, blank=True)
+    entity_identifier = models.CharField(max_length=255, null=True, blank=True)
     is_deleted = models.BooleanField(default=False)
     is_archived = models.BooleanField(default=False)
     external_id = models.CharField(max_length=255, null=True, blank=True)

apiserver/plane/db/models/issue.py

@@ -9,11 +9,13 @@ from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models, transaction
 from django.utils import timezone
 from django.db.models import Q
+from django import apps
 
 # Module imports
 from plane.utils.html_processor import strip_tags
 from plane.db.mixins import SoftDeletionManager
-
+from plane.utils.exception_logger import log_exception
+from .base import BaseModel
 from .project import ProjectBaseModel
 
 
@@ -656,3 +658,165 @@ class IssueVote(ProjectBaseModel):
 
     def __str__(self):
         return f"{self.issue.name} {self.actor.email}"
+
+
+class IssueVersion(ProjectBaseModel):
+    PRIORITY_CHOICES = (
+        ("urgent", "Urgent"),
+        ("high", "High"),
+        ("medium", "Medium"),
+        ("low", "Low"),
+        ("none", "None"),
+    )
+
+    parent = models.UUIDField(blank=True, null=True)
+    state = models.UUIDField(blank=True, null=True)
+    estimate_point = models.UUIDField(blank=True, null=True)
+    name = models.CharField(max_length=255, verbose_name="Issue Name")
+    priority = models.CharField(
+        max_length=30,
+        choices=PRIORITY_CHOICES,
+        verbose_name="Issue Priority",
+        default="none",
+    )
+    start_date = models.DateField(null=True, blank=True)
+    target_date = models.DateField(null=True, blank=True)
+    assignees = ArrayField(models.UUIDField(), blank=True, default=list)
+    sequence_id = models.IntegerField(default=1, verbose_name="Issue Sequence ID")
+    labels = ArrayField(models.UUIDField(), blank=True, default=list)
+    sort_order = models.FloatField(default=65535)
+    completed_at = models.DateTimeField(null=True)
+    archived_at = models.DateField(null=True)
+    is_draft = models.BooleanField(default=False)
+    external_source = models.CharField(max_length=255, null=True, blank=True)
+    external_id = models.CharField(max_length=255, blank=True, null=True)
+    type = models.UUIDField(blank=True, null=True)
+    cycle = models.UUIDField(null=True, blank=True)
+    modules = ArrayField(models.UUIDField(), blank=True, default=list)
+    properties = models.JSONField(default=dict)  # issue properties
+    meta = models.JSONField(default=dict)  # issue meta
+    last_saved_at = models.DateTimeField(default=timezone.now)
+
+    issue = models.ForeignKey(
+        "db.Issue", on_delete=models.CASCADE, related_name="versions"
+    )
+    activity = models.ForeignKey(
+        "db.IssueActivity",
+        on_delete=models.SET_NULL,
+        null=True,
+        related_name="versions",
+    )
+    owned_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="issue_versions",
+    )
+
+    class Meta:
+        verbose_name = "Issue Version"
+        verbose_name_plural = "Issue Versions"
+        db_table = "issue_versions"
+        ordering = ("-created_at",)
+
+    def __str__(self):
+        return f"{self.name} <{self.project.name}>"
+
+    @classmethod
+    def log_issue_version(cls, issue, user):
+        try:
+            """
+            Log the issue version
+            """
+
+            Module = apps.get_model("db.Module")
+            CycleIssue = apps.get_model("db.CycleIssue")
+            IssueAssignee = apps.get_model("db.IssueAssignee")
+            IssueLabel = apps.get_model("db.IssueLabel")
+
+            cycle_issue = CycleIssue.objects.filter(issue=issue).first()
+
+            cls.objects.create(
+                issue=issue,
+                parent=issue.parent_id,
+                state=issue.state_id,
+                estimate_point=issue.estimate_point_id,
+                name=issue.name,
+                priority=issue.priority,
+                start_date=issue.start_date,
+                target_date=issue.target_date,
+                assignees=list(
+                    IssueAssignee.objects.filter(issue=issue).values_list(
+                        "assignee_id", flat=True
+                    )
+                ),
+                sequence_id=issue.sequence_id,
+                labels=list(
+                    IssueLabel.objects.filter(issue=issue).values_list(
+                        "label_id", flat=True
+                    )
+                ),
+                sort_order=issue.sort_order,
+                completed_at=issue.completed_at,
+                archived_at=issue.archived_at,
+                is_draft=issue.is_draft,
+                external_source=issue.external_source,
+                external_id=issue.external_id,
+                type=issue.type_id,
+                cycle=cycle_issue.cycle_id if cycle_issue else None,
+                modules=list(
+                    Module.objects.filter(issue=issue).values_list("id", flat=True)
+                ),
+                properties={},
+                meta={},
+                last_saved_at=timezone.now(),
+                owned_by=user,
+            )
+            return True
+        except Exception as e:
+            log_exception(e)
+            return False
+
+
+class IssueDescriptionVersion(ProjectBaseModel):
+    issue = models.ForeignKey(
+        "db.Issue", on_delete=models.CASCADE, related_name="description_versions"
+    )
+    description_binary = models.BinaryField(null=True)
+    description_html = models.TextField(blank=True, default="<p></p>")
+    description_stripped = models.TextField(blank=True, null=True)
+    description_json = models.JSONField(default=dict, blank=True)
+    last_saved_at = models.DateTimeField(default=timezone.now)
+    owned_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="issue_description_versions",
+    )
+
+    class Meta:
+        verbose_name = "Issue Description Version"
+        verbose_name_plural = "Issue Description Versions"
+        db_table = "issue_description_versions"
+
+    @classmethod
+    def log_issue_description_version(cls, issue, user):
+        try:
+            """
+            Log the issue description version
+            """
+            cls.objects.create(
+                workspace_id=issue.workspace_id,
+                project_id=issue.project_id,
+                created_by_id=issue.created_by_id,
+                updated_by_id=issue.updated_by_id,
+                owned_by_id=user,
+                last_saved_at=timezone.now(),
+                issue_id=issue.id,
+                description_binary=issue.description_binary,
+                description_html=issue.description_html,
+                description_stripped=issue.description_stripped,
+                description_json=issue.description,
+            )
+            return True
+        except Exception as e:
+            log_exception(e)
+            return False

apiserver/plane/db/models/page.py

@@ -50,9 +50,6 @@ class Page(BaseModel):
     projects = models.ManyToManyField(
         "db.Project", related_name="pages", through="db.ProjectPage"
     )
-    teams = models.ManyToManyField(
-        "db.Team", related_name="pages", through="db.TeamPage"
-    )
 
     class Meta:
         verbose_name = "Page"
@@ -160,32 +157,6 @@ class ProjectPage(BaseModel):
         return f"{self.project.name} {self.page.name}"
 
 
-class TeamPage(BaseModel):
-    team = models.ForeignKey(
-        "db.Team", on_delete=models.CASCADE, related_name="team_pages"
-    )
-    page = models.ForeignKey(
-        "db.Page", on_delete=models.CASCADE, related_name="team_pages"
-    )
-    workspace = models.ForeignKey(
-        "db.Workspace", on_delete=models.CASCADE, related_name="team_pages"
-    )
-
-    class Meta:
-        unique_together = ["team", "page", "deleted_at"]
-        constraints = [
-            models.UniqueConstraint(
-                fields=["team", "page"],
-                condition=models.Q(deleted_at__isnull=True),
-                name="team_page_unique_team_page_when_deleted_at_null",
-            )
-        ]
-        verbose_name = "Team Page"
-        verbose_name_plural = "Team Pages"
-        db_table = "team_pages"
-        ordering = ("-created_at",)
-
-
 class PageVersion(BaseModel):
     workspace = models.ForeignKey(
         "db.Workspace", on_delete=models.CASCADE, related_name="page_versions"

apiserver/plane/db/models/sticky.py

@@ -0,0 +1,32 @@
+# Django imports
+from django.conf import settings
+from django.db import models
+
+# Module imports
+from .base import BaseModel
+
+
+class Sticky(BaseModel):
+    name = models.TextField()
+
+    description = models.JSONField(blank=True, default=dict)
+    description_html = models.TextField(blank=True, default="<p></p>")
+    description_stripped = models.TextField(blank=True, null=True)
+    description_binary = models.BinaryField(null=True)
+
+    logo_props = models.JSONField(default=dict)
+    color = models.CharField(max_length=255, blank=True, null=True)
+    background_color = models.CharField(max_length=255, blank=True, null=True)
+
+    workspace = models.ForeignKey(
+        "db.Workspace", on_delete=models.CASCADE, related_name="stickies"
+    )
+    owner = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="stickies"
+    )
+
+    class Meta:
+        verbose_name = "Sticky"
+        verbose_name_plural = "Stickies"
+        db_table = "stickies"
+        ordering = ("-created_at",)

apiserver/plane/db/models/user.py

@@ -26,6 +26,14 @@ def get_default_onboarding():
     }
 
 
+def get_mobile_default_onboarding():
+    return {
+        "profile_complete": False,
+        "workspace_create": False,
+        "workspace_join": False,
+    }
+
+
 class User(AbstractBaseUser, PermissionsMixin):
     id = models.UUIDField(
         default=uuid.uuid4, unique=True, editable=False, db_index=True, primary_key=True
@@ -178,6 +186,12 @@ class Profile(TimeAuditModel):
     billing_address = models.JSONField(null=True)
     has_billing_address = models.BooleanField(default=False)
     company_name = models.CharField(max_length=255, blank=True)
+    # mobile
+    is_mobile_onboarded = models.BooleanField(default=False)
+    mobile_onboarding_step = models.JSONField(default=get_mobile_default_onboarding)
+    mobile_timezone_auto_set = models.BooleanField(default=False)
+    # language
+    language = models.CharField(max_length=255, default="en")
 
     class Meta:
         verbose_name = "Profile"

apiserver/plane/db/models/webhook.py

@@ -31,7 +31,9 @@ class Webhook(BaseModel):
     workspace = models.ForeignKey(
         "db.Workspace", on_delete=models.CASCADE, related_name="workspace_webhooks"
     )
-    url = models.URLField(validators=[validate_schema, validate_domain])
+    url = models.URLField(
+        validators=[validate_schema, validate_domain], max_length=1024
+    )
     is_active = models.BooleanField(default=True)
     secret_key = models.CharField(max_length=255, default=generate_token)
     project = models.BooleanField(default=False)
@@ -39,6 +41,7 @@ class Webhook(BaseModel):
     module = models.BooleanField(default=False)
     cycle = models.BooleanField(default=False)
     issue_comment = models.BooleanField(default=False)
+    is_internal = models.BooleanField(default=False)
 
     def __str__(self):
         return f"{self.workspace.slug} {self.url}"

apiserver/plane/db/models/workspace.py

@@ -239,13 +239,6 @@ class WorkspaceMemberInvite(BaseModel):
 class Team(BaseModel):
     name = models.CharField(max_length=255, verbose_name="Team Name")
     description = models.TextField(verbose_name="Team Description", blank=True)
-    members = models.ManyToManyField(
-        settings.AUTH_USER_MODEL,
-        blank=True,
-        related_name="members",
-        through="TeamMember",
-        through_fields=("team", "member"),
-    )
     workspace = models.ForeignKey(
         Workspace, on_delete=models.CASCADE, related_name="workspace_team"
     )
@@ -270,33 +263,6 @@ class Team(BaseModel):
         ordering = ("-created_at",)
 
 
-class TeamMember(BaseModel):
-    workspace = models.ForeignKey(
-        Workspace, on_delete=models.CASCADE, related_name="team_member"
-    )
-    team = models.ForeignKey(Team, on_delete=models.CASCADE, related_name="team_member")
-    member = models.ForeignKey(
-        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="team_member"
-    )
-
-    def __str__(self):
-        return self.team.name
-
-    class Meta:
-        unique_together = ["team", "member", "deleted_at"]
-        constraints = [
-            models.UniqueConstraint(
-                fields=["team", "member"],
-                condition=models.Q(deleted_at__isnull=True),
-                name="team_member_unique_team_member_when_deleted_at_null",
-            )
-        ]
-        verbose_name = "Team Member"
-        verbose_name_plural = "Team Members"
-        db_table = "team_members"
-        ordering = ("-created_at",)
-
-
 class WorkspaceTheme(BaseModel):
     workspace = models.ForeignKey(
         "db.Workspace", on_delete=models.CASCADE, related_name="themes"

apiserver/plane/license/api/serializers/__init__.py

@@ -2,3 +2,4 @@ from .instance import InstanceSerializer
 
 from .configuration import InstanceConfigurationSerializer
 from .admin import InstanceAdminSerializer, InstanceAdminMeSerializer
+from .workspace import WorkspaceSerializer

apiserver/plane/license/api/serializers/user.py

@@ -0,0 +1,8 @@
+from .base import BaseSerializer
+from plane.db.models import User
+
+
+class UserLiteSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = ["id", "email", "first_name", "last_name"]

apiserver/plane/license/api/serializers/workspace.py

@@ -0,0 +1,37 @@
+# Third Party Imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from .user import UserLiteSerializer
+from plane.db.models import Workspace
+from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
+
+
+class WorkspaceSerializer(BaseSerializer):
+    owner = UserLiteSerializer(read_only=True)
+    logo_url = serializers.CharField(read_only=True)
+    total_projects = serializers.IntegerField(read_only=True)
+    total_members = serializers.IntegerField(read_only=True)
+
+    def validate_slug(self, value):
+        # Check if the slug is restricted
+        if value in RESTRICTED_WORKSPACE_SLUGS:
+            raise serializers.ValidationError("Slug is not valid")
+        # Check uniqueness case-insensitively
+        if Workspace.objects.filter(slug__iexact=value).exists():
+            raise serializers.ValidationError("Slug is already in use")
+        return value
+
+    class Meta:
+        model = Workspace
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "owner",
+            "logo_url",
+        ]

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

@@ -13,4 +13,8 @@ from .admin import (
     InstanceAdminUserSessionEndpoint,
 )
 
-from .changelog import ChangeLogEndpoint
+
+from .workspace import (
+    InstanceWorkSpaceAvailabilityCheckEndpoint,
+    InstanceWorkSpaceEndpoint,
+)

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

@@ -1,33 +0,0 @@
-# Python imports
-import requests
-
-# Django imports
-from django.conf import settings
-
-# Third party imports
-from rest_framework.response import Response
-from rest_framework import status
-from rest_framework.permissions import AllowAny
-
-# plane imports
-from .base import BaseAPIView
-
-
-class ChangeLogEndpoint(BaseAPIView):
-    permission_classes = [AllowAny]
-
-    def fetch_change_logs(self):
-        response = requests.get(settings.INSTANCE_CHANGELOG_URL)
-        response.raise_for_status()
-        return response.json()
-
-    def get(self, request):
-        # Fetch the changelog
-        if settings.INSTANCE_CHANGELOG_URL:
-            data = self.fetch_change_logs()
-            return Response(data, status=status.HTTP_200_OK)
-        else:
-            return Response(
-                {"error": "could not fetch changelog please try again later"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )

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

@@ -45,6 +45,7 @@ class InstanceEndpoint(BaseAPIView):
         # Get all the configuration
         (
             ENABLE_SIGNUP,
+            DISABLE_WORKSPACE_CREATION,
             IS_GOOGLE_ENABLED,
             IS_GITHUB_ENABLED,
             GITHUB_APP_NAME,
@@ -65,6 +66,10 @@ class InstanceEndpoint(BaseAPIView):
                     "key": "ENABLE_SIGNUP",
                     "default": os.environ.get("ENABLE_SIGNUP", "0"),
                 },
+                {
+                    "key": "DISABLE_WORKSPACE_CREATION",
+                    "default": os.environ.get("DISABLE_WORKSPACE_CREATION", "0"),
+                },
                 {
                     "key": "IS_GOOGLE_ENABLED",
                     "default": os.environ.get("IS_GOOGLE_ENABLED", "0"),
@@ -125,6 +130,7 @@ class InstanceEndpoint(BaseAPIView):
         data = {}
         # Authentication
         data["enable_signup"] = ENABLE_SIGNUP == "1"
+        data["is_workspace_creation_disabled"] = DISABLE_WORKSPACE_CREATION == "1"
         data["is_google_enabled"] = IS_GOOGLE_ENABLED == "1"
         data["is_github_enabled"] = IS_GITHUB_ENABLED == "1"
         data["is_gitlab_enabled"] = IS_GITLAB_ENABLED == "1"

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

@@ -0,0 +1,113 @@
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+from django.db import IntegrityError
+from django.db.models import OuterRef, Func, F
+
+# Module imports
+from plane.app.views.base import BaseAPIView
+from plane.license.api.permissions import InstanceAdminPermission
+from plane.db.models import Workspace, WorkspaceMember, Project
+from plane.license.api.serializers import WorkspaceSerializer
+from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
+
+
+class InstanceWorkSpaceAvailabilityCheckEndpoint(BaseAPIView):
+    permission_classes = [InstanceAdminPermission]
+
+    def get(self, request):
+        slug = request.GET.get("slug", False)
+
+        if not slug or slug == "":
+            return Response(
+                {"error": "Workspace Slug is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace = (
+            Workspace.objects.filter(slug__iexact=slug).exists()
+            or slug in RESTRICTED_WORKSPACE_SLUGS
+        )
+        return Response({"status": not workspace}, status=status.HTTP_200_OK)
+
+
+class InstanceWorkSpaceEndpoint(BaseAPIView):
+    model = Workspace
+    serializer_class = WorkspaceSerializer
+    permission_classes = [InstanceAdminPermission]
+
+    def get(self, request):
+        project_count = (
+            Project.objects.filter(workspace_id=OuterRef("id"))
+            .order_by()
+            .annotate(count=Func(F("id"), function="Count"))
+            .values("count")
+        )
+
+        member_count = (
+            WorkspaceMember.objects.filter(
+                workspace=OuterRef("id"), member__is_bot=False, is_active=True
+            )
+            .select_related("owner")
+            .order_by()
+            .annotate(count=Func(F("id"), function="Count"))
+            .values("count")
+        )
+
+        workspaces = Workspace.objects.annotate(
+            total_projects=project_count, total_members=member_count
+        )
+
+        # Add search functionality
+        search = request.query_params.get("search", None)
+        if search:
+            workspaces = workspaces.filter(name__icontains=search)
+
+        return self.paginate(
+            request=request,
+            queryset=workspaces,
+            on_results=lambda results: WorkspaceSerializer(results, many=True).data,
+            max_per_page=10,
+            default_per_page=10,
+        )
+
+    def post(self, request):
+        try:
+            serializer = WorkspaceSerializer(data=request.data)
+
+            slug = request.data.get("slug", False)
+            name = request.data.get("name", False)
+
+            if not name or not slug:
+                return Response(
+                    {"error": "Both name and slug are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if len(name) > 80 or len(slug) > 48:
+                return Response(
+                    {"error": "The maximum length for name is 80 and for slug is 48"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if serializer.is_valid(raise_exception=True):
+                serializer.save(owner=request.user)
+                # Create Workspace member
+                _ = WorkspaceMember.objects.create(
+                    workspace_id=serializer.data["id"],
+                    member=request.user,
+                    role=20,
+                    company_role=request.data.get("company_role", ""),
+                )
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(
+                [serializer.errors[error][0] for error in serializer.errors],
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"slug": "The workspace with the slug already exists"},
+                    status=status.HTTP_410_GONE,
+                )

apiserver/plane/license/bgtasks/tracer.py

@@ -16,76 +16,55 @@ from plane.db.models import (
     Page,
     WorkspaceMember,
 )
+from plane.utils.telemetry import init_tracer, shutdown_tracer
 
 
 @shared_task
 def instance_traces():
-    # Get the tracer
-    tracer = trace.get_tracer(__name__)
+    try:
+        init_tracer()
+        # Check if the instance is registered
+        instance = Instance.objects.first()
 
-    # Check if the instance is registered
-    instance = Instance.objects.first()
+        # If instance is None then return
+        if instance is None:
+            return
 
-    # If instance is None then return
-    if instance is None:
-        return
+        if instance.is_telemetry_enabled:
+            # Get the tracer
+            tracer = trace.get_tracer(__name__)
+            # Instance details
+            with tracer.start_as_current_span("instance_details") as span:
+                # Count of all models
+                workspace_count = Workspace.objects.count()
+                user_count = User.objects.count()
+                project_count = Project.objects.count()
+                issue_count = Issue.objects.count()
+                module_count = Module.objects.count()
+                cycle_count = Cycle.objects.count()
+                cycle_issue_count = CycleIssue.objects.count()
+                module_issue_count = ModuleIssue.objects.count()
+                page_count = Page.objects.count()
 
-    if instance.is_telemetry_enabled:
-        # Instance details
-        with tracer.start_as_current_span("instance_details") as span:
-            # Count of all models
-            workspace_count = Workspace.objects.count()
-            user_count = User.objects.count()
-            project_count = Project.objects.count()
-            issue_count = Issue.objects.count()
-            module_count = Module.objects.count()
-            cycle_count = Cycle.objects.count()
-            cycle_issue_count = CycleIssue.objects.count()
-            module_issue_count = ModuleIssue.objects.count()
-            page_count = Page.objects.count()
-
-            # Set span attributes
-            span.set_attribute("instance_id", instance.instance_id)
-            span.set_attribute("instance_name", instance.instance_name)
-            span.set_attribute("current_version", instance.current_version)
-            span.set_attribute("latest_version", instance.latest_version)
-            span.set_attribute("is_telemetry_enabled", instance.is_telemetry_enabled)
-            span.set_attribute("is_support_required", instance.is_support_required)
-            span.set_attribute("is_setup_done", instance.is_setup_done)
-            span.set_attribute(
-                "is_signup_screen_visited", instance.is_signup_screen_visited
-            )
-            span.set_attribute("is_verified", instance.is_verified)
-            span.set_attribute("edition", instance.edition)
-            span.set_attribute("domain", instance.domain)
-            span.set_attribute("is_test", instance.is_test)
-            span.set_attribute("user_count", user_count)
-            span.set_attribute("workspace_count", workspace_count)
-            span.set_attribute("project_count", project_count)
-            span.set_attribute("issue_count", issue_count)
-            span.set_attribute("module_count", module_count)
-            span.set_attribute("cycle_count", cycle_count)
-            span.set_attribute("cycle_issue_count", cycle_issue_count)
-            span.set_attribute("module_issue_count", module_issue_count)
-            span.set_attribute("page_count", page_count)
-
-        # Workspace details
-        for workspace in Workspace.objects.all():
-            # Count of all models
-            project_count = Project.objects.filter(workspace=workspace).count()
-            issue_count = Issue.objects.filter(workspace=workspace).count()
-            module_count = Module.objects.filter(workspace=workspace).count()
-            cycle_count = Cycle.objects.filter(workspace=workspace).count()
-            cycle_issue_count = CycleIssue.objects.filter(workspace=workspace).count()
-            module_issue_count = ModuleIssue.objects.filter(workspace=workspace).count()
-            page_count = Page.objects.filter(workspace=workspace).count()
-            member_count = WorkspaceMember.objects.filter(workspace=workspace).count()
-
-            # Set span attributes
-            with tracer.start_as_current_span("workspace_details") as span:
+                # Set span attributes
                 span.set_attribute("instance_id", instance.instance_id)
-                span.set_attribute("workspace_id", str(workspace.id))
-                span.set_attribute("workspace_slug", workspace.slug)
+                span.set_attribute("instance_name", instance.instance_name)
+                span.set_attribute("current_version", instance.current_version)
+                span.set_attribute("latest_version", instance.latest_version)
+                span.set_attribute(
+                    "is_telemetry_enabled", instance.is_telemetry_enabled
+                )
+                span.set_attribute("is_support_required", instance.is_support_required)
+                span.set_attribute("is_setup_done", instance.is_setup_done)
+                span.set_attribute(
+                    "is_signup_screen_visited", instance.is_signup_screen_visited
+                )
+                span.set_attribute("is_verified", instance.is_verified)
+                span.set_attribute("edition", instance.edition)
+                span.set_attribute("domain", instance.domain)
+                span.set_attribute("is_test", instance.is_test)
+                span.set_attribute("user_count", user_count)
+                span.set_attribute("workspace_count", workspace_count)
                 span.set_attribute("project_count", project_count)
                 span.set_attribute("issue_count", issue_count)
                 span.set_attribute("module_count", module_count)
@@ -93,6 +72,40 @@ def instance_traces():
                 span.set_attribute("cycle_issue_count", cycle_issue_count)
                 span.set_attribute("module_issue_count", module_issue_count)
                 span.set_attribute("page_count", page_count)
-                span.set_attribute("member_count", member_count)
 
-    return
+            # Workspace details
+            for workspace in Workspace.objects.all():
+                # Count of all models
+                project_count = Project.objects.filter(workspace=workspace).count()
+                issue_count = Issue.objects.filter(workspace=workspace).count()
+                module_count = Module.objects.filter(workspace=workspace).count()
+                cycle_count = Cycle.objects.filter(workspace=workspace).count()
+                cycle_issue_count = CycleIssue.objects.filter(
+                    workspace=workspace
+                ).count()
+                module_issue_count = ModuleIssue.objects.filter(
+                    workspace=workspace
+                ).count()
+                page_count = Page.objects.filter(workspace=workspace).count()
+                member_count = WorkspaceMember.objects.filter(
+                    workspace=workspace
+                ).count()
+
+                # Set span attributes
+                with tracer.start_as_current_span("workspace_details") as span:
+                    span.set_attribute("instance_id", instance.instance_id)
+                    span.set_attribute("workspace_id", str(workspace.id))
+                    span.set_attribute("workspace_slug", workspace.slug)
+                    span.set_attribute("project_count", project_count)
+                    span.set_attribute("issue_count", issue_count)
+                    span.set_attribute("module_count", module_count)
+                    span.set_attribute("cycle_count", cycle_count)
+                    span.set_attribute("cycle_issue_count", cycle_issue_count)
+                    span.set_attribute("module_issue_count", module_issue_count)
+                    span.set_attribute("page_count", page_count)
+                    span.set_attribute("member_count", member_count)
+
+        return
+    finally:
+        # Shutdown the tracer
+        shutdown_tracer()

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

@@ -29,6 +29,12 @@ class Command(BaseCommand):
                 "category": "AUTHENTICATION",
                 "is_encrypted": False,
             },
+            {
+                "key": "DISABLE_WORKSPACE_CREATION",
+                "value": os.environ.get("DISABLE_WORKSPACE_CREATION", "0"),
+                "category": "WORKSPACE_MANAGEMENT",
+                "is_encrypted": False,
+            },
             {
                 "key": "ENABLE_EMAIL_PASSWORD",
                 "value": os.environ.get("ENABLE_EMAIL_PASSWORD", "1"),

apiserver/plane/license/urls.py

@@ -11,12 +11,12 @@ from plane.license.api.views import (
     InstanceAdminUserMeEndpoint,
     InstanceAdminSignOutEndpoint,
     InstanceAdminUserSessionEndpoint,
-    ChangeLogEndpoint,
+    InstanceWorkSpaceAvailabilityCheckEndpoint,
+    InstanceWorkSpaceEndpoint,
 )
 
 urlpatterns = [
     path("", InstanceEndpoint.as_view(), name="instance"),
-    path("changelog/", ChangeLogEndpoint.as_view(), name="instance-changelog"),
     path("admins/", InstanceAdminEndpoint.as_view(), name="instance-admins"),
     path("admins/me/", InstanceAdminUserMeEndpoint.as_view(), name="instance-admins"),
     path(
@@ -55,4 +55,10 @@ urlpatterns = [
         EmailCredentialCheckEndpoint.as_view(),
         name="email-credential-check",
     ),
+    path(
+        "workspace-slug-check/",
+        InstanceWorkSpaceAvailabilityCheckEndpoint.as_view(),
+        name="instance-workspace-availability",
+    ),
+    path("workspaces/", InstanceWorkSpaceEndpoint.as_view(), name="instance-workspace"),
 ]

apiserver/plane/settings/common.py

@@ -16,14 +16,6 @@ from sentry_sdk.integrations.django import DjangoIntegration
 from sentry_sdk.integrations.redis import RedisIntegration
 from corsheaders.defaults import default_headers
 
-# OpenTelemetry
-from opentelemetry import trace
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.instrumentation.django import DjangoInstrumentor
-
 
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
@@ -33,19 +25,6 @@ SECRET_KEY = os.environ.get("SECRET_KEY", get_random_secret_key())
 # SECURITY WARNING: don't run with debug turned on in production!
 DEBUG = int(os.environ.get("DEBUG", "0"))
 
-# Configure the tracer provider
-service_name = os.environ.get("SERVICE_NAME", "plane-ce-api")
-resource = Resource.create({"service.name": service_name})
-trace.set_tracer_provider(TracerProvider(resource=resource))
-# Configure the OTLP exporter
-otel_endpoint = os.environ.get("OTLP_ENDPOINT", "https://telemetry.plane.so")
-otlp_exporter = OTLPSpanExporter(endpoint=otel_endpoint)
-span_processor = BatchSpanProcessor(otlp_exporter)
-trace.get_tracer_provider().add_span_processor(span_processor)
-# Initialize Django instrumentation
-DjangoInstrumentor().instrument()
-
-
 # Allowed Hosts
 ALLOWED_HOSTS = ["*"]
 
@@ -283,6 +262,9 @@ CELERY_IMPORTS = (
     "plane.license.bgtasks.tracer",
     # management tasks
     "plane.bgtasks.dummy_data_task",
+    # issue version tasks
+    "plane.bgtasks.issue_version_sync",
+    "plane.bgtasks.issue_description_version_sync",
 )
 
 # Sentry Settings

apiserver/plane/space/urls/project.py

@@ -10,9 +10,15 @@ from plane.space.views import (
     ProjectStatesEndpoint,
     ProjectLabelsEndpoint,
     ProjectMembersEndpoint,
+    ProjectMetaDataEndpoint,
 )
 
 urlpatterns = [
+    path(
+        "anchor/<str:anchor>/meta/",
+        ProjectMetaDataEndpoint.as_view(),
+        name="project-meta",
+    ),
     path(
         "anchor/<str:anchor>/settings/",
         ProjectDeployBoardPublicSettingsEndpoint.as_view(),

apiserver/plane/space/views/__init__.py

@@ -25,3 +25,5 @@ from .state import ProjectStatesEndpoint
 from .label import ProjectLabelsEndpoint
 
 from .asset import EntityAssetEndpoint, AssetRestoreEndpoint, EntityBulkAssetEndpoint
+
+from .meta import ProjectMetaDataEndpoint

apiserver/plane/space/views/meta.py

@@ -0,0 +1,34 @@
+# third party
+from rest_framework.permissions import AllowAny
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.db.models import DeployBoard, Project
+
+from .base import BaseAPIView
+from plane.space.serializer.project import ProjectLiteSerializer
+
+
+class ProjectMetaDataEndpoint(BaseAPIView):
+    permission_classes = [AllowAny]
+
+    def get(self, request, anchor):
+        try:
+            deploy_board = DeployBoard.objects.filter(
+                anchor=anchor, entity_name="project"
+            ).first()
+        except DeployBoard.DoesNotExist:
+            return Response(
+                {"error": "Project is not published"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+        try:
+            project_id = deploy_board.entity_identifier
+            project = Project.objects.get(id=project_id)
+        except Project.DoesNotExist:
+            return Response(
+                {"error": "Project is not published"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+        serializer = ProjectLiteSerializer(project)
+        return Response(serializer.data, status=status.HTTP_200_OK)

apiserver/plane/utils/telemetry.py

@@ -0,0 +1,58 @@
+# Python imports
+import os
+import atexit
+
+# Third party imports
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.instrumentation.django import DjangoInstrumentor
+
+# Global variable to track initialization
+_TRACER_PROVIDER = None
+
+
+def init_tracer():
+    """Initialize OpenTelemetry with proper shutdown handling"""
+    global _TRACER_PROVIDER
+
+    # If already initialized, return existing provider
+    if _TRACER_PROVIDER is not None:
+        return _TRACER_PROVIDER
+
+    # Configure the tracer provider
+    service_name = os.environ.get("SERVICE_NAME", "plane-ce-api")
+    resource = Resource.create({"service.name": service_name})
+    tracer_provider = TracerProvider(resource=resource)
+
+    # Set as global tracer provider
+    trace.set_tracer_provider(tracer_provider)
+
+    # Configure the OTLP exporter
+    otel_endpoint = os.environ.get("OTLP_ENDPOINT", "https://telemetry.plane.so")
+    otlp_exporter = OTLPSpanExporter(endpoint=otel_endpoint)
+    span_processor = BatchSpanProcessor(otlp_exporter)
+    tracer_provider.add_span_processor(span_processor)
+
+    # Initialize Django instrumentation
+    DjangoInstrumentor().instrument()
+
+    # Store provider globally
+    _TRACER_PROVIDER = tracer_provider
+
+    # Register shutdown handler
+    atexit.register(shutdown_tracer)
+
+    return tracer_provider
+
+
+def shutdown_tracer():
+    """Shutdown OpenTelemetry tracers and processors"""
+    global _TRACER_PROVIDER
+
+    if _TRACER_PROVIDER is not None:
+        if hasattr(_TRACER_PROVIDER, "shutdown"):
+            _TRACER_PROVIDER.shutdown()
+        _TRACER_PROVIDER = None

apiserver/plane/utils/timezone_converter.py

@@ -0,0 +1,100 @@
+import pytz
+from plane.db.models import Project
+from datetime import datetime, time
+from datetime import timedelta
+
+def user_timezone_converter(queryset, datetime_fields, user_timezone):
+    # Create a timezone object for the user's timezone
+    user_tz = pytz.timezone(user_timezone)
+
+    # Check if queryset is a dictionary (single item) or a list of dictionaries
+    if isinstance(queryset, dict):
+        queryset_values = [queryset]
+    else:
+        queryset_values = list(queryset)
+
+    # Iterate over the dictionaries in the list
+    for item in queryset_values:
+        # Iterate over the datetime fields
+        for field in datetime_fields:
+            # Convert the datetime field to the user's timezone
+            if field in item and item[field]:
+                item[field] = item[field].astimezone(user_tz)
+
+    # If queryset was a single item, return a single item
+    if isinstance(queryset, dict):
+        return queryset_values[0]
+    else:
+        return queryset_values
+
+
+def convert_to_utc(date, project_id, is_start_date=False):
+    """
+    Converts a start date string to the project's local timezone at 12:00 AM
+    and then converts it to UTC for storage.
+
+    Args:
+        date (str): The date string in "YYYY-MM-DD" format.
+        project_id (int): The project's ID to fetch the associated timezone.
+
+    Returns:
+        datetime: The UTC datetime.
+    """
+    # Retrieve the project's timezone using the project ID
+    project = Project.objects.get(id=project_id)
+    project_timezone = project.timezone
+    if not date or not project_timezone:
+        raise ValueError("Both date and timezone must be provided.")
+
+    # Parse the string into a date object
+    start_date = datetime.strptime(date, "%Y-%m-%d").date()
+
+    # Get the project's timezone
+    local_tz = pytz.timezone(project_timezone)
+
+    # Combine the date with 12:00 AM time
+    local_datetime = datetime.combine(start_date, time.min)
+
+    # Localize the datetime to the project's timezone
+    localized_datetime = local_tz.localize(local_datetime)
+
+    # If it's an start date, add one minute
+    if is_start_date:
+        localized_datetime += timedelta(minutes=1)
+
+    # Convert the localized datetime to UTC
+    utc_datetime = localized_datetime.astimezone(pytz.utc)
+
+    # Return the UTC datetime for storage
+    return utc_datetime
+
+
+def convert_utc_to_project_timezone(utc_datetime, project_id):
+    """
+    Converts a UTC datetime (stored in the database) to the project's local timezone.
+
+    Args:
+        utc_datetime (datetime): The UTC datetime to be converted.
+        project_id (int): The project's ID to fetch the associated timezone.
+
+    Returns:
+        datetime: The datetime in the project's local timezone.
+    """
+    # Retrieve the project's timezone using the project ID
+    project = Project.objects.get(id=project_id)
+    project_timezone = project.timezone
+    if not project_timezone:
+        raise ValueError("Project timezone must be provided.")
+
+    # Get the timezone object for the project's timezone
+    local_tz = pytz.timezone(project_timezone)
+
+    # Convert the UTC datetime to the project's local timezone
+    if utc_datetime.tzinfo is None:
+        # Localize UTC datetime if it's naive (i.e., without timezone info)
+        utc_datetime = pytz.utc.localize(utc_datetime)
+
+    # Convert to the project's local timezone
+    local_datetime = utc_datetime.astimezone(local_tz)
+
+    return local_datetime

apiserver/plane/utils/user_timezone_converter.py

@@ -1,26 +0,0 @@
-import pytz
-
-
-def user_timezone_converter(queryset, datetime_fields, user_timezone):
-    # Create a timezone object for the user's timezone
-    user_tz = pytz.timezone(user_timezone)
-
-    # Check if queryset is a dictionary (single item) or a list of dictionaries
-    if isinstance(queryset, dict):
-        queryset_values = [queryset]
-    else:
-        queryset_values = list(queryset)
-
-    # Iterate over the dictionaries in the list
-    for item in queryset_values:
-        # Iterate over the datetime fields
-        for field in datetime_fields:
-            # Convert the datetime field to the user's timezone
-            if field in item and item[field]:
-                item[field] = item[field].astimezone(user_tz)
-
-    # If queryset was a single item, return a single item
-    if isinstance(queryset, dict):
-        return queryset_values[0]
-    else:
-        return queryset_values

apiserver/requirements/base.txt

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

app.json

@@ -70,7 +70,7 @@
       "value": ""
     },
     "GITHUB_CLIENT_SECRET": {
-      "description": "Github Client Secret",
+      "description": "GitHub Client Secret",
       "value": ""
     },
     "NEXT_PUBLIC_API_BASE_URL": {

deploy/selfhost/README.md

@@ -62,7 +62,7 @@ mkdir plane-selfhost
 
 cd plane-selfhost
 
-curl -fsSL -o setup.sh https://raw.githubusercontent.com/makeplane/plane/master/deploy/selfhost/install.sh
+curl -fsSL -o setup.sh https://github.com/makeplane/plane/releases/latest/download/setup.sh
 
 chmod +x setup.sh
 ```

deploy/selfhost/docker-compose.yml

@@ -1,54 +1,63 @@
-x-app-env: &app-env
-  environment:
-    - NGINX_PORT=${NGINX_PORT:-80}
-    - WEB_URL=${WEB_URL:-http://localhost}
-    - DEBUG=${DEBUG:-0}
-    - SENTRY_DSN=${SENTRY_DSN:-""}
-    - SENTRY_ENVIRONMENT=${SENTRY_ENVIRONMENT:-"production"}
-    - CORS_ALLOWED_ORIGINS=${CORS_ALLOWED_ORIGINS:-}
-    # Gunicorn Workers
-    - GUNICORN_WORKERS=${GUNICORN_WORKERS:-1}
-    #DB SETTINGS
-    - PGHOST=${PGHOST:-plane-db}
-    - PGDATABASE=${PGDATABASE:-plane}
-    - POSTGRES_USER=${POSTGRES_USER:-plane}
-    - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-plane}
-    - POSTGRES_DB=${POSTGRES_DB:-plane}
-    - POSTGRES_PORT=${POSTGRES_PORT:-5432}
-    - PGDATA=${PGDATA:-/var/lib/postgresql/data}
-    - DATABASE_URL=${DATABASE_URL:-postgresql://plane:plane@plane-db/plane}
-    # REDIS SETTINGS
-    - REDIS_HOST=${REDIS_HOST:-plane-redis}
-    - REDIS_PORT=${REDIS_PORT:-6379}
-    - REDIS_URL=${REDIS_URL:-redis://plane-redis:6379/}
+x-db-env: &db-env
+  PGHOST: ${PGHOST:-plane-db}
+  PGDATABASE: ${PGDATABASE:-plane}
+  POSTGRES_USER: ${POSTGRES_USER:-plane}
+  POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-plane}
+  POSTGRES_DB: ${POSTGRES_DB:-plane}
+  POSTGRES_PORT: ${POSTGRES_PORT:-5432}
+  PGDATA: ${PGDATA:-/var/lib/postgresql/data}
+
+x-redis-env: &redis-env
+  REDIS_HOST: ${REDIS_HOST:-plane-redis}
+  REDIS_PORT: ${REDIS_PORT:-6379}
+  REDIS_URL: ${REDIS_URL:-redis://plane-redis:6379/}
+
+x-minio-env: &minio-env
+  MINIO_ROOT_USER: ${AWS_ACCESS_KEY_ID:-access-key}
+  MINIO_ROOT_PASSWORD: ${AWS_SECRET_ACCESS_KEY:-secret-key}
+  
+x-aws-s3-env: &aws-s3-env
+  AWS_REGION: ${AWS_REGION:-}
+  AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID:-access-key}
+  AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY:-secret-key}
+  AWS_S3_ENDPOINT_URL: ${AWS_S3_ENDPOINT_URL:-http://plane-minio:9000}
+  AWS_S3_BUCKET_NAME: ${AWS_S3_BUCKET_NAME:-uploads}
+
+x-proxy-env: &proxy-env
+  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}
+  RABBITMQ_PORT: ${RABBITMQ_PORT:-5672}
+  RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER:-plane}
+  RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASSWORD:-plane}
+  RABBITMQ_DEFAULT_VHOST: ${RABBITMQ_VHOST:-plane}
+  RABBITMQ_VHOST: ${RABBITMQ_VHOST:-plane}
+
+x-live-env: &live-env
+  API_BASE_URL: ${API_BASE_URL:-http://api:8000}
+
+x-app-env: &app-env
+  WEB_URL: ${WEB_URL:-http://localhost}
+  DEBUG: ${DEBUG:-0}
+  SENTRY_DSN: ${SENTRY_DSN}
+  SENTRY_ENVIRONMENT: ${SENTRY_ENVIRONMENT:-production}
+  CORS_ALLOWED_ORIGINS: ${CORS_ALLOWED_ORIGINS}
+  GUNICORN_WORKERS: 1
+  USE_MINIO: ${USE_MINIO:-1}
+  DATABASE_URL: ${DATABASE_URL:-postgresql://plane:plane@plane-db/plane}
+  SECRET_KEY: ${SECRET_KEY:-60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5}
+  ADMIN_BASE_URL: ${ADMIN_BASE_URL}
+  SPACE_BASE_URL: ${SPACE_BASE_URL}
+  APP_BASE_URL: ${APP_BASE_URL}
+  AMQP_URL: ${AMQP_URL:-amqp://plane:plane@plane-mq:5672/plane}
 
-    # RabbitMQ Settings
-    - RABBITMQ_HOST=${RABBITMQ_HOST:-plane-mq}
-    - RABBITMQ_PORT=${RABBITMQ_PORT:-5672}
-    - RABBITMQ_DEFAULT_USER=${RABBITMQ_USER:-plane}
-    - RABBITMQ_DEFAULT_PASS=${RABBITMQ_PASSWORD:-plane}
-    - RABBITMQ_DEFAULT_VHOST=${RABBITMQ_VHOST:-plane}
-    - RABBITMQ_VHOST=${RABBITMQ_VHOST:-plane}
-    - AMQP_URL=${AMQP_URL:-amqp://plane:plane@plane-mq:5672/plane}
-    # Application secret
-    - SECRET_KEY=${SECRET_KEY:-60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5}
-    # DATA STORE SETTINGS
-    - USE_MINIO=${USE_MINIO:-1}
-    - AWS_REGION=${AWS_REGION:-}
-    - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-"access-key"}
-    - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-"secret-key"}
-    - AWS_S3_ENDPOINT_URL=${AWS_S3_ENDPOINT_URL:-http://plane-minio:9000}
-    - AWS_S3_BUCKET_NAME=${AWS_S3_BUCKET_NAME:-uploads}
-    - MINIO_ROOT_USER=${MINIO_ROOT_USER:-"access-key"}
-    - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD:-"secret-key"}
-    - BUCKET_NAME=${BUCKET_NAME:-uploads}
-    - FILE_SIZE_LIMIT=${FILE_SIZE_LIMIT:-5242880}
-    # Live server env
-    - API_BASE_URL=${API_BASE_URL:-http://api:8000}
 
 services:
   web:
-    <<: *app-env
     image: ${DOCKERHUB_USER:-makeplane}/plane-frontend:${APP_RELEASE:-stable}
     platform: ${DOCKER_PLATFORM:-}
     pull_policy: if_not_present
@@ -61,7 +70,6 @@ services:
       - worker
 
   space:
-    <<: *app-env
     image: ${DOCKERHUB_USER:-makeplane}/plane-space:${APP_RELEASE:-stable}
     platform: ${DOCKER_PLATFORM:-}
     pull_policy: if_not_present
@@ -75,7 +83,6 @@ services:
       - web
 
   admin:
-    <<: *app-env
     image: ${DOCKERHUB_USER:-makeplane}/plane-admin:${APP_RELEASE:-stable}
     platform: ${DOCKER_PLATFORM:-}
     pull_policy: if_not_present
@@ -88,12 +95,13 @@ services:
       - web
 
   live:
-    <<: *app-env
     image: ${DOCKERHUB_USER:-makeplane}/plane-live:${APP_RELEASE:-stable}
     platform: ${DOCKER_PLATFORM:-}
     pull_policy: if_not_present
     restart: unless-stopped
     command: node live/dist/server.js live
+    environment:
+      <<: [ *live-env ]
     deploy:
       replicas: ${LIVE_REPLICAS:-1}
     depends_on:
@@ -101,7 +109,6 @@ services:
       - web
 
   api:
-    <<: *app-env
     image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
     platform: ${DOCKER_PLATFORM:-}
     pull_policy: if_not_present
@@ -111,14 +118,14 @@ services:
       replicas: ${API_REPLICAS:-1}
     volumes:
       - logs_api:/code/plane/logs
+    environment:
+      <<: [ *app-env, *db-env, *redis-env, *minio-env, *aws-s3-env, *proxy-env ]
     depends_on:
       - plane-db
       - plane-redis
       - plane-mq
 
-
   worker:
-    <<: *app-env
     image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
     platform: ${DOCKER_PLATFORM:-}
     pull_policy: if_not_present
@@ -126,6 +133,8 @@ services:
     command: ./bin/docker-entrypoint-worker.sh
     volumes:
       - logs_worker:/code/plane/logs
+    environment:
+      <<: [ *app-env, *db-env, *redis-env, *minio-env, *aws-s3-env, *proxy-env ]
     depends_on:
       - api
       - plane-db
@@ -133,7 +142,6 @@ services:
       - plane-mq
 
   beat-worker:
-    <<: *app-env
     image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
     platform: ${DOCKER_PLATFORM:-}
     pull_policy: if_not_present
@@ -141,6 +149,8 @@ services:
     command: ./bin/docker-entrypoint-beat.sh
     volumes:
       - logs_beat-worker:/code/plane/logs
+    environment:
+      <<: [ *app-env, *db-env, *redis-env, *minio-env, *aws-s3-env, *proxy-env ]
     depends_on:
       - api
       - plane-db
@@ -148,7 +158,6 @@ services:
       - plane-mq
 
   migrator:
-    <<: *app-env
     image: ${DOCKERHUB_USER:-makeplane}/plane-backend:${APP_RELEASE:-stable}
     platform: ${DOCKER_PLATFORM:-}
     pull_policy: if_not_present
@@ -156,21 +165,23 @@ services:
     command: ./bin/docker-entrypoint-migrator.sh
     volumes:
       - logs_migrator:/code/plane/logs
+    environment:
+      <<: [ *app-env, *db-env, *redis-env, *minio-env, *aws-s3-env, *proxy-env ]
     depends_on:
       - plane-db
       - plane-redis
 
   plane-db:
-    <<: *app-env
     image: postgres:15.7-alpine
     pull_policy: if_not_present
     restart: unless-stopped
     command: postgres -c 'max_connections=1000'
+    environment:
+      <<: *db-env
     volumes:
       - pgdata:/var/lib/postgresql/data
 
   plane-redis:
-    <<: *app-env
     image: valkey/valkey:7.2.5-alpine
     pull_policy: if_not_present
     restart: unless-stopped
@@ -178,30 +189,33 @@ services:
       - redisdata:/data
 
   plane-mq:
-    <<: *app-env
     image: rabbitmq:3.13.6-management-alpine
     restart: always
+    environment:
+      <<: *mq-env
     volumes:
       - rabbitmq_data:/var/lib/rabbitmq
 
   plane-minio:
-    <<: *app-env
     image: minio/minio:latest
     pull_policy: if_not_present
     restart: unless-stopped
     command: server /export --console-address ":9090"
+    environment:
+      <<: *minio-env
     volumes:
       - uploads:/export
 
   # Comment this if you already have a reverse proxy running
   proxy:
-    <<: *app-env
     image: ${DOCKERHUB_USER:-makeplane}/plane-proxy:${APP_RELEASE:-stable}
     platform: ${DOCKER_PLATFORM:-}
     pull_policy: if_not_present
     restart: unless-stopped
     ports:
       - ${NGINX_PORT}:80
+    environment:
+      <<: *proxy-env
     depends_on:
       - web
       - api

deploy/selfhost/install.sh

@@ -4,9 +4,12 @@ BRANCH=${BRANCH:-master}
 SCRIPT_DIR=$PWD
 SERVICE_FOLDER=plane-app
 PLANE_INSTALL_DIR=$PWD/$SERVICE_FOLDER
-export APP_RELEASE="stable"
+export APP_RELEASE=stable
 export DOCKERHUB_USER=makeplane
 export PULL_POLICY=${PULL_POLICY:-if_not_present}
+export GH_REPO=makeplane/plane
+export RELEASE_DOWNLOAD_URL="https://github.com/$GH_REPO/releases/download"
+export FALLBACK_DOWNLOAD_URL="https://raw.githubusercontent.com/$GH_REPO/$BRANCH/deploy/selfhost"
 
 CPU_ARCH=$(uname -m)
 OS_NAME=$(uname)
@@ -16,13 +19,6 @@ mkdir -p $PLANE_INSTALL_DIR/archive
 DOCKER_FILE_PATH=$PLANE_INSTALL_DIR/docker-compose.yaml
 DOCKER_ENV_PATH=$PLANE_INSTALL_DIR/plane.env
 
-SED_PREFIX=()
-if [ "$OS_NAME" == "Darwin" ]; then
-  SED_PREFIX=("-i" "")
-else
-  SED_PREFIX=("-i")
-fi
-
 function print_header() {
 clear
 
@@ -59,6 +55,17 @@ function spinner() {
     printf "    \b\b\b\b" >&2
 }
 
+function checkLatestRelease(){
+    echo "Checking for the latest release..." >&2
+    local latest_release=$(curl -s https://api.github.com/repos/$GH_REPO/releases/latest |  grep -o '"tag_name": "[^"]*"' | sed 's/"tag_name": "//;s/"//g')
+    if [ -z "$latest_release" ]; then
+        echo "Failed to check for the latest release. Exiting..." >&2
+        exit 1
+    fi
+
+    echo $latest_release    
+}
+
 function initialize(){
     printf "Please wait while we check the availability of Docker images for the selected release ($APP_RELEASE) with ${UPPER_CPU_ARCH} support." >&2
 
@@ -130,8 +137,12 @@ function updateEnvFile() {
             echo "$key=$value" >> "$file"
             return
         else 
-            # if key exists, update the value
-            sed "${SED_PREFIX[@]}" "s/^$key=.*/$key=$value/g" "$file"
+            if [ "$OS_NAME" == "Darwin" ]; then
+                value=$(echo "$value" | sed 's/|/\\|/g')
+                sed -i '' "s|^$key=.*|$key=$value|g" "$file"
+            else
+                sed -i "s/^$key=.*/$key=$value/g" "$file"
+            fi
         fi
     else
         echo "File not found: $file"
@@ -182,7 +193,7 @@ function buildYourOwnImage(){
     local PLANE_TEMP_CODE_DIR=~/tmp/plane
     rm -rf $PLANE_TEMP_CODE_DIR
     mkdir -p $PLANE_TEMP_CODE_DIR
-    REPO=https://github.com/makeplane/plane.git
+    REPO=https://github.com/$GH_REPO.git
     git clone "$REPO" "$PLANE_TEMP_CODE_DIR"  --branch "$BRANCH" --single-branch --depth 1
 
     cp "$PLANE_TEMP_CODE_DIR/deploy/selfhost/build.yml" "$PLANE_TEMP_CODE_DIR/build.yml"
@@ -204,6 +215,10 @@ function install() {
     echo "Begin Installing Plane"
     echo ""
 
+    if [ "$APP_RELEASE" == "stable" ]; then
+        export APP_RELEASE=$(checkLatestRelease)
+    fi
+
     local build_image=$(initialize)
 
     if [ "$build_image" == "build" ]; then
@@ -232,8 +247,49 @@ function download() {
         mv $PLANE_INSTALL_DIR/docker-compose.yaml $PLANE_INSTALL_DIR/archive/$TS.docker-compose.yaml
     fi
 
-    curl -H 'Cache-Control: no-cache, no-store' -s -o $PLANE_INSTALL_DIR/docker-compose.yaml  https://raw.githubusercontent.com/makeplane/plane/$BRANCH/deploy/selfhost/docker-compose.yml?$(date +%s)
-    curl -H 'Cache-Control: no-cache, no-store' -s -o $PLANE_INSTALL_DIR/variables-upgrade.env https://raw.githubusercontent.com/makeplane/plane/$BRANCH/deploy/selfhost/variables.env?$(date +%s)
+    RESPONSE=$(curl -H 'Cache-Control: no-cache, no-store' -s -w "HTTPSTATUS:%{http_code}" "$RELEASE_DOWNLOAD_URL/$APP_RELEASE/docker-compose.yml?$(date +%s)")
+    BODY=$(echo "$RESPONSE" | sed -e 's/HTTPSTATUS\:.*//g')
+    STATUS=$(echo "$RESPONSE" | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
+
+    if [ "$STATUS" -eq 200 ]; then
+        echo "$BODY" > $PLANE_INSTALL_DIR/docker-compose.yaml
+    else
+        # Fallback to download from the raw github url
+        RESPONSE=$(curl -H 'Cache-Control: no-cache, no-store' -s -w "HTTPSTATUS:%{http_code}" "$FALLBACK_DOWNLOAD_URL/docker-compose.yml?$(date +%s)")
+        BODY=$(echo "$RESPONSE" | sed -e 's/HTTPSTATUS\:.*//g')
+        STATUS=$(echo "$RESPONSE" | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
+
+        if [ "$STATUS" -eq 200 ]; then
+            echo "$BODY" > $PLANE_INSTALL_DIR/docker-compose.yaml
+        else
+            echo "Failed to download docker-compose.yml. HTTP Status: $STATUS"
+            echo "URL: $RELEASE_DOWNLOAD_URL/$APP_RELEASE/docker-compose.yml"
+            mv $PLANE_INSTALL_DIR/archive/$TS.docker-compose.yaml $PLANE_INSTALL_DIR/docker-compose.yaml
+            exit 1
+        fi
+    fi
+
+    RESPONSE=$(curl -H 'Cache-Control: no-cache, no-store' -s -w "HTTPSTATUS:%{http_code}" "$RELEASE_DOWNLOAD_URL/$APP_RELEASE/variables.env?$(date +%s)")
+    BODY=$(echo "$RESPONSE" | sed -e 's/HTTPSTATUS\:.*//g')
+    STATUS=$(echo "$RESPONSE" | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
+
+    if [ "$STATUS" -eq 200 ]; then
+        echo "$BODY" > $PLANE_INSTALL_DIR/variables-upgrade.env
+    else
+        # Fallback to download from the raw github url
+        RESPONSE=$(curl -H 'Cache-Control: no-cache, no-store' -s -w "HTTPSTATUS:%{http_code}" "$FALLBACK_DOWNLOAD_URL/variables.env?$(date +%s)")
+        BODY=$(echo "$RESPONSE" | sed -e 's/HTTPSTATUS\:.*//g')
+        STATUS=$(echo "$RESPONSE" | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
+
+        if [ "$STATUS" -eq 200 ]; then
+            echo "$BODY" > $PLANE_INSTALL_DIR/variables-upgrade.env
+        else
+            echo "Failed to download variables.env. HTTP Status: $STATUS"
+            echo "URL: $RELEASE_DOWNLOAD_URL/$APP_RELEASE/variables.env"
+            mv $PLANE_INSTALL_DIR/archive/$TS.docker-compose.yaml $PLANE_INSTALL_DIR/docker-compose.yaml
+            exit 1
+        fi
+    fi
 
     if [ -f "$DOCKER_ENV_PATH" ];
     then
@@ -335,6 +391,34 @@ function restartServices() {
     startServices
 }
 function upgrade() {
+    local latest_release=$(checkLatestRelease)
+
+    echo ""
+    echo "Current release: $APP_RELEASE"
+
+    if [ "$latest_release" == "$APP_RELEASE" ]; then
+        echo ""
+        echo "You are already using the latest release"
+        exit 0
+    fi
+
+    echo "Latest release: $latest_release"
+    echo ""
+
+    # Check for confirmation to upgrade
+    echo "Do you want to upgrade to the latest release ($latest_release)?"
+    read -p "Continue? [y/N]: " confirm
+
+    if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
+        echo "Exiting..."
+        exit 0
+    fi
+
+    export APP_RELEASE=$latest_release
+
+    echo "Upgrading Plane to the latest release..."
+    echo ""
+
     echo "***** STOPPING SERVICES ****"
     stopServices
 

deploy/selfhost/variables.env

@@ -47,9 +47,6 @@ AWS_ACCESS_KEY_ID=access-key
 AWS_SECRET_ACCESS_KEY=secret-key
 AWS_S3_ENDPOINT_URL=http://plane-minio:9000
 AWS_S3_BUCKET_NAME=uploads
-MINIO_ROOT_USER=access-key
-MINIO_ROOT_PASSWORD=secret-key
-BUCKET_NAME=uploads
 FILE_SIZE_LIMIT=5242880
 
 # Gunicorn Workers

live/package.json

@@ -1,16 +1,16 @@
 {
   "name": "live",
-  "version": "0.23.1",
+  "version": "0.24.1",
   "description": "",
   "main": "./src/server.ts",
   "private": true,
   "type": "module",
   "scripts": {
+    "dev": "concurrently \"babel src --out-dir dist --extensions '.ts,.js' --watch\" \"nodemon dist/server.js\"",
     "build": "babel src --out-dir dist --extensions \".ts,.js\"",
     "start": "node dist/server.js",
-    "lint": "eslint . --ext .ts,.tsx",
-    "dev": "concurrently \"babel src --out-dir dist --extensions '.ts,.js' --watch\" \"nodemon dist/server.js\"",
-    "lint:errors": "eslint . --ext .ts,.tsx --quiet"
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:errors": "eslint src --ext .ts,.tsx --quiet"
   },
   "keywords": [],
   "author": "",
@@ -30,7 +30,7 @@
     "compression": "^1.7.4",
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
-    "express": "^4.20.0",
+    "express": "^4.21.2",
     "express-ws": "^5.0.2",
     "helmet": "^7.1.0",
     "ioredis": "^5.4.1",

live/src/core/hocuspocus-server.ts

@@ -4,6 +4,10 @@ import { v4 as uuidv4 } from "uuid";
 import { handleAuthentication } from "@/core/lib/authentication.js";
 // extensions
 import { getExtensions } from "@/core/extensions/index.js";
+import {
+  DocumentCollaborativeEvents,
+  TDocumentEventsServer,
+} from "@plane/editor/lib";
 // editor types
 import { TUserDetails } from "@plane/editor";
 // types
@@ -55,6 +59,14 @@ export const getHocusPocusServer = async () => {
         throw Error("Authentication unsuccessful!");
       }
     },
+    async onStateless({ payload, document }) {
+      // broadcast the client event (derived from the server event) to all the clients so that they can update their state
+      const response =
+        DocumentCollaborativeEvents[payload as TDocumentEventsServer].client;
+      if (response) {
+        document.broadcastStateless(response);
+      }
+    },
     extensions,
     debounce: 10000,
   });

package.json

@@ -1,6 +1,6 @@
 {
   "repository": "https://github.com/makeplane/plane.git",
-  "version": "0.23.1",
+  "version": "0.24.1",
   "license": "AGPL-3.0",
   "private": true,
   "workspaces": [
@@ -22,7 +22,7 @@
   "devDependencies": {
     "prettier": "latest",
     "prettier-plugin-tailwindcss": "^0.5.4",
-    "turbo": "^2.3.0"
+    "turbo": "^2.3.3"
   },
   "packageManager": "yarn@1.22.22",
   "name": "plane"

packages/constants/index.ts

@@ -1,2 +0,0 @@
-export * from "./auth";
-export * from "./issue";