chore: intake form version history

* fix: proxy dockerfile fixes

* fix changes

.env.example

@@ -26,9 +26,10 @@ AWS_S3_BUCKET_NAME="uploads"
 FILE_SIZE_LIMIT=5242880
 
 # GPT settings
+SILO_BASE_URL=
 OPENAI_API_BASE="https://api.openai.com/v1" # deprecated
 OPENAI_API_KEY="sk-" # deprecated
-GPT_ENGINE="gpt-3.5-turbo" # deprecated
+GPT_ENGINE="gpt-4o-mini" # deprecated
 
 # Settings related to Docker
 DOCKERIZED=1  # deprecated
@@ -38,3 +39,15 @@ USE_MINIO=1
 
 # Nginx Configuration
 NGINX_PORT=80
+
+# Force HTTPS for handling SSL Termination
+MINIO_ENDPOINT_SSL=0
+
+# API key rate limit
+API_KEY_RATE_LIMIT="60/minute"
+
+# Imports Config
+SILO_BASE_URL=
+MONGO_DB_URL="mongodb://plane-mongodb:27017/"
+SILO_DB=silo
+SILO_DB_URL=postgresql://plane:plane@plane-db/silo

.github/actions/build-push-cloud/action.yml

@@ -0,0 +1,127 @@
+name: "Build and Push Docker Image"
+description: "Reusable action for building and pushing Docker images"
+inputs:
+  docker-username:
+    description: "The Dockerhub username"
+    required: true
+  dockerhub-token:
+    description: "The Dockerhub Token"
+    required: true
+
+  # Docker Image Options
+  docker-image-owner:
+    description: "The owner of the Docker image"
+    required: true
+  docker-image-name:
+    description: "The name of the Docker image"
+    required: true
+  build-context:
+    description: "The build context"
+    required: true
+    default: "."
+  dockerfile-path:
+    description: "The path to the Dockerfile"
+    required: true
+  build-args:
+    description: "The build arguments"
+    required: false
+    default: ""
+
+  # Buildx Options
+  buildx-driver:
+    description: "Buildx driver"
+    required: true
+    default: "docker-container"
+  buildx-version:
+    description: "Buildx version"
+    required: true
+    default: "latest"
+  buildx-platforms:
+    description: "Buildx platforms"
+    required: true
+    default: "linux/amd64"
+  buildx-endpoint:
+    description: "Buildx endpoint"
+    required: true
+    default: "default"
+
+  # Release Build Options
+  build-release:
+    description: "Flag to publish release"
+    required: false
+    default: "false"
+  build-prerelease:
+    description: "Flag to publish prerelease"
+    required: false
+    default: "false"
+  release-version:
+    description: "The release version"
+    required: false
+    default: "latest"
+
+runs:
+  using: "composite"
+  steps:
+  - name: Set Docker Tag
+    shell: bash
+    env:
+      IMG_OWNER: ${{ inputs.docker-image-owner }}
+      IMG_NAME: ${{ inputs.docker-image-name }}
+      BUILD_RELEASE: ${{ inputs.build-release }}
+      IS_PRERELEASE: ${{ inputs.build-prerelease }}
+      REL_VERSION: ${{ inputs.release-version }}
+    run: |
+      FLAT_BRANCH_VERSION=$(echo "${{ github.ref_name }}" | sed 's/[^a-zA-Z0-9.-]//g')
+
+      if [ "${{ env.BUILD_RELEASE }}" == "true" ]; then
+        semver_regex="^v([0-9]+)\.([0-9]+)\.([0-9]+)(-[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*)?$"
+        if [[ ! ${{ env.REL_VERSION }} =~ $semver_regex ]]; then
+          echo "Invalid Release Version Format : ${{ env.REL_VERSION }}"
+          echo "Please provide a valid SemVer version"
+          echo "e.g. v1.2.3 or v1.2.3-alpha-1"
+          echo "Exiting the build process"
+          exit 1  # Exit with status 1 to fail the step
+        fi
+
+        TAG=${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:${{ env.REL_VERSION }}
+
+        if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
+          TAG=${TAG},${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:stable
+        fi
+      elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+        TAG=${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:latest
+      else
+        TAG=${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:${FLAT_BRANCH_VERSION}
+      fi
+
+      echo "DOCKER_TAGS=${TAG}" >> $GITHUB_ENV
+
+  - name: Login to Docker Hub
+    uses: docker/login-action@v3
+    with:
+      username: ${{ inputs.docker-username }}
+      password: ${{ inputs.dockerhub-token}}
+
+  - name: Set up Docker Buildx
+    uses: docker/setup-buildx-action@v3
+    with:
+      driver: ${{ inputs.buildx-driver }}
+      version: ${{ inputs.buildx-version }}
+      endpoint: ${{ inputs.buildx-endpoint }}
+
+  - name: Check out the repo
+    uses: actions/checkout@v4
+
+  - name: Build and Push Docker Image
+    uses: docker/build-push-action@v5.1.0
+    with:
+      context: ${{ inputs.build-context }}
+      file: ${{ inputs.dockerfile-path }}
+      platforms: ${{ inputs.buildx-platforms }}
+      tags: ${{ env.DOCKER_TAGS }}
+      push: true
+      build-args: ${{ inputs.build-args }}
+    env:
+      DOCKER_BUILDKIT: 1
+      DOCKER_USERNAME: ${{ inputs.docker-username }}
+      DOCKER_PASSWORD: ${{ inputs.dockerhub-token }}

.github/actions/build-push-ee/action.yml

@@ -0,0 +1,168 @@
+name: "Build and Push Docker Image"
+description: "Reusable action for building and pushing Docker images"
+inputs:
+  docker-username:
+    description: "The Dockerhub username"
+    required: true
+  dockerhub-token:
+    description: "The Dockerhub Token"
+    required: true
+
+  # Harbor Options
+  harbor-push:
+    description: "Flag to push to Harbor"
+    required: false
+    default: "false"
+  harbor-username:
+    description: "The Harbor username"
+    required: false
+  harbor-token:
+    description: "The Harbor token"
+    required: false
+  harbor-registry:
+    description: "The Harbor registry"
+    required: false
+    default: "registry.plane.tools"
+  harbor-project:
+    description: "The Harbor project"
+    required: false
+
+  # Docker Image Options
+  docker-image-owner:
+    description: "The owner of the Docker image"
+    required: true
+  docker-image-name:
+    description: "The name of the Docker image"
+    required: true
+  build-context:
+    description: "The build context"
+    required: true
+    default: "."
+  dockerfile-path:
+    description: "The path to the Dockerfile"
+    required: true
+  build-args:
+    description: "The build arguments"
+    required: false
+    default: ""
+  
+  # Buildx Options
+  buildx-driver:
+    description: "Buildx driver"
+    required: true
+    default: "docker-container"
+  buildx-version:
+    description: "Buildx version"
+    required: true
+    default: "latest"
+  buildx-platforms:
+    description: "Buildx platforms"
+    required: true
+    default: "linux/amd64"
+  buildx-endpoint:
+    description: "Buildx endpoint"
+    required: true
+    default: "default"
+
+  # Release Build Options
+  build-release:
+    description: "Flag to publish release"
+    required: false
+    default: "false"
+  build-prerelease:
+    description: "Flag to publish prerelease"
+    required: false
+    default: "false"
+  release-version:
+    description: "The release version"
+    required: false
+    default: "latest"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Set Docker Tag
+      shell: bash
+      env:
+        IMG_OWNER: ${{ inputs.docker-image-owner }}
+        IMG_NAME: ${{ inputs.docker-image-name }}
+        HARBOR_PUSH: ${{ inputs.harbor-push }}
+        HARBOR_REGISTRY: ${{ inputs.harbor-registry }}
+        HARBOR_PROJECT: ${{ inputs.harbor-project }}
+        BUILD_RELEASE: ${{ inputs.build-release }}
+        IS_PRERELEASE: ${{ inputs.build-prerelease }}
+        REL_VERSION: ${{ inputs.release-version }}
+      run: |
+        FLAT_BRANCH_VERSION=$(echo "${{ github.ref_name }}" | sed 's/[^a-zA-Z0-9.-]//g')
+
+        if [ "${{ env.BUILD_RELEASE }}" == "true" ]; then
+          semver_regex="^v([0-9]+)\.([0-9]+)\.([0-9]+)(-[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*)?$"
+          if [[ ! ${{ env.REL_VERSION }} =~ $semver_regex ]]; then
+            echo "Invalid Release Version Format : ${{ env.REL_VERSION }}"
+            echo "Please provide a valid SemVer version"
+            echo "e.g. v1.2.3 or v1.2.3-alpha-1"
+            echo "Exiting the build process"
+            exit 1  # Exit with status 1 to fail the step
+          fi
+
+          TAG=${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:${{ env.REL_VERSION }}
+
+          if [ "${{ env.HARBOR_PUSH }}" == "true" ]; then
+            TAG=${TAG},${{ env.HARBOR_REGISTRY }}/${{ env.HARBOR_PROJECT }}/${{ env.IMG_NAME }}:${{ env.REL_VERSION }}
+          fi
+
+          if [ "${{ env.IS_PRERELEASE }}" != "true" ]; then
+            TAG=${TAG},${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:stable
+            if [ "${{ env.HARBOR_PUSH }}" == "true" ]; then
+              TAG=${TAG},${{ env.HARBOR_REGISTRY }}/${{ env.HARBOR_PROJECT }}/${{ env.IMG_NAME }}:stable
+            fi
+          fi
+        elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+          TAG=${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:latest
+          if [ "${{ env.HARBOR_PUSH }}" == "true" ]; then
+            TAG=${TAG},${{ env.HARBOR_REGISTRY }}/${{ env.HARBOR_PROJECT }}/${{ env.IMG_NAME }}:latest
+          fi
+        else
+          TAG=${{ env.IMG_OWNER }}/${{ env.IMG_NAME }}:${FLAT_BRANCH_VERSION}
+          if [ "${{ env.HARBOR_PUSH }}" == "true" ]; then
+            TAG=${TAG},${{ env.HARBOR_REGISTRY }}/${{ env.HARBOR_PROJECT }}/${{ env.IMG_NAME }}:${FLAT_BRANCH_VERSION}
+          fi
+        fi
+        
+        echo "DOCKER_TAGS=${TAG}" >> $GITHUB_ENV
+    - name: Login to Docker Hub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ inputs.docker-username }}
+        password: ${{ inputs.dockerhub-token}}
+    - name: Login to Harbor
+      if: ${{ inputs.harbor-push }} == "true"
+      uses: docker/login-action@v3
+      with:
+        username: ${{ inputs.harbor-username }}
+        password: ${{ inputs.harbor-token }}
+        registry: ${{ inputs.harbor-registry }}
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      with:
+        driver: ${{ inputs.buildx-driver }}
+        version: ${{ inputs.buildx-version }}
+        endpoint: ${{ inputs.buildx-endpoint }}
+
+    - name: Check out the repo
+      uses: actions/checkout@v4
+
+    - name: Build and Push Docker Image
+      uses: docker/build-push-action@v5.1.0
+      with:
+        context: ${{ inputs.build-context }}
+        file: ${{ inputs.dockerfile-path }}
+        platforms: ${{ inputs.buildx-platforms }}
+        tags: ${{ env.DOCKER_TAGS }}
+        push: true
+        build-args: ${{ inputs.build-args }}
+      env:
+        DOCKER_BUILDKIT: 1
+        DOCKER_USERNAME: ${{ inputs.docker-username }}
+        DOCKER_PASSWORD: ${{ inputs.dockerhub-token }}

.github/workflows/build-aio-branch-ee.yml

@@ -0,0 +1,204 @@
+name: Branch Build AIO
+
+on:
+  workflow_dispatch:
+    inputs:
+      full:
+        description: 'Run full build'
+        type: boolean
+        required: false
+        default: true
+      slim:
+        description: 'Run slim build'
+        type: boolean
+        required: false
+        default: true
+      base_tag_name:
+        description: 'Base Tag Name'
+        required: false
+        default: ''
+  release:
+    types: [released, prereleased]
+
+env:
+  TARGET_BRANCH: ${{ github.ref_name || github.event.release.target_commitish }}
+  IS_PRERELEASE: ${{ github.event.release.prerelease }}
+  FULL_BUILD_INPUT: ${{ github.event.inputs.full }}
+  SLIM_BUILD_INPUT: ${{ github.event.inputs.slim }}
+
+jobs:
+  branch_build_setup:
+    name: Build Setup
+    runs-on: ubuntu-latest
+    outputs:
+      gh_branch_name: ${{ steps.set_env_variables.outputs.TARGET_BRANCH }}
+      gh_buildx_driver: ${{ steps.set_env_variables.outputs.BUILDX_DRIVER }}
+      gh_buildx_version: ${{ steps.set_env_variables.outputs.BUILDX_VERSION }}
+      gh_buildx_platforms: ${{ steps.set_env_variables.outputs.BUILDX_PLATFORMS }}
+      gh_buildx_endpoint: ${{ steps.set_env_variables.outputs.BUILDX_ENDPOINT }}
+      aio_base_tag: ${{ steps.set_env_variables.outputs.AIO_BASE_TAG }}
+      do_full_build: ${{ steps.set_env_variables.outputs.DO_FULL_BUILD }}
+      do_slim_build: ${{ steps.set_env_variables.outputs.DO_SLIM_BUILD }}
+
+    steps:
+      - id: set_env_variables
+        name: Set Environment Variables
+        run: |
+          if [ [ "${{ github.event_name }}" == "release" ] && [ "${{ env.IS_PRERELEASE }}" != "true" ] ; then
+            echo "BUILDX_DRIVER=cloud" >> $GITHUB_OUTPUT
+            echo "BUILDX_VERSION=lab:latest" >> $GITHUB_OUTPUT
+            echo "BUILDX_PLATFORMS=linux/amd64,linux/arm64" >> $GITHUB_OUTPUT
+            echo "BUILDX_ENDPOINT=makeplane/plane-dev" >> $GITHUB_OUTPUT
+
+            echo "AIO_BASE_TAG=latest" >> $GITHUB_OUTPUT
+          else
+            echo "BUILDX_DRIVER=docker-container" >> $GITHUB_OUTPUT
+            echo "BUILDX_VERSION=latest" >> $GITHUB_OUTPUT
+            echo "BUILDX_PLATFORMS=linux/amd64" >> $GITHUB_OUTPUT
+            echo "BUILDX_ENDPOINT=" >> $GITHUB_OUTPUT
+
+            if [ "${{ github.event.inputs.base_tag_name }}" != "" ]; then
+              echo "AIO_BASE_TAG=${{ github.event.inputs.base_tag_name }}" >> $GITHUB_OUTPUT
+            elif [ "${{ env.TARGET_BRANCH }}" == "preview" ]; then
+              echo "AIO_BASE_TAG=preview" >> $GITHUB_OUTPUT
+            else
+              echo "AIO_BASE_TAG=develop" >> $GITHUB_OUTPUT
+            fi
+          fi
+          echo "TARGET_BRANCH=${{ env.TARGET_BRANCH }}" >> $GITHUB_OUTPUT
+
+          if [ "${{ env.FULL_BUILD_INPUT }}" == "true" ] || [ "${{github.event_name}}" == "push" ] || [ "${{github.event_name}}" == "release" ]; then
+            echo "DO_FULL_BUILD=true" >> $GITHUB_OUTPUT
+          else
+            echo "DO_FULL_BUILD=false" >> $GITHUB_OUTPUT
+          fi
+
+          if [ "${{ env.SLIM_BUILD_INPUT }}" == "true" ] || [ "${{github.event_name}}" == "push" ] || [ "${{github.event_name}}" == "release" ]; then
+            echo "DO_SLIM_BUILD=true" >> $GITHUB_OUTPUT
+          else
+            echo "DO_SLIM_BUILD=false" >> $GITHUB_OUTPUT
+          fi
+
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+
+  full_build_push:
+    if: ${{ needs.branch_build_setup.outputs.do_full_build == 'true' }}
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    env:
+      BUILD_TYPE: full
+      AIO_BASE_TAG: ${{ needs.branch_build_setup.outputs.aio_base_tag }}
+      AIO_IMAGE_TAGS: makeplane/plane-aio-enterprise:full-${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+    steps:
+      - name: Set Docker Tag
+        run: |
+          if [ "${{ github.event_name }}" == "release" ]; then
+            TAG=makeplane/plane-aio-enterprise:${{env.BUILD_TYPE}}-stable,makeplane/plane-aio-enterprise:${{env.BUILD_TYPE}}-${{ github.event.release.tag_name }}
+          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+            TAG=makeplane/plane-aio-enterprise:${{env.BUILD_TYPE}}-latest
+          else
+            TAG=${{ env.AIO_IMAGE_TAGS }}
+          fi
+          echo "AIO_IMAGE_TAGS=${TAG}" >> $GITHUB_ENV
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
+      - name: Check out the repo
+        uses: actions/checkout@v4
+
+      - name: Build and Push to Docker Hub
+        uses: docker/build-push-action@v5.1.0
+        with:
+          context: .
+          file: ./aio/Dockerfile-app
+          platforms: ${{ env.BUILDX_PLATFORMS }}
+          tags: ${{ env.AIO_IMAGE_TAGS }}
+          push: true
+          build-args: |
+            BUILD_TAG=${{ env.AIO_BASE_TAG }}
+            BUILD_TYPE=${{env.BUILD_TYPE}}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+  slim_build_push:
+    if: ${{ needs.branch_build_setup.outputs.do_slim_build == 'true' }}
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    env:
+      BUILD_TYPE: slim
+      AIO_BASE_TAG: ${{ needs.branch_build_setup.outputs.aio_base_tag }}
+      AIO_IMAGE_TAGS: makeplane/plane-aio-enterprise:slim-${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      TARGET_BRANCH: ${{ needs.branch_build_setup.outputs.gh_branch_name }}
+      BUILDX_DRIVER: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+      BUILDX_VERSION: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+      BUILDX_PLATFORMS: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+      BUILDX_ENDPOINT: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+    steps:
+      - name: Set Docker Tag
+        run: |
+          if [ "${{ github.event_name }}" == "release" ]; then
+            TAG=makeplane/plane-aio-enterprise:${{env.BUILD_TYPE}}-stable,makeplane/plane-aio-enterprise:${{env.BUILD_TYPE}}-${{ github.event.release.tag_name }}
+          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+            TAG=makeplane/plane-aio-enterprise:${{env.BUILD_TYPE}}-latest
+          else
+            TAG=${{ env.AIO_IMAGE_TAGS }}
+          fi
+          echo "AIO_IMAGE_TAGS=${TAG}" >> $GITHUB_ENV
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: ${{ env.BUILDX_DRIVER }}
+          version: ${{ env.BUILDX_VERSION }}
+          endpoint: ${{ env.BUILDX_ENDPOINT }}
+
+      - name: Check out the repo
+        uses: actions/checkout@v4
+
+      - name: Build and Push to Docker Hub
+        uses: docker/build-push-action@v5.1.0
+        with:
+          context: .
+          file: ./aio/Dockerfile-app
+          platforms: ${{ env.BUILDX_PLATFORMS }}
+          tags: ${{ env.AIO_IMAGE_TAGS }}
+          push: true
+          build-args: |
+            BUILD_TAG=${{ env.AIO_BASE_TAG }}
+            BUILD_TYPE=${{env.BUILD_TYPE}}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+        env:
+          DOCKER_BUILDKIT: 1
+          DOCKER_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+          DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}

.github/workflows/build-branch-cloud.yml

@@ -0,0 +1,370 @@
+name: Branch Build Cloud
+
+on:
+  workflow_dispatch:
+    inputs:
+      build_type:
+        description: "Type of build to run"
+        required: true
+        type: choice
+        default: "Build"
+        options:
+          - "Build"
+          - "Release"
+      releaseVersion:
+        description: "Release Version"
+        type: string
+        default: v0.0.0-cloud
+      useVaultSecrets:
+        description: "Use Vault Secrets"
+        type: boolean
+        default: false
+        required: true
+      isPrerelease:
+        description: "Is Pre-release"
+        type: boolean
+        default: false
+        required: true
+
+env:
+  TARGET_BRANCH: ${{ github.ref_name }}
+  VAULT_KP_PREFIX: plane-ee-cloud-builds
+  BUILD_TYPE: ${{ github.event.inputs.build_type }}
+  RELEASE_VERSION: ${{ github.event.inputs.releaseVersion }}
+  IS_PRERELEASE: ${{ github.event.inputs.isPrerelease }}
+
+jobs:
+  branch_build_setup:
+    name: Build Setup
+    runs-on: ubuntu-22.04
+    outputs:
+      gh_branch_name: ${{ steps.set_env_variables.outputs.TARGET_BRANCH }}
+      gh_buildx_driver: ${{ steps.set_env_variables.outputs.BUILDX_DRIVER }}
+      gh_buildx_version: ${{ steps.set_env_variables.outputs.BUILDX_VERSION }}
+      gh_buildx_platforms: ${{ steps.set_env_variables.outputs.BUILDX_PLATFORMS }}
+      gh_buildx_endpoint: ${{ steps.set_env_variables.outputs.BUILDX_ENDPOINT }}
+
+      dh_img_web: ${{ steps.set_env_variables.outputs.DH_IMG_WEB }}
+      dh_img_space: ${{ steps.set_env_variables.outputs.DH_IMG_SPACE }}
+      dh_img_admin: ${{ steps.set_env_variables.outputs.DH_IMG_ADMIN }}
+      dh_img_live: ${{ steps.set_env_variables.outputs.DH_IMG_LIVE }}
+      dh_img_silo: ${{ steps.set_env_variables.outputs.DH_IMG_SILO }}
+      dh_img_backend: ${{ steps.set_env_variables.outputs.DH_IMG_BACKEND }}
+      dh_img_email: ${{ steps.set_env_variables.outputs.DH_IMG_EMAIL }}
+      harbor_push: ${{ steps.set_env_variables.outputs.HARBOR_PUSH }}
+
+      build_type: ${{steps.set_env_variables.outputs.BUILD_TYPE}}
+      build_release: ${{ steps.set_env_variables.outputs.BUILD_RELEASE }}
+      build_prerelease: ${{ steps.set_env_variables.outputs.BUILD_PRERELEASE }}
+      release_version: ${{ steps.set_env_variables.outputs.RELEASE_VERSION }}
+      vault_secrets: ${{ steps.get_vault_secrets.outputs.VAULT_SECRETS }}
+      build_args: ${{ steps.prepare_build_args.outputs.BUILD_ARGS }}
+    steps:
+      - id: set_env_variables
+        name: Set Environment Variables
+        run: |
+          echo "BUILDX_DRIVER=docker-container" >> $GITHUB_OUTPUT
+          echo "BUILDX_VERSION=latest" >> $GITHUB_OUTPUT
+          echo "BUILDX_PLATFORMS=linux/amd64" >> $GITHUB_OUTPUT
+          echo "BUILDX_ENDPOINT=" >> $GITHUB_OUTPUT
+
+          BR_NAME=$( echo "${{ env.TARGET_BRANCH }}" | sed 's/[^a-zA-Z0-9.-]//g')
+          echo "TARGET_BRANCH=$BR_NAME" >> $GITHUB_OUTPUT
+
+          echo "DH_IMG_WEB=web-cloud" >> $GITHUB_OUTPUT
+          echo "DH_IMG_SPACE=space-cloud" >> $GITHUB_OUTPUT
+          echo "DH_IMG_ADMIN=admin-cloud" >> $GITHUB_OUTPUT
+          echo "DH_IMG_LIVE=live-cloud" >> $GITHUB_OUTPUT
+          echo "DH_IMG_SILO=silo-cloud" >> $GITHUB_OUTPUT
+          echo "DH_IMG_BACKEND=backend-cloud" >> $GITHUB_OUTPUT
+          echo "DH_IMG_EMAIL=email-cloud" >> $GITHUB_OUTPUT
+
+          echo "BUILD_TYPE=${{env.BUILD_TYPE}}" >> $GITHUB_OUTPUT
+          BUILD_RELEASE=false
+          BUILD_PRERELEASE=false
+          RELVERSION="latest"
+
+          if [ "${{ env.BUILD_TYPE }}" == "Release" ]; then
+            FLAT_RELEASE_VERSION=$(echo "${{ env.RELEASE_VERSION }}" | sed 's/[^a-zA-Z0-9.-]//g')
+            echo "FLAT_RELEASE_VERSION=${FLAT_RELEASE_VERSION}" >> $GITHUB_OUTPUT
+
+            semver_regex="^v([0-9]+)\.([0-9]+)\.([0-9]+)(-[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*)?$"
+            if [[ ! $FLAT_RELEASE_VERSION =~ $semver_regex ]]; then
+              echo "Invalid Release Version Format : $FLAT_RELEASE_VERSION"
+              echo "Please provide a valid SemVer version"
+              echo "e.g. v1.2.3 or v1.2.3-alpha-1"
+              echo "Exiting the build process"
+              exit 1  # Exit with status 1 to fail the step
+            fi
+            BUILD_RELEASE=true
+            RELVERSION=$FLAT_RELEASE_VERSION
+
+            if [ "${{ env.IS_PRERELEASE }}" == "true" ]; then
+              BUILD_PRERELEASE=true
+            fi
+          fi
+          echo "BUILD_RELEASE=${BUILD_RELEASE}" >> $GITHUB_OUTPUT
+          echo "BUILD_PRERELEASE=${BUILD_PRERELEASE}" >> $GITHUB_OUTPUT
+          echo "RELEASE_VERSION=${RELVERSION}" >> $GITHUB_OUTPUT
+
+      - name: Tailscale
+        uses: tailscale/github-action@v2
+        if: ${{github.event.inputs.useVaultSecrets == 'true'}}
+        with:
+          oauth-client-id: ${{ secrets.TAILSCALE_OAUTH_CLIENT_ID }}
+          oauth-secret: ${{ secrets.TAILSCALE_OAUTH_CLIENT_SECRET }}
+          tags: tag:ci
+
+      - name: Get the ENV values from Vault
+        id: get_vault_secrets
+        if: ${{github.event.inputs.useVaultSecrets == 'true'}}
+        run: |
+          if [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+            ENV_NAME="prod"
+          else
+            ENV_NAME="stage"
+          fi
+
+          curl -fsSL \
+            --header "X-Vault-Token: ${{ secrets.VAULT_TOKEN }}" \
+            --request GET \
+            ${{ vars.VAULT_HOST }}/v1/kv/git-builds/data/${{ env.VAULT_KP_PREFIX }}-${ENV_NAME} | jq .data.data > vault_secrets.json
+
+          if [ $? != 0 ]; then
+            echo "Failed to get the ENV values from Vault"
+            exit 1
+          fi
+
+          VAULT_SECRETS=$(cat vault_secrets.json | base64 -w 0)
+          echo "VAULT_SECRETS=${VAULT_SECRETS}" >> $GITHUB_OUTPUT
+
+      - name: Prepare Docker Build Args
+        id: prepare_build_args
+        if: ${{github.event.inputs.useVaultSecrets == 'true'}}
+        run: |
+          BUILD_ARGS=""
+          add_build_arg() {
+            if [ -n "$2" ]; then
+              BUILD_ARGS="$BUILD_ARGS $1=$2"
+            fi
+          }
+          add_build_arg "NEXT_PUBLIC_API_BASE_URL" "${{ env.NEXT_PUBLIC_API_BASE_URL }}"
+          add_build_arg "NEXT_PUBLIC_API_BASE_PATH" "${{ env.NEXT_PUBLIC_API_BASE_PATH }}"
+
+          add_build_arg "NEXT_PUBLIC_ADMIN_BASE_URL" "${{ env.NEXT_PUBLIC_ADMIN_BASE_URL }}"
+          add_build_arg "NEXT_PUBLIC_ADMIN_BASE_PATH" "${{ env.NEXT_PUBLIC_ADMIN_BASE_PATH }}"
+
+          add_build_arg "NEXT_PUBLIC_SPACE_BASE_URL" "${{ env.NEXT_PUBLIC_SPACE_BASE_URL }}"
+          add_build_arg "NEXT_PUBLIC_SPACE_BASE_PATH" "${{ env.NEXT_PUBLIC_SPACE_BASE_PATH }}"
+
+          add_build_arg "NEXT_PUBLIC_LIVE_BASE_URL" "${{ env.NEXT_PUBLIC_LIVE_BASE_URL }}"
+          add_build_arg "NEXT_PUBLIC_LIVE_BASE_PATH" "${{ env.NEXT_PUBLIC_LIVE_BASE_PATH }}"
+
+          add_build_arg "NEXT_PUBLIC_SILO_BASE_URL" "${{ env.NEXT_PUBLIC_SILO_BASE_URL }}"
+          add_build_arg "NEXT_PUBLIC_SILO_BASE_PATH" "${{ env.NEXT_PUBLIC_SILO_BASE_PATH }}"
+
+          add_build_arg "NEXT_PUBLIC_WEB_BASE_URL" "${{ env.NEXT_PUBLIC_WEB_BASE_URL }}"
+
+          add_build_arg "SENTRY_AUTH_TOKEN" "${{ secrets.SENTRY_AUTH_TOKEN }}"
+
+          echo "BUILD_ARGS=$BUILD_ARGS" >> $GITHUB_OUTPUT
+
+  branch_build_push_admin:
+    name: Build-Push Admin Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Admin Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_admin }}
+          build-context: .
+          dockerfile-path: ./admin/Dockerfile.admin
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+          build-args: ${{ needs.branch_build_setup.outputs.build_args }}
+
+  branch_build_push_web:
+    name: Build-Push Web Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Load Vault Secrets
+        run: |
+          echo ${{ needs.branch_build_setup.outputs.vault_secrets }} | base64 -d > vault_secrets.json
+          jq -r 'to_entries|map("\(.key)=\(.value|tostring)")|.[]' vault_secrets.json >> $GITHUB_ENV
+
+      - name: Web Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_web }}
+          build-context: .
+          dockerfile-path: ./web/Dockerfile.web
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+          build-args: ${{ needs.branch_build_setup.outputs.build_args }}
+
+  branch_build_push_space:
+    name: Build-Push Space Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Load Vault Secrets
+        run: |
+          echo ${{ needs.branch_build_setup.outputs.vault_secrets }} | base64 -d > vault_secrets.json
+          jq -r 'to_entries|map("\(.key)=\(.value|tostring)")|.[]' vault_secrets.json >> $GITHUB_ENV
+
+      - name: Space Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_space }}
+          build-context: .
+          dockerfile-path: ./space/Dockerfile.space
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+          build-args: ${{ needs.branch_build_setup.outputs.build_args }}
+
+  branch_build_push_live:
+    name: Build-Push Live Collaboration Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Live Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_live }}
+          build-context: .
+          dockerfile-path: ./live/Dockerfile.live
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_silo:
+    name: Build-Push Silo Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Silo Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_silo }}
+          build-context: .
+          dockerfile-path: ./silo/Dockerfile.silo
+
+  branch_build_push_apiserver:
+    name: Build-Push API Server Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Backend Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_backend }}
+          build-context: ./apiserver
+          dockerfile-path: ./apiserver/Dockerfile.api
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_email:
+    name: Build-Push Email Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+
+      - name: Email Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_email }}
+          build-context: ./email
+          dockerfile-path: ./email/Dockerfile
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  publish_release:
+    if: ${{ needs.branch_build_setup.outputs.build_type == 'Release' }}
+    name: Build Release
+    runs-on: ubuntu-22.04
+    needs:
+      [
+        branch_build_setup,
+        branch_build_push_admin,
+        branch_build_push_web,
+        branch_build_push_space,
+        branch_build_push_live,
+        branch_build_push_silo,
+        branch_build_push_apiserver,
+        branch_build_push_email,
+      ]
+    env:
+      REL_VERSION: ${{ needs.branch_build_setup.outputs.release_version }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Create Release
+        id: create_release
+        uses: softprops/action-gh-release@v2.0.8
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+        with:
+          tag_name: ${{ env.REL_VERSION }}
+          name: ${{ env.REL_VERSION }}
+          draft: false
+          prerelease: ${{ env.IS_PRERELEASE }}
+          generate_release_notes: true

.github/workflows/build-branch-ee.yml

@@ -0,0 +1,498 @@
+name: Branch Build Enterprise
+
+on:
+  workflow_dispatch:
+    inputs:
+      build_type:
+        description: "Type of build to run"
+        required: true
+        type: choice
+        default: "Build"
+        options:
+          - "Build"
+          - "Release"
+      releaseVersion:
+        description: "Release Version"
+        type: string
+        default: v0.0.0
+      isPrerelease:
+        description: "Is Pre-release"
+        type: boolean
+        default: false
+        required: true
+      arm64:
+        description: "Build for ARM64 architecture"
+        required: false
+        default: false
+        type: boolean
+
+env:
+  TARGET_BRANCH: ${{ github.ref_name }}
+  ARM64_BUILD: ${{ github.event.inputs.arm64 }}
+  BUILD_TYPE: ${{ github.event.inputs.build_type }}
+  RELEASE_VERSION: ${{ github.event.inputs.releaseVersion }}
+  IS_PRERELEASE: ${{ github.event.inputs.isPrerelease }}
+
+jobs:
+  branch_build_setup:
+    name: Build Setup
+    runs-on: ubuntu-22.04
+    outputs:
+      gh_branch_name: ${{ steps.set_env_variables.outputs.TARGET_BRANCH }}
+      gh_buildx_driver: ${{ steps.set_env_variables.outputs.BUILDX_DRIVER }}
+      gh_buildx_version: ${{ steps.set_env_variables.outputs.BUILDX_VERSION }}
+      gh_buildx_platforms: ${{ steps.set_env_variables.outputs.BUILDX_PLATFORMS }}
+      gh_buildx_endpoint: ${{ steps.set_env_variables.outputs.BUILDX_ENDPOINT }}
+
+      artifact_upload_to_s3: ${{ steps.set_env_variables.outputs.artifact_upload_to_s3 }}
+      artifact_s3_suffix: ${{ steps.set_env_variables.outputs.artifact_s3_suffix }}
+
+      dh_img_web: ${{ steps.set_env_variables.outputs.DH_IMG_WEB }}
+      dh_img_space: ${{ steps.set_env_variables.outputs.DH_IMG_SPACE }}
+      dh_img_admin: ${{ steps.set_env_variables.outputs.DH_IMG_ADMIN }}
+      dh_img_live: ${{ steps.set_env_variables.outputs.DH_IMG_LIVE }}
+      dh_img_backend: ${{ steps.set_env_variables.outputs.DH_IMG_BACKEND }}
+      dh_img_proxy: ${{ steps.set_env_variables.outputs.DH_IMG_PROXY }}
+      dh_img_monitor: ${{ steps.set_env_variables.outputs.DH_IMG_MONITOR }}
+      dh_img_silo: ${{ steps.set_env_variables.outputs.DH_IMG_SILO }}
+      dh_img_email: ${{ steps.set_env_variables.outputs.DH_IMG_EMAIL }}
+
+      harbor_push: ${{ steps.set_env_variables.outputs.HARBOR_PUSH }}
+
+      build_type: ${{steps.set_env_variables.outputs.BUILD_TYPE}}
+      build_release: ${{ steps.set_env_variables.outputs.BUILD_RELEASE }}
+      build_prerelease: ${{ steps.set_env_variables.outputs.BUILD_PRERELEASE }}
+      release_version: ${{ steps.set_env_variables.outputs.RELEASE_VERSION }}
+
+    steps:
+      - id: set_env_variables
+        name: Set Environment Variables
+        run: |
+          if [ "${{ env.ARM64_BUILD }}" == "true" ] || ([ "${{ env.BUILD_TYPE }}" == "Release" ] && [ "${{ env.IS_PRERELEASE }}" != "true" ]); then
+            echo "BUILDX_DRIVER=cloud" >> $GITHUB_OUTPUT
+            echo "BUILDX_VERSION=lab:latest" >> $GITHUB_OUTPUT
+            echo "BUILDX_PLATFORMS=linux/amd64,linux/arm64" >> $GITHUB_OUTPUT
+            echo "BUILDX_ENDPOINT=makeplane/plane-dev" >> $GITHUB_OUTPUT
+          else
+            echo "BUILDX_DRIVER=docker-container" >> $GITHUB_OUTPUT
+            echo "BUILDX_VERSION=latest" >> $GITHUB_OUTPUT
+            echo "BUILDX_PLATFORMS=linux/amd64" >> $GITHUB_OUTPUT
+            echo "BUILDX_ENDPOINT=" >> $GITHUB_OUTPUT
+          fi
+          BR_NAME=$( echo "${{ env.TARGET_BRANCH }}" |sed 's/[^a-zA-Z0-9.-]//g')
+          echo "TARGET_BRANCH=$BR_NAME" >> $GITHUB_OUTPUT
+
+          echo "DH_IMG_WEB=web-commercial" >> $GITHUB_OUTPUT
+          echo "DH_IMG_SPACE=space-commercial" >> $GITHUB_OUTPUT
+          echo "DH_IMG_ADMIN=admin-commercial" >> $GITHUB_OUTPUT
+          echo "DH_IMG_LIVE=live-commercial" >> $GITHUB_OUTPUT
+          echo "DH_IMG_BACKEND=backend-commercial" >> $GITHUB_OUTPUT
+          echo "DH_IMG_PROXY=proxy-commercial" >> $GITHUB_OUTPUT
+          echo "DH_IMG_MONITOR=monitor-commercial" >> $GITHUB_OUTPUT
+          echo "DH_IMG_SILO=silo-commercial" >> $GITHUB_OUTPUT
+          echo "DH_IMG_EMAIL=email-commercial" >> $GITHUB_OUTPUT
+
+          echo "BUILD_TYPE=${{env.BUILD_TYPE}}" >> $GITHUB_OUTPUT
+          BUILD_RELEASE=false
+          BUILD_PRERELEASE=false
+          RELVERSION="latest"
+          HARBOR_PUSH=false
+
+          if [ "${{ env.BUILD_TYPE }}" == "Release" ]; then
+            FLAT_RELEASE_VERSION=$(echo "${{ env.RELEASE_VERSION }}" | sed 's/[^a-zA-Z0-9.-]//g')
+            echo "FLAT_RELEASE_VERSION=${FLAT_RELEASE_VERSION}" >> $GITHUB_OUTPUT
+            # HARBOR_PUSH=true
+
+            semver_regex="^v([0-9]+)\.([0-9]+)\.([0-9]+)(-[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*)?$"
+            if [[ ! $FLAT_RELEASE_VERSION =~ $semver_regex ]]; then
+              echo "Invalid Release Version Format : $FLAT_RELEASE_VERSION"
+              echo "Please provide a valid SemVer version"
+              echo "e.g. v1.2.3 or v1.2.3-alpha-1"
+              echo "Exiting the build process"
+              exit 1  # Exit with status 1 to fail the step
+            fi
+            BUILD_RELEASE=true
+            RELVERSION=$FLAT_RELEASE_VERSION
+
+            if [ "${{ env.IS_PRERELEASE }}" == "true" ]; then
+              BUILD_PRERELEASE=true
+            fi
+          fi
+          echo "BUILD_RELEASE=${BUILD_RELEASE}" >> $GITHUB_OUTPUT
+          echo "BUILD_PRERELEASE=${BUILD_PRERELEASE}" >> $GITHUB_OUTPUT
+          echo "RELEASE_VERSION=${RELVERSION}" >> $GITHUB_OUTPUT
+          echo "HARBOR_PUSH=${HARBOR_PUSH}" >> $GITHUB_OUTPUT
+
+          if [ "${{ env.BUILD_TYPE }}" == "Release" ]; then
+            echo "artifact_upload_to_s3=true" >> $GITHUB_OUTPUT
+            echo "artifact_s3_suffix=${{ env.RELEASE_VERSION }}" >> $GITHUB_OUTPUT
+          elif [ "${{ env.TARGET_BRANCH }}" == "master" ]; then
+            echo "artifact_upload_to_s3=true" >> $GITHUB_OUTPUT
+            echo "artifact_s3_suffix=latest" >> $GITHUB_OUTPUT
+          elif [ "${{ env.TARGET_BRANCH }}" == "preview" ] || [ "${{ env.TARGET_BRANCH }}" == "develop" ] || [ "${{ env.TARGET_BRANCH }}" == "uat" ]; then
+            echo "artifact_upload_to_s3=true" >> $GITHUB_OUTPUT
+            echo "artifact_s3_suffix=${{ env.TARGET_BRANCH }}" >> $GITHUB_OUTPUT
+          else
+            echo "artifact_upload_to_s3=false" >> $GITHUB_OUTPUT
+            echo "artifact_s3_suffix=$BR_NAME" >> $GITHUB_OUTPUT
+          fi
+
+  branch_build_push_admin:
+    name: Build-Push Admin Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Admin Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          private-registry-push: ${{ needs.branch_build_setup.outputs.harbor_push }}
+          private-registry-username: ${{ secrets.HARBOR_USERNAME }}
+          private-registry-token: ${{ secrets.HARBOR_TOKEN }}
+          private-registry-addr: ${{ vars.HARBOR_REGISTRY }}
+          private-registry-project: ${{ vars.HARBOR_PROJECT }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_admin }}
+          build-context: .
+          dockerfile-path: ./admin/Dockerfile.admin
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_web:
+    name: Build-Push Web Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Web Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          private-registry-push: ${{ needs.branch_build_setup.outputs.harbor_push }}
+          private-registry-username: ${{ secrets.HARBOR_USERNAME }}
+          private-registry-token: ${{ secrets.HARBOR_TOKEN }}
+          private-registry-addr: ${{ vars.HARBOR_REGISTRY }}
+          private-registry-project: ${{ vars.HARBOR_PROJECT }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_web }}
+          build-context: .
+          dockerfile-path: ./web/Dockerfile.web
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_space:
+    name: Build-Push Space Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Space Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          private-registry-push: ${{ needs.branch_build_setup.outputs.harbor_push }}
+          private-registry-username: ${{ secrets.HARBOR_USERNAME }}
+          private-registry-token: ${{ secrets.HARBOR_TOKEN }}
+          private-registry-addr: ${{ vars.HARBOR_REGISTRY }}
+          private-registry-project: ${{ vars.HARBOR_PROJECT }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_space }}
+          build-context: .
+          dockerfile-path: ./space/Dockerfile.space
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_live:
+    name: Build-Push Live Collaboration Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Live Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          private-registry-push: ${{ needs.branch_build_setup.outputs.harbor_push }}
+          private-registry-username: ${{ secrets.HARBOR_USERNAME }}
+          private-registry-token: ${{ secrets.HARBOR_TOKEN }}
+          private-registry-addr: ${{ vars.HARBOR_REGISTRY }}
+          private-registry-project: ${{ vars.HARBOR_PROJECT }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_live }}
+          build-context: .
+          dockerfile-path: ./live/Dockerfile.live
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_silo:
+    name: Build-Push Silo Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Silo Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          private-registry-push: ${{ needs.branch_build_setup.outputs.harbor_push }}
+          private-registry-username: ${{ secrets.HARBOR_USERNAME }}
+          private-registry-token: ${{ secrets.HARBOR_TOKEN }}
+          private-registry-addr: ${{ vars.HARBOR_REGISTRY }}
+          private-registry-project: ${{ vars.HARBOR_PROJECT }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_silo }}
+          build-context: .
+          dockerfile-path: ./silo/Dockerfile.silo
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_apiserver:
+    name: Build-Push API Server Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Backend Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          private-registry-push: ${{ needs.branch_build_setup.outputs.harbor_push }}
+          private-registry-username: ${{ secrets.HARBOR_USERNAME }}
+          private-registry-token: ${{ secrets.HARBOR_TOKEN }}
+          private-registry-addr: ${{ vars.HARBOR_REGISTRY }}
+          private-registry-project: ${{ vars.HARBOR_PROJECT }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_backend }}
+          build-context: ./apiserver
+          dockerfile-path: ./apiserver/Dockerfile.api
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_proxy:
+    name: Build-Push Proxy Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Proxy Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          private-registry-push: ${{ needs.branch_build_setup.outputs.harbor_push }}
+          private-registry-username: ${{ secrets.HARBOR_USERNAME }}
+          private-registry-token: ${{ secrets.HARBOR_TOKEN }}
+          private-registry-addr: ${{ vars.HARBOR_REGISTRY }}
+          private-registry-project: ${{ vars.HARBOR_PROJECT }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_proxy }}
+          build-context: ./proxy
+          dockerfile-path: ./proxy/Dockerfile.ee
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+  branch_build_push_monitor:
+    name: Build-Push Monitor Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - name: Generate Keypair
+        run: |
+          if [ "${{ env.TARGET_BRANCH }}" == "master" ] || [ "${{ env.BUILD_TYPE }}" == "Release" ]; then
+            openssl genrsa -out private_key.pem 2048
+          else
+            echo "${{ secrets.DEFAULT_PRIME_PRIVATE_KEY }}" > private_key.pem
+          fi
+          openssl rsa -in private_key.pem -pubout -out public_key.pem
+          cat public_key.pem
+
+          # Generating the private key env for the generated keys
+          PRIVATE_KEY=$(cat private_key.pem | base64 -w 0)
+          echo "PRIVATE_KEY=${PRIVATE_KEY}" >> $GITHUB_ENV
+
+      - name: Monitor Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          private-registry-push: ${{ needs.branch_build_setup.outputs.harbor_push }}
+          private-registry-username: ${{ secrets.HARBOR_USERNAME }}
+          private-registry-token: ${{ secrets.HARBOR_TOKEN }}
+          private-registry-addr: ${{ vars.HARBOR_REGISTRY }}
+          private-registry-project: ${{ vars.HARBOR_PROJECT }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_monitor }}
+          build-context: ./monitor
+          dockerfile-path: ./monitor/Dockerfile
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+          build-args: |
+            PRIVATE_KEY=${{ env.PRIVATE_KEY }}
+
+  branch_build_push_email:
+    name: Build-Push Email Docker Image
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    steps:
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+
+      - name: Email Build and Push
+        uses: makeplane/actions/build-push@v1.0.0
+        with:
+          build-release: ${{ needs.branch_build_setup.outputs.build_release }}
+          build-prerelease: ${{ needs.branch_build_setup.outputs.build_prerelease }}
+          release-version: ${{ needs.branch_build_setup.outputs.release_version }}
+          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          private-registry-push: ${{ needs.branch_build_setup.outputs.harbor_push }}
+          private-registry-username: ${{ secrets.HARBOR_USERNAME }}
+          private-registry-token: ${{ secrets.HARBOR_TOKEN }}
+          private-registry-addr: ${{ vars.HARBOR_REGISTRY }}
+          private-registry-project: ${{ vars.HARBOR_PROJECT }}
+          docker-image-owner: makeplane
+          docker-image-name: ${{ needs.branch_build_setup.outputs.dh_img_email }}
+          build-context: ./email
+          dockerfile-path: ./email/Dockerfile
+          buildx-driver: ${{ needs.branch_build_setup.outputs.gh_buildx_driver }}
+          buildx-version: ${{ needs.branch_build_setup.outputs.gh_buildx_version }}
+          buildx-platforms: ${{ needs.branch_build_setup.outputs.gh_buildx_platforms }}
+          buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
+
+
+  upload_artifacts_s3:
+    if: ${{ needs.branch_build_setup.outputs.artifact_upload_to_s3 == 'true' }}
+    name: Upload artifacts to S3 Bucket
+    runs-on: ubuntu-22.04
+    needs: [branch_build_setup]
+    container:
+      image: docker:20.10.7
+      credentials:
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_TOKEN }}
+    env:
+      ARTIFACT_SUFFIX: ${{ needs.branch_build_setup.outputs.artifact_s3_suffix }}
+      AWS_ACCESS_KEY_ID: ${{ secrets.SELF_HOST_BUCKET_ACCESS_KEY }}
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.SELF_HOST_BUCKET_SECRET_KEY }}
+    steps:
+      - id: checkout_files
+        name: Checkout Files
+        uses: actions/checkout@v4
+
+      - name: Upload artifacts
+        run: |
+          apk update
+          apk add --no-cache aws-cli
+
+          mkdir -p ~/${{ env.ARTIFACT_SUFFIX }}
+
+          sed -i 's@APP_RELEASE_VERSION=.*@APP_RELEASE_VERSION='${{ env.ARTIFACT_SUFFIX }}'@' deploy/cli-install/variables.env
+          cp deploy/cli-install/variables.env ~/${{ env.ARTIFACT_SUFFIX }}/variables.env
+
+          sed -i 's@${APP_RELEASE_VERSION.*@'${{ env.ARTIFACT_SUFFIX }}'@' deploy/cli-install/docker-compose-caddy.yml
+          cp deploy/cli-install/docker-compose-caddy.yml ~/${{ env.ARTIFACT_SUFFIX }}/docker-compose-caddy.yml
+
+          sed -i 's@${APP_RELEASE_VERSION.*@'${{ env.ARTIFACT_SUFFIX }}'@' deploy/cli-install/coolify-compose.yml
+          cp deploy/cli-install/coolify-compose.yml ~/${{ env.ARTIFACT_SUFFIX }}/coolify-compose.yml
+
+          sed -i 's@${APP_RELEASE_VERSION.*@'${{ env.ARTIFACT_SUFFIX }}'@' deploy/cli-install/portainer-compose.yml
+          cp deploy/cli-install/portainer-compose.yml ~/${{ env.ARTIFACT_SUFFIX }}/portainer-compose.yml
+
+          # required for prime-cli backward compatibility
+          cp proxy/Caddyfile.ee ~/${{ env.ARTIFACT_SUFFIX }}/Caddyfile
+          cp deploy/cli-install/docker-compose-caddy.yml ~/${{ env.ARTIFACT_SUFFIX }}/docker-compose.yml
+
+          aws s3 cp ~/${{ env.ARTIFACT_SUFFIX }} s3://${{ vars.SELF_HOST_BUCKET_NAME }}/plane-enterprise/${{ env.ARTIFACT_SUFFIX }} --recursive
+
+  publish_release:
+    if: ${{ needs.branch_build_setup.outputs.build_type == 'Release' }}
+    name: Build Release
+    runs-on: ubuntu-22.04
+    needs:
+      [
+        branch_build_setup,
+        branch_build_push_admin,
+        branch_build_push_web,
+        branch_build_push_space,
+        branch_build_push_live,
+        branch_build_push_apiserver,
+        branch_build_push_proxy,
+        branch_build_push_monitor,
+        branch_build_push_email,
+        branch_build_push_silo,
+        upload_artifacts_s3,
+      ]
+    env:
+      REL_VERSION: ${{ needs.branch_build_setup.outputs.release_version }}
+      ARTIFACT_SUFFIX: ${{ needs.branch_build_setup.outputs.artifact_s3_suffix }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Update docker-compose
+        run: |
+          sed -i 's@APP_RELEASE_VERSION=.*@APP_RELEASE_VERSION='${{ env.ARTIFACT_SUFFIX }}'@' deploy/cli-install/variables.env
+          sed -i 's@${APP_RELEASE_VERSION.*@'${{ env.ARTIFACT_SUFFIX }}'@' deploy/cli-install/docker-compose-caddy.yml
+          sed -i 's@${APP_RELEASE_VERSION.*@'${{ env.ARTIFACT_SUFFIX }}'@' deploy/cli-install/coolify-compose.yml
+          sed -i 's@${APP_RELEASE_VERSION.*@'${{ env.ARTIFACT_SUFFIX }}'@' deploy/cli-install/portainer-compose.yml
+          cp deploy/cli-install/docker-compose-caddy.yml deploy/cli-install/docker-compose.yml
+          cp deploy/cli-install/portainer-compose.yml deploy/cli-install/swarm-compose.yml
+
+      - name: Create Release
+        id: create_release
+        uses: softprops/action-gh-release@v2.0.8
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+        with:
+          tag_name: ${{ env.REL_VERSION }}
+          name: ${{ env.REL_VERSION }}
+          draft: false
+          prerelease: ${{ env.IS_PRERELEASE }}
+          generate_release_notes: true
+          files: |
+            ${{ github.workspace }}/deploy/cli-install/variables.env
+            ${{ github.workspace }}/deploy/cli-install/docker-compose.yml
+            ${{ github.workspace }}/deploy/cli-install/coolify-compose.yml
+            ${{ github.workspace }}/deploy/cli-install/portainer-compose.yml
+            ${{ github.workspace }}/deploy/cli-install/swarm-compose.yml

.github/workflows/build-branch.yml

@@ -47,12 +47,6 @@ jobs:
       gh_buildx_version: ${{ steps.set_env_variables.outputs.BUILDX_VERSION }}
       gh_buildx_platforms: ${{ steps.set_env_variables.outputs.BUILDX_PLATFORMS }}
       gh_buildx_endpoint: ${{ steps.set_env_variables.outputs.BUILDX_ENDPOINT }}
-      build_proxy: ${{ steps.changed_files.outputs.proxy_any_changed }}
-      build_apiserver: ${{ steps.changed_files.outputs.apiserver_any_changed }}
-      build_admin: ${{ steps.changed_files.outputs.admin_any_changed }}
-      build_space: ${{ steps.changed_files.outputs.space_any_changed }}
-      build_web: ${{ steps.changed_files.outputs.web_any_changed }}
-      build_live: ${{ steps.changed_files.outputs.live_any_changed }}
 
       dh_img_web: ${{ steps.set_env_variables.outputs.DH_IMG_WEB }}
       dh_img_space: ${{ steps.set_env_variables.outputs.DH_IMG_SPACE }}
@@ -123,46 +117,7 @@ jobs:
         name: Checkout Files
         uses: actions/checkout@v4
 
-      - name: Get changed files
-        id: changed_files
-        uses: tj-actions/changed-files@v42
-        with:
-          files_yaml: |
-            apiserver:
-              - apiserver/**
-            proxy:
-              - nginx/**
-            admin:
-              - admin/**
-              - packages/**
-              - "package.json"
-              - "yarn.lock"
-              - "tsconfig.json"
-              - "turbo.json"
-            space:
-              - space/**
-              - packages/**
-              - "package.json"
-              - "yarn.lock"
-              - "tsconfig.json"
-              - "turbo.json"
-            web:
-              - web/**
-              - packages/**
-              - "package.json"
-              - "yarn.lock"
-              - "tsconfig.json"
-              - "turbo.json"
-            live:
-              - live/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-
   branch_build_push_admin:
-    if: ${{ needs.branch_build_setup.outputs.build_admin == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push Admin Docker Image
     runs-on: ubuntu-22.04
     needs: [branch_build_setup]
@@ -185,7 +140,6 @@ jobs:
           buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
   branch_build_push_web:
-    if: ${{ needs.branch_build_setup.outputs.build_web == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push Web Docker Image
     runs-on: ubuntu-22.04
     needs: [branch_build_setup]
@@ -208,7 +162,6 @@ jobs:
           buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
   branch_build_push_space:
-    if: ${{ needs.branch_build_setup.outputs.build_space == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push Space Docker Image
     runs-on: ubuntu-22.04
     needs: [branch_build_setup]
@@ -231,7 +184,6 @@ jobs:
           buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
   branch_build_push_live:
-    if: ${{ needs.branch_build_setup.outputs.build_live == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push Live Collaboration Docker Image
     runs-on: ubuntu-22.04
     needs: [branch_build_setup]
@@ -254,7 +206,6 @@ jobs:
           buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
   branch_build_push_apiserver:
-    if: ${{ needs.branch_build_setup.outputs.build_apiserver == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push API Server Docker Image
     runs-on: ubuntu-22.04
     needs: [branch_build_setup]
@@ -277,7 +228,6 @@ jobs:
           buildx-endpoint: ${{ needs.branch_build_setup.outputs.gh_buildx_endpoint }}
 
   branch_build_push_proxy:
-    if: ${{ needs.branch_build_setup.outputs.build_proxy == 'true' || github.event_name == 'workflow_dispatch' || needs.branch_build_setup.outputs.gh_branch_name == 'master' }}
     name: Build-Push Proxy Docker Image
     runs-on: ubuntu-22.04
     needs: [branch_build_setup]

.github/workflows/build-test-pull-request.yml

@@ -6,49 +6,9 @@ on:
     types: ["opened", "synchronize", "ready_for_review"]
 
 jobs:
-  get-changed-files:
+  lint-apiserver:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
-    outputs:
-      apiserver_changed: ${{ steps.changed-files.outputs.apiserver_any_changed }}
-      admin_changed: ${{ steps.changed-files.outputs.admin_any_changed }}
-      space_changed: ${{ steps.changed-files.outputs.space_any_changed }}
-      web_changed: ${{ steps.changed-files.outputs.web_any_changed }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Get changed files
-        id: changed-files
-        uses: tj-actions/changed-files@v44
-        with:
-          files_yaml: |
-            apiserver:
-              - apiserver/**
-            admin:
-              - admin/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-            space:
-              - space/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-            web:
-              - web/**
-              - packages/**
-              - 'package.json'
-              - 'yarn.lock'
-              - 'tsconfig.json'
-              - 'turbo.json'
-
-  lint-apiserver:
-    needs: get-changed-files
-    runs-on: ubuntu-latest
-    if: needs.get-changed-files.outputs.apiserver_changed == 'true'
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python
@@ -63,8 +23,7 @@ jobs:
         run: ruff check --fix apiserver
 
   lint-admin:
-    needs: get-changed-files
-    if: needs.get-changed-files.outputs.admin_changed == 'true'
+    if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -76,8 +35,7 @@ jobs:
       - run: yarn lint --filter=admin
 
   lint-space:
-    needs: get-changed-files
-    if: needs.get-changed-files.outputs.space_changed == 'true'
+    if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -89,8 +47,7 @@ jobs:
       - run: yarn lint --filter=space
 
   lint-web:
-    needs: get-changed-files
-    if: needs.get-changed-files.outputs.web_changed == 'true'
+    if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/create-release.yml

@@ -0,0 +1,70 @@
+name: Manual Release Workflow
+
+on:
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        description: 'Release Tag (e.g., v0.16-cannary-1)'
+        required: true
+      prerelease:
+        description: 'Pre-Release'
+        required: true
+        default: true
+        type: boolean
+      draft:
+        description: 'Draft'
+        required: true
+        default: true
+        type: boolean
+
+permissions:
+  contents: write
+
+jobs:
+  create-release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0  # Necessary to fetch all history for tags
+
+      - name: Set up Git
+        run: |
+          git config user.name "github-actions"
+          git config user.email "github-actions@github.com"
+
+      - name: Check for the Prerelease
+        run: |
+            echo ${{ github.event.release.prerelease }}
+
+      - name: Generate Release Notes
+        id: generate_notes
+        run: |
+          bash ./generate_release_notes.sh
+          # Directly use the content of RELEASE_NOTES.md for the release body
+          RELEASE_NOTES=$(cat RELEASE_NOTES.md)
+          echo "RELEASE_NOTES<<EOF" >> $GITHUB_ENV
+          echo "$RELEASE_NOTES" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+
+      - name: Create Tag
+        run: |
+          git tag ${{ github.event.inputs.release_tag }}
+          git push origin ${{ github.event.inputs.release_tag }}
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ github.event.inputs.release_tag }}
+          body_path: RELEASE_NOTES.md
+          draft: ${{ github.event.inputs.draft }}
+          prerelease: ${{ github.event.inputs.prerelease }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+
+
+
+
+

.github/workflows/sync-community.yml

@@ -0,0 +1,55 @@
+name: Sync from Community Repo
+
+on:
+  #   schedule:
+  #     - cron: "*/30 * * * *" # Runs every 30 minutes
+  workflow_dispatch:
+    inputs:
+      source_branch:
+        description: "Source branch in Community repo"
+        required: true
+        default: "preview"
+      target_branch:
+        description: "Target branch in Enterprise repo"
+        required: true
+        default: "preview"
+
+jobs:
+  sync-from-community-repo:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout enterprise repository
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Set branch names
+        run: |
+          echo "SOURCE_BRANCH=${{ github.event.inputs.source_branch || 'preview' }}" >> $GITHUB_ENV
+          echo "TARGET_BRANCH=${{ github.event.inputs.target_branch || 'preview' }}" >> $GITHUB_ENV
+          echo "SYNC_BRANCH=sync-${{ github.run_id }}" >> $GITHUB_ENV
+
+      - name: Create sync branch
+        run: git checkout -b ${{ env.SYNC_BRANCH }}
+
+      - name: Fetch from community repository
+        run: |
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+          git remote add community https://github.com/makeplane/plane.git
+          git reset --hard community/${{ env.SOURCE_BRANCH }}
+
+      - name: Create Pull Request
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          PR_TITLE="Sync changes from community repo"
+          EXISTING_PR=$(gh pr list --base ${{ env.TARGET_BRANCH }} --head ${{ env.SYNC_BRANCH }} --json number --jq '.[0].number')
+          if [ -z "$EXISTING_PR" ]; then
+            pr_url=$(gh pr create --base ${{ env.TARGET_BRANCH }} --head ${{ env.SYNC_BRANCH }} --title "$PR_TITLE" --body "This PR syncs changes from the community repository's ${{ env.SOURCE_BRANCH }} branch.")
+            echo "New Pull Request created: $pr_url"
+          else
+            echo "Pull Request already exists with number: $EXISTING_PR"
+            gh pr edit $EXISTING_PR --title "$PR_TITLE" --body "This PR syncs changes from the community repository's ${{ env.SOURCE_BRANCH }} branch. (Updated)"
+            echo "Existing Pull Request updated"
+          fi

.github/workflows/sync-repo-pr.yml

@@ -41,12 +41,16 @@ jobs:
 
       - name: Create PR to Target Branch
         run: |
+          # Determine target branch based on current branch prefix
+          TARGET_BRANCH="preview"
+          PR_TITLE="${{vars.SYNC_PR_TITLE}}"
+
           # get all pull requests and check if there is already a PR
           PR_EXISTS=$(gh pr list --base $TARGET_BRANCH --head $CURRENT_BRANCH --state open --json number | jq '.[] | .number')
           if [ -n "$PR_EXISTS" ]; then
             echo "Pull Request already exists: $PR_EXISTS"
           else
             echo "Creating new pull request"
-            PR_URL=$(gh pr create --base $TARGET_BRANCH --head $CURRENT_BRANCH --title "${{ vars.SYNC_PR_TITLE }}" --body "")
+            PR_URL=$(gh pr create --base $TARGET_BRANCH --head $CURRENT_BRANCH --title "$PR_TITLE" --body "")
             echo "Pull Request created: $PR_URL"
           fi

.github/workflows/sync-repo.yml

@@ -36,8 +36,8 @@ jobs:
           GH_TOKEN: ${{ secrets.ACCESS_TOKEN }}
         run: |
           TARGET_REPO="${{ vars.SYNC_TARGET_REPO }}"
-          TARGET_BRANCH="${{ vars.SYNC_TARGET_BRANCH_NAME }}"
           SOURCE_BRANCH="${{ env.SOURCE_BRANCH_NAME }}"
+          TARGET_BRANCH="${{ vars.SYNC_TARGET_BRANCH_NAME }}"
 
           git checkout $SOURCE_BRANCH
           git remote add target-origin-a "https://$GH_TOKEN@github.com/$TARGET_REPO.git"

.gitignore

@@ -78,10 +78,23 @@ pnpm-workspace.yaml
 .npmrc
 .secrets
 tmp/
+
 ## packages
 dist
+.flatfile
 .temp/
 deploy/selfhost/plane-app/
+
 ## Storybook
 *storybook.log
 output.css
+
+dev-editor
+# Redis
+*.rdb
+*.rdb.gz
+
+# Monitor
+monitor/prime.key
+monitor/prime.key.pub
+monitor.db

ENV_SETUP.md

@@ -27,7 +27,7 @@ FILE_SIZE_LIMIT=5242880
 # GPT settings
 OPENAI_API_BASE="https://api.openai.com/v1" # deprecated
 OPENAI_API_KEY="sk-" # deprecated
-GPT_ENGINE="gpt-3.5-turbo" # deprecated
+GPT_ENGINE="gpt-4o-mini" # deprecated
 # Settings related to Docker
 DOCKERIZED=1  # deprecated
 # set to 1 If using the pre-configured minio setup
@@ -43,9 +43,6 @@ NGINX_PORT=80
 # Debug value for api server use it as 0 for production use
 DEBUG=0
 CORS_ALLOWED_ORIGINS="http://localhost"
-# Error logs
-SENTRY_DSN=""
-SENTRY_ENVIRONMENT="development"
 # Database Settings
 POSTGRES_USER="plane"
 POSTGRES_PASSWORD="plane"

README.md

@@ -16,10 +16,10 @@
 </p>
 
 <p align="center">
-    <a href="https://dub.sh/plane-website-readme"><b>Website</b></a> •
-    <a href="https://git.new/releases"><b>Releases</b></a> •
-    <a href="https://dub.sh/planepowershq"><b>Twitter</b></a> •
-    <a href="https://dub.sh/planedocs"><b>Documentation</b></a>
+    <a href="https://plane.so/"><b>Website</b></a> •
+    <a href="https://github.com/makeplane/plane/releases"><b>Releases</b></a> •
+    <a href="https://twitter.com/planepowers"><b>Twitter</b></a> •
+    <a href="https://docs.plane.so/"><b>Documentation</b></a>
 </p>
 
 <p>
@@ -39,7 +39,7 @@
     </a>
 </p>
 
-Meet [Plane](https://dub.sh/plane-website-readme), an open-source project management tool to track issues, run ~sprints~ cycles, and manage product roadmaps without the chaos of managing the tool itself. 🧘‍♀️
+Meet [Plane](https://plane.so/), an open-source project management tool to track issues, run ~sprints~ cycles, and manage product roadmaps without the chaos of managing the tool itself. 🧘‍♀️
 
 > Plane is evolving every day. Your suggestions, ideas, and reported bugs help us immensely. Do not hesitate to join in the conversation on [Discord](https://discord.com/invite/A92xrEGCge) or raise a GitHub issue. We read everything and respond to most.
 

admin/app/ai/form.tsx

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

admin/app/authentication/github/form.tsx

@@ -43,6 +43,7 @@ export const InstanceGithubConfigForm: FC<Props> = (props) => {
     defaultValues: {
       GITHUB_CLIENT_ID: config["GITHUB_CLIENT_ID"],
       GITHUB_CLIENT_SECRET: config["GITHUB_CLIENT_SECRET"],
+      GITHUB_ORGANIZATION_ID: config["GITHUB_ORGANIZATION_ID"],
     },
   });
 
@@ -93,6 +94,19 @@ export const InstanceGithubConfigForm: FC<Props> = (props) => {
       error: Boolean(errors.GITHUB_CLIENT_SECRET),
       required: true,
     },
+    {
+      key: "GITHUB_ORGANIZATION_ID",
+      type: "text",
+      label: "Organization ID",
+      description: (
+        <>
+          The organization github ID.
+        </>
+      ),
+      placeholder: "123456789",
+      error: Boolean(errors.GITHUB_ORGANIZATION_ID),
+      required: false,
+    },
   ];
 
   const GITHUB_SERVICE_FIELD: TCopyField[] = [
@@ -150,6 +164,7 @@ export const InstanceGithubConfigForm: FC<Props> = (props) => {
         reset({
           GITHUB_CLIENT_ID: response.find((item) => item.key === "GITHUB_CLIENT_ID")?.value,
           GITHUB_CLIENT_SECRET: response.find((item) => item.key === "GITHUB_CLIENT_SECRET")?.value,
+          GITHUB_ORGANIZATION_ID: response.find((item) => item.key === "GITHUB_ORGANIZATION_ID")?.value,
         });
       })
       .catch((err) => console.error(err));

admin/app/authentication/oidc/form.tsx

@@ -0,0 +1,240 @@
+import { FC, useState } from "react";
+import Link from "next/link";
+import { useForm } from "react-hook-form";
+// plane internal packages
+import { IFormattedInstanceConfiguration, TInstanceOIDCAuthenticationConfigurationKeys } from "@plane/types";
+import { Button, TOAST_TYPE, getButtonStyling, setToast } from "@plane/ui";
+import { cn } from "@plane/utils";
+// components
+import {
+  ConfirmDiscardModal,
+  ControllerInput,
+  TControllerInputFormField,
+  CopyField,
+  TCopyField,
+  CodeBlock,
+} from "@/components/common";
+// hooks
+import { useInstance } from "@/hooks/store";
+
+type Props = {
+  config: IFormattedInstanceConfiguration;
+};
+
+type OIDCConfigFormValues = Record<TInstanceOIDCAuthenticationConfigurationKeys, string>;
+
+export const InstanceOIDCConfigForm: FC<Props> = (props) => {
+  const { config } = props;
+  // states
+  const [isDiscardChangesModalOpen, setIsDiscardChangesModalOpen] = useState(false);
+  // store hooks
+  const { updateInstanceConfigurations } = useInstance();
+  // form data
+  const {
+    handleSubmit,
+    control,
+    reset,
+    formState: { errors, isDirty, isSubmitting },
+  } = useForm<OIDCConfigFormValues>({
+    defaultValues: {
+      OIDC_CLIENT_ID: config["OIDC_CLIENT_ID"],
+      OIDC_CLIENT_SECRET: config["OIDC_CLIENT_SECRET"],
+      OIDC_TOKEN_URL: config["OIDC_TOKEN_URL"],
+      OIDC_USERINFO_URL: config["OIDC_USERINFO_URL"],
+      OIDC_AUTHORIZE_URL: config["OIDC_AUTHORIZE_URL"],
+      OIDC_LOGOUT_URL: config["OIDC_LOGOUT_URL"],
+      OIDC_PROVIDER_NAME: config["OIDC_PROVIDER_NAME"],
+    },
+  });
+
+  const originURL = typeof window !== "undefined" ? window.location.origin : "";
+
+  const OIDC_FORM_FIELDS: TControllerInputFormField[] = [
+    {
+      key: "OIDC_CLIENT_ID",
+      type: "text",
+      label: "Client ID",
+      description: "A unique ID for this Plane app that you register on your IdP",
+      placeholder: "abc123xyz789",
+      error: Boolean(errors.OIDC_CLIENT_ID),
+      required: true,
+    },
+    {
+      key: "OIDC_CLIENT_SECRET",
+      type: "password",
+      label: "Client secret",
+      description: "The secret key that authenticates this Plane app to your IdP",
+      placeholder: "s3cr3tK3y123!",
+      error: Boolean(errors.OIDC_CLIENT_SECRET),
+      required: true,
+    },
+    {
+      key: "OIDC_AUTHORIZE_URL",
+      type: "text",
+      label: "Authorize URL",
+      description: (
+        <>
+          The URL that brings up your IdP{"'"}s authentication screen when your users click the{" "}
+          <CodeBlock>{"Continue with"}</CodeBlock>
+        </>
+      ),
+      placeholder: "https://example.com/",
+      error: Boolean(errors.OIDC_AUTHORIZE_URL),
+      required: true,
+    },
+    {
+      key: "OIDC_TOKEN_URL",
+      type: "text",
+      label: "Token URL",
+      description: "The URL that talks to the IdP and persists user authentication on Plane",
+      placeholder: "https://example.com/oauth/token",
+      error: Boolean(errors.OIDC_TOKEN_URL),
+      required: true,
+    },
+    {
+      key: "OIDC_USERINFO_URL",
+      type: "text",
+      label: "Users' info URL",
+      description: "The URL that fetches your users' info from your IdP",
+      placeholder: "https://example.com/userinfo",
+      error: Boolean(errors.OIDC_USERINFO_URL),
+      required: true,
+    },
+    {
+      key: "OIDC_LOGOUT_URL",
+      type: "text",
+      label: "Logout URL",
+      description: "Optional field that controls where your users go after they log out of Plane",
+      placeholder: "https://example.com/logout",
+      error: Boolean(errors.OIDC_LOGOUT_URL),
+      required: false,
+    },
+    {
+      key: "OIDC_PROVIDER_NAME",
+      type: "text",
+      label: "IdP's name",
+      description: (
+        <>
+          Optional field for the name that your users see on the <CodeBlock>Continue with</CodeBlock> button
+        </>
+      ),
+      placeholder: "Okta",
+      error: Boolean(errors.OIDC_PROVIDER_NAME),
+      required: false,
+    },
+  ];
+
+  const OIDC_SERVICE_DETAILS: TCopyField[] = [
+    {
+      key: "Origin_URI",
+      label: "Origin URI",
+      url: `${originURL}/auth/oidc/`,
+      description:
+        "We will generate this for this Plane app. Add this as a trusted origin on your IdP's corresponding field.",
+    },
+    {
+      key: "Callback_URI",
+      label: "Callback URI",
+      url: `${originURL}/auth/oidc/callback/`,
+      description: (
+        <>
+          We will generate this for you.Add this in the <CodeBlock darkerShade>Sign-in redirect URI</CodeBlock> field of
+          your IdP.
+        </>
+      ),
+    },
+    {
+      key: "Logout_URI",
+      label: "Logout URI",
+      url: `${originURL}/auth/oidc/logout/`,
+      description: (
+        <>
+          We will generate this for you. Add this in the <CodeBlock darkerShade>Logout redirect URI</CodeBlock> field of
+          your IdP.
+        </>
+      ),
+    },
+  ];
+
+  const onSubmit = async (formData: OIDCConfigFormValues) => {
+    const payload: Partial<OIDCConfigFormValues> = { ...formData };
+
+    await updateInstanceConfigurations(payload)
+      .then((response = []) => {
+        setToast({
+          type: TOAST_TYPE.SUCCESS,
+          title: "Done!",
+          message: "Your OIDC-based authentication is configured. You should test it now.",
+        });
+        reset({
+          OIDC_CLIENT_ID: response.find((item) => item.key === "OIDC_CLIENT_ID")?.value,
+          OIDC_CLIENT_SECRET: response.find((item) => item.key === "OIDC_CLIENT_SECRET")?.value,
+          OIDC_AUTHORIZE_URL: response.find((item) => item.key === "OIDC_AUTHORIZE_URL")?.value,
+          OIDC_TOKEN_URL: response.find((item) => item.key === "OIDC_TOKEN_URL")?.value,
+          OIDC_USERINFO_URL: response.find((item) => item.key === "OIDC_USERINFO_URL")?.value,
+          OIDC_LOGOUT_URL: response.find((item) => item.key === "OIDC_LOGOUT_URL")?.value,
+          OIDC_PROVIDER_NAME: response.find((item) => item.key === "OIDC_PROVIDER_NAME")?.value,
+        });
+      })
+      .catch((err) => console.error(err));
+  };
+
+  const handleGoBack = (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => {
+    if (isDirty) {
+      e.preventDefault();
+      setIsDiscardChangesModalOpen(true);
+    }
+  };
+
+  return (
+    <>
+      <ConfirmDiscardModal
+        isOpen={isDiscardChangesModalOpen}
+        onDiscardHref="/authentication"
+        handleClose={() => setIsDiscardChangesModalOpen(false)}
+      />
+      <div className="flex flex-col gap-8">
+        <div className="grid grid-cols-2 gap-x-12 gap-y-8 w-full">
+          <div className="flex flex-col gap-y-4 col-span-2 md:col-span-1 pt-1">
+            <div className="pt-2.5 text-xl font-medium">IdP-provided details for Plane</div>
+            {OIDC_FORM_FIELDS.map((field) => (
+              <ControllerInput
+                key={field.key}
+                control={control}
+                type={field.type}
+                name={field.key}
+                label={field.label}
+                description={field.description}
+                placeholder={field.placeholder}
+                error={field.error}
+                required={field.required}
+              />
+            ))}
+            <div className="flex flex-col gap-1 pt-4">
+              <div className="flex items-center gap-4">
+                <Button variant="primary" onClick={handleSubmit(onSubmit)} loading={isSubmitting} disabled={!isDirty}>
+                  {isSubmitting ? "Saving..." : "Save changes"}
+                </Button>
+                <Link
+                  href="/authentication"
+                  className={cn(getButtonStyling("link-neutral", "md"), "font-medium")}
+                  onClick={handleGoBack}
+                >
+                  Go back
+                </Link>
+              </div>
+            </div>
+          </div>
+          <div className="col-span-2 md:col-span-1">
+            <div className="flex flex-col gap-y-4 px-6 pt-1.5 pb-4 bg-custom-background-80/60 rounded-lg">
+              <div className="pt-2 text-xl font-medium">Plane-provided details for your IdP</div>
+              {OIDC_SERVICE_DETAILS.map((field) => (
+                <CopyField key={field.key} label={field.label} url={field.url} description={field.description} />
+              ))}
+            </div>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+};

admin/app/authentication/oidc/page.tsx

@@ -0,0 +1,120 @@
+"use client";
+
+import { useState } from "react";
+import { observer } from "mobx-react-lite";
+import Image from "next/image";
+import useSWR from "swr";
+// ui
+import { Loader, ToggleSwitch, setPromiseToast } from "@plane/ui";
+// components
+import { AuthenticationMethodCard } from "@/components/authentication";
+import { PageHeader } from "@/components/common";
+// hooks
+import { useInstance } from "@/hooks/store";
+// icons
+import OIDCLogo from "/public/logos/oidc-logo.svg";
+// plane admin hooks
+import { useInstanceFlag } from "@/plane-admin/hooks/store/use-instance-flag";
+// local components
+import { InstanceOIDCConfigForm } from "./form";
+
+const InstanceOIDCAuthenticationPage = observer(() => {
+  // state
+  const [isSubmitting, setIsSubmitting] = useState<boolean>(false);
+  // store
+  const { fetchInstanceConfigurations, formattedConfig, updateInstanceConfigurations } = useInstance();
+  // plane admin store
+  const isOIDCEnabled = useInstanceFlag("OIDC_SAML_AUTH");
+  // config
+  const enableOIDCConfig = formattedConfig?.IS_OIDC_ENABLED ?? "";
+
+  useSWR("INSTANCE_CONFIGURATIONS", () => fetchInstanceConfigurations());
+
+  const updateConfig = async (key: "IS_OIDC_ENABLED", value: string) => {
+    setIsSubmitting(true);
+
+    const payload = {
+      [key]: value,
+    };
+
+    const updateConfigPromise = updateInstanceConfigurations(payload);
+
+    setPromiseToast(updateConfigPromise, {
+      loading: "Saving Configuration...",
+      success: {
+        title: "Configuration saved",
+        message: () => `OIDC authentication is now ${value ? "active" : "disabled"}.`,
+      },
+      error: {
+        title: "Error",
+        message: () => "Failed to save configuration",
+      },
+    });
+
+    await updateConfigPromise
+      .then(() => {
+        setIsSubmitting(false);
+      })
+      .catch((err) => {
+        console.error(err);
+        setIsSubmitting(false);
+      });
+  };
+
+  if (isOIDCEnabled === false) {
+    return (
+      <div className="relative container mx-auto w-full h-full p-4 py-4 my-6 space-y-6 flex flex-col">
+        <PageHeader title="Authentication - God Mode" />
+        <div className="text-center text-lg text-gray-500">
+          <p>OpenID Connect (OIDC) authentication is not enabled for this instance.</p>
+          <p>Activate any of your workspace to get this feature.</p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <>
+      <PageHeader title="Authentication - God Mode" />
+      <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="OIDC"
+            description="Authenticate your users via the OpenID connect protocol."
+            icon={<Image src={OIDCLogo} height={24} width={24} alt="OIDC Logo" />}
+            config={
+              <ToggleSwitch
+                value={Boolean(parseInt(enableOIDCConfig))}
+                onChange={() => {
+                  Boolean(parseInt(enableOIDCConfig)) === true
+                    ? updateConfig("IS_OIDC_ENABLED", "0")
+                    : updateConfig("IS_OIDC_ENABLED", "1");
+                }}
+                size="sm"
+                disabled={isSubmitting || !formattedConfig}
+              />
+            }
+            disabled={isSubmitting || !formattedConfig}
+            withBorder={false}
+          />
+        </div>
+        <div className="flex-grow overflow-hidden overflow-y-scroll vertical-scrollbar scrollbar-md px-4">
+          {formattedConfig ? (
+            <InstanceOIDCConfigForm config={formattedConfig} />
+          ) : (
+            <Loader className="space-y-8">
+              <Loader.Item height="50px" width="25%" />
+              <Loader.Item height="50px" />
+              <Loader.Item height="50px" />
+              <Loader.Item height="50px" />
+              <Loader.Item height="50px" />
+              <Loader.Item height="50px" width="50%" />
+            </Loader>
+          )}
+        </div>
+      </div>
+    </>
+  );
+});
+
+export default InstanceOIDCAuthenticationPage;

admin/app/authentication/saml/form.tsx

@@ -0,0 +1,238 @@
+import { FC, useState } from "react";
+import Link from "next/link";
+import { Controller, useForm } from "react-hook-form";
+// plane internal packages
+import { IFormattedInstanceConfiguration, TInstanceSAMLAuthenticationConfigurationKeys } from "@plane/types";
+import { Button, TOAST_TYPE, TextArea, getButtonStyling, setToast } from "@plane/ui";
+import { cn } from "@plane/utils";
+// components
+import {
+  ConfirmDiscardModal,
+  ControllerInput,
+  TControllerInputFormField,
+  CopyField,
+  TCopyField,
+  CodeBlock,
+} from "@/components/common";
+// hooks
+import { useInstance } from "@/hooks/store";
+import { SAMLAttributeMappingTable } from "@/plane-admin/components/authentication";
+
+type Props = {
+  config: IFormattedInstanceConfiguration;
+};
+
+type SAMLConfigFormValues = Record<TInstanceSAMLAuthenticationConfigurationKeys, string>;
+
+export const InstanceSAMLConfigForm: FC<Props> = (props) => {
+  const { config } = props;
+  // states
+  const [isDiscardChangesModalOpen, setIsDiscardChangesModalOpen] = useState(false);
+  // store hooks
+  const { updateInstanceConfigurations } = useInstance();
+  // form data
+  const {
+    handleSubmit,
+    control,
+    reset,
+    formState: { errors, isDirty, isSubmitting },
+  } = useForm<SAMLConfigFormValues>({
+    defaultValues: {
+      SAML_ENTITY_ID: config["SAML_ENTITY_ID"],
+      SAML_SSO_URL: config["SAML_SSO_URL"],
+      SAML_LOGOUT_URL: config["SAML_LOGOUT_URL"],
+      SAML_CERTIFICATE: config["SAML_CERTIFICATE"],
+      SAML_PROVIDER_NAME: config["SAML_PROVIDER_NAME"],
+    },
+  });
+
+  const originURL = typeof window !== "undefined" ? window.location.origin : "";
+
+  const SAML_FORM_FIELDS: TControllerInputFormField[] = [
+    {
+      key: "SAML_ENTITY_ID",
+      type: "text",
+      label: "Entity ID",
+      description: "A unique ID for this Plane app that you register on your IdP",
+      placeholder: "70a44354520df8bd9bcd",
+      error: Boolean(errors.SAML_ENTITY_ID),
+      required: true,
+    },
+    {
+      key: "SAML_SSO_URL",
+      type: "text",
+      label: "SSO URL",
+      description: (
+        <>
+          The URL that brings up your IdP{"'"}s authentication screen when your users click the{" "}
+          <CodeBlock>{"Continue with"}</CodeBlock> button
+        </>
+      ),
+      placeholder: "https://example.com/sso",
+      error: Boolean(errors.SAML_SSO_URL),
+      required: true,
+    },
+    {
+      key: "SAML_LOGOUT_URL",
+      type: "text",
+      label: "Logout URL",
+      description: "Optional field that tells your IdP your users have logged out of this Plane app",
+      placeholder: "https://example.com/logout",
+      error: Boolean(errors.SAML_LOGOUT_URL),
+      required: false,
+    },
+    {
+      key: "SAML_PROVIDER_NAME",
+      type: "text",
+      label: "IdP's name",
+      description: (
+        <>
+          Optional field for the name that your users see on the <CodeBlock>Continue with</CodeBlock> button
+        </>
+      ),
+      placeholder: "Okta",
+      error: Boolean(errors.SAML_PROVIDER_NAME),
+      required: false,
+    },
+  ];
+
+  const SAML_SERVICE_DETAILS: TCopyField[] = [
+    {
+      key: "Metadata_Information",
+      label: "Entity ID | Audience | Metadata information",
+      url: `${originURL}/auth/saml/metadata/`,
+      description:
+        "We will generate this bit of the metadata that identifies this Plane app as an authorized service on your IdP.",
+    },
+    {
+      key: "Callback_URI",
+      label: "Callback URI",
+      url: `${originURL}/auth/saml/callback/`,
+      description: (
+        <>
+          We will generate this <CodeBlock darkerShade>http-post request</CodeBlock> URL that you should paste into your{" "}
+          <CodeBlock darkerShade>ACS URL</CodeBlock> or <CodeBlock darkerShade>Sign-in call back URL</CodeBlock> field
+          on your IdP.
+        </>
+      ),
+    },
+    {
+      key: "Logout_URI",
+      label: "Logout URI",
+      url: `${originURL}/auth/saml/logout/`,
+      description: (
+        <>
+          We will generate this <CodeBlock darkerShade>http-redirect request</CodeBlock> URL that you should paste into
+          your <CodeBlock darkerShade>SLS URL</CodeBlock> or <CodeBlock darkerShade>Logout URL</CodeBlock>
+          field on your IdP.
+        </>
+      ),
+    },
+  ];
+
+  const onSubmit = async (formData: SAMLConfigFormValues) => {
+    const payload: Partial<SAMLConfigFormValues> = { ...formData };
+
+    await updateInstanceConfigurations(payload)
+      .then((response = []) => {
+        setToast({
+          type: TOAST_TYPE.SUCCESS,
+          title: "Done!",
+          message: "Your SAML-based authentication is configured. You should test it now.",
+        });
+        reset({
+          SAML_ENTITY_ID: response.find((item) => item.key === "SAML_ENTITY_ID")?.value,
+          SAML_SSO_URL: response.find((item) => item.key === "SAML_SSO_URL")?.value,
+          SAML_LOGOUT_URL: response.find((item) => item.key === "SAML_LOGOUT_URL")?.value,
+          SAML_CERTIFICATE: response.find((item) => item.key === "SAML_CERTIFICATE")?.value,
+          SAML_PROVIDER_NAME: response.find((item) => item.key === "SAML_PROVIDER_NAME")?.value,
+        });
+      })
+      .catch((err) => console.error(err));
+  };
+
+  const handleGoBack = (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => {
+    if (isDirty) {
+      e.preventDefault();
+      setIsDiscardChangesModalOpen(true);
+    }
+  };
+
+  return (
+    <>
+      <ConfirmDiscardModal
+        isOpen={isDiscardChangesModalOpen}
+        onDiscardHref="/authentication"
+        handleClose={() => setIsDiscardChangesModalOpen(false)}
+      />
+      <div className="flex flex-col gap-8">
+        <div className="grid grid-cols-2 gap-x-12 gap-y-8 w-full">
+          <div className="flex flex-col gap-y-4 col-span-2 md:col-span-1 pt-1">
+            <div className="pt-2.5 text-xl font-medium">IdP-provided details for Plane</div>
+            {SAML_FORM_FIELDS.map((field) => (
+              <ControllerInput
+                key={field.key}
+                control={control}
+                type={field.type}
+                name={field.key}
+                label={field.label}
+                description={field.description}
+                placeholder={field.placeholder}
+                error={field.error}
+                required={field.required}
+              />
+            ))}
+            <div className="flex flex-col gap-1">
+              <h4 className="text-sm">SAML certificate</h4>
+              <Controller
+                control={control}
+                name="SAML_CERTIFICATE"
+                rules={{ required: "Certificate is required." }}
+                render={({ field: { value, onChange } }) => (
+                  <TextArea
+                    id="SAML_CERTIFICATE"
+                    name="SAML_CERTIFICATE"
+                    value={value}
+                    onChange={onChange}
+                    hasError={Boolean(errors.SAML_CERTIFICATE)}
+                    placeholder="---BEGIN CERTIFICATE---\n2yWn1gc7DhOFB9\nr0gbE+\n---END CERTIFICATE---"
+                    className="min-h-[102px] w-full rounded-md font-medium text-sm"
+                  />
+                )}
+              />
+              <p className="pt-0.5 text-xs text-custom-text-300">
+                IdP-generated certificate for signing this Plane app as an authorized service provider for your IdP
+              </p>
+            </div>
+            <div className="flex flex-col gap-1 pt-4">
+              <div className="flex items-center gap-4">
+                <Button variant="primary" onClick={handleSubmit(onSubmit)} loading={isSubmitting} disabled={!isDirty}>
+                  {isSubmitting ? "Saving..." : "Save changes"}
+                </Button>
+                <Link
+                  href="/authentication"
+                  className={cn(getButtonStyling("link-neutral", "md"), "font-medium")}
+                  onClick={handleGoBack}
+                >
+                  Go back
+                </Link>
+              </div>
+            </div>
+          </div>
+          <div className="col-span-2 md:col-span-1">
+            <div className="flex flex-col gap-y-4 px-6 pt-1.5 pb-4 bg-custom-background-80/60 rounded-lg">
+              <div className="pt-2 text-xl font-medium">Plane-provided details for your IdP</div>
+              {SAML_SERVICE_DETAILS.map((field) => (
+                <CopyField key={field.key} label={field.label} url={field.url} description={field.description} />
+              ))}
+              <div className="flex flex-col gap-1">
+                <h4 className="text-sm text-custom-text-200 font-medium">Mapping</h4>
+                <SAMLAttributeMappingTable />
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+};

admin/app/authentication/saml/page.tsx

@@ -0,0 +1,120 @@
+"use client";
+
+import { useState } from "react";
+import { observer } from "mobx-react-lite";
+import Image from "next/image";
+import useSWR from "swr";
+// ui
+import { Loader, ToggleSwitch, setPromiseToast } from "@plane/ui";
+// components
+import { AuthenticationMethodCard } from "@/components/authentication";
+import { PageHeader } from "@/components/common";
+// hooks
+import { useInstance } from "@/hooks/store";
+// icons
+import SAMLLogo from "/public/logos/saml-logo.svg";
+// plane admin hooks
+import { useInstanceFlag } from "@/plane-admin/hooks/store/use-instance-flag";
+// local components
+import { InstanceSAMLConfigForm } from "./form";
+
+const InstanceSAMLAuthenticationPage = observer(() => {
+  // state
+  const [isSubmitting, setIsSubmitting] = useState<boolean>(false);
+  // store
+  const { fetchInstanceConfigurations, formattedConfig, updateInstanceConfigurations } = useInstance();
+  // plane admin store
+  const isSAMLEnabled = useInstanceFlag("OIDC_SAML_AUTH");
+  // config
+  const enableSAMLConfig = formattedConfig?.IS_SAML_ENABLED ?? "";
+
+  useSWR("INSTANCE_CONFIGURATIONS", () => fetchInstanceConfigurations());
+
+  const updateConfig = async (key: "IS_SAML_ENABLED", value: string) => {
+    setIsSubmitting(true);
+
+    const payload = {
+      [key]: value,
+    };
+
+    const updateConfigPromise = updateInstanceConfigurations(payload);
+
+    setPromiseToast(updateConfigPromise, {
+      loading: "Saving Configuration...",
+      success: {
+        title: "Configuration saved",
+        message: () => `SAML authentication is now ${value ? "active" : "disabled"}.`,
+      },
+      error: {
+        title: "Error",
+        message: () => "Failed to save configuration",
+      },
+    });
+
+    await updateConfigPromise
+      .then(() => {
+        setIsSubmitting(false);
+      })
+      .catch((err) => {
+        console.error(err);
+        setIsSubmitting(false);
+      });
+  };
+
+  if (isSAMLEnabled === false) {
+    return (
+      <div className="relative container mx-auto w-full h-full p-4 py-4 my-6 space-y-6 flex flex-col">
+        <PageHeader title="Authentication - God Mode" />
+        <div className="text-center text-lg text-gray-500">
+          <p>Security Assertion Markup Language (SAML) authentication is not enabled for this instance.</p>
+          <p>Activate any of your workspace to get this feature.</p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <>
+      <PageHeader title="Authentication - God Mode" />
+      <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="SAML"
+            description="Authenticate your users via Security Assertion Markup Language
+          protocol."
+            icon={<Image src={SAMLLogo} height={24} width={24} alt="SAML Logo" className="pl-0.5" />}
+            config={
+              <ToggleSwitch
+                value={Boolean(parseInt(enableSAMLConfig))}
+                onChange={() => {
+                  Boolean(parseInt(enableSAMLConfig)) === true
+                    ? updateConfig("IS_SAML_ENABLED", "0")
+                    : updateConfig("IS_SAML_ENABLED", "1");
+                }}
+                size="sm"
+                disabled={isSubmitting || !formattedConfig}
+              />
+            }
+            disabled={isSubmitting || !formattedConfig}
+            withBorder={false}
+          />
+        </div>
+        <div className="flex-grow overflow-hidden overflow-y-scroll vertical-scrollbar scrollbar-md px-4">
+          {formattedConfig ? (
+            <InstanceSAMLConfigForm config={formattedConfig} />
+          ) : (
+            <Loader className="space-y-8">
+              <Loader.Item height="50px" width="25%" />
+              <Loader.Item height="50px" />
+              <Loader.Item height="50px" />
+              <Loader.Item height="50px" />
+              <Loader.Item height="50px" width="50%" />
+            </Loader>
+          )}
+        </div>
+      </div>
+    </>
+  );
+});
+
+export default InstanceSAMLAuthenticationPage;

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

@@ -10,11 +10,12 @@ import { WEB_BASE_URL } from "@plane/constants";
 import { DiscordIcon, GithubIcon, Tooltip } from "@plane/ui";
 import { cn } from "@plane/utils";
 // hooks
-import { useTheme } from "@/hooks/store";
+import { useInstance, useTheme } from "@/hooks/store";
 // assets
 // eslint-disable-next-line import/order
 import packageJson from "package.json";
 
+
 const helpOptions = [
   {
     name: "Documentation",
@@ -37,6 +38,7 @@ export const HelpSection: FC = observer(() => {
   // states
   const [isNeedHelpOpen, setIsNeedHelpOpen] = useState(false);
   // store
+  const { instance } = useInstance();
   const { isSidebarCollapsed, toggleSidebar } = useTheme();
   // refs
   const helpOptionsRef = useRef<HTMLDivElement | null>(null);
@@ -129,8 +131,20 @@ export const HelpSection: FC = observer(() => {
                     </button>
                   );
               })}
+              {/* {instance?.latest_version && instance?.current_version != instance?.latest_version && (
+                <a
+                  href="https://docs.plane.so/docs/changelog"
+                  target="_blank"
+                  className="flex items-center gap-2 px-2 py-1 text-xs font-medium cursor-pointer transition-all border rounded border-custom-primary-100/30 bg-custom-primary-100/20 hover:bg-custom-primary-100/30 text-custom-text-100"
+                  referrerPolicy="no-referrer"
+                >
+                  <RefreshCcw className="flex-shrink-0 h-3 w-3 text-custom-text-100" />
+                  <div>Updates available</div>
+                  <div className="flex-shrink-0 ml-auto animate-pulse bg-custom-primary-100 !w-2 !h-2 rounded-full" />
+                </a>
+              )} */}
             </div>
-            <div className="px-2 pb-1 pt-2 text-[10px]">Version: v{packageJson.version}</div>
+            <div className="px-2 pb-1 pt-2 text-[10px]">Version: v{instance?.current_version}</div>
           </div>
         </Transition>
       </div>

admin/core/layouts/admin-layout.tsx

@@ -2,6 +2,7 @@
 import { FC, ReactNode, useEffect } from "react";
 import { observer } from "mobx-react";
 import { useRouter } from "next/navigation";
+import useSWR from "swr";
 // components
 import { InstanceSidebar } from "@/components/admin-sidebar";
 import { InstanceHeader } from "@/components/auth-header";
@@ -9,6 +10,8 @@ import { LogoSpinner } from "@/components/common";
 import { NewUserPopup } from "@/components/new-user-popup";
 // hooks
 import { useUser } from "@/hooks/store";
+// plane admin hooks
+import { useInstanceFeatureFlags } from "@/plane-admin/hooks/store/use-instance-feature-flag";
 
 type TAdminLayout = {
   children: ReactNode;
@@ -20,6 +23,14 @@ export const AdminLayout: FC<TAdminLayout> = observer((props) => {
   const router = useRouter();
   // store hooks
   const { isUserLoggedIn } = useUser();
+  // plane admin hooks
+  const { fetchInstanceFeatureFlags } = useInstanceFeatureFlags();
+  // fetching instance feature flags
+  const { isLoading: flagsLoader, error: flagsError } = useSWR(
+    `INSTANCE_FEATURE_FLAGS`,
+    () => fetchInstanceFeatureFlags(),
+    { revalidateOnFocus: false, revalidateIfStale: false, errorRetryCount: 1 }
+  );
 
   useEffect(() => {
     if (isUserLoggedIn === false) {
@@ -27,7 +38,7 @@ export const AdminLayout: FC<TAdminLayout> = observer((props) => {
     }
   }, [router, isUserLoggedIn]);
 
-  if (isUserLoggedIn === undefined) {
+  if ((flagsLoader && !flagsError) || isUserLoggedIn === undefined) {
     return (
       <div className="relative flex h-screen w-full items-center justify-center">
         <LogoSpinner />

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

@@ -1 +1,85 @@
-export * from "ce/components/authentication/authentication-modes";
+import { observer } from "mobx-react";
+import Image from "next/image";
+import { useTheme } from "next-themes";
+import {
+  TInstanceAuthenticationMethodKeys as TBaseAuthenticationMethods,
+  TInstanceAuthenticationModes,
+  TInstanceEnterpriseAuthenticationMethodKeys,
+} from "@plane/types";
+import { getAuthenticationModes as getCEAuthenticationModes } from "@/ce/components/authentication/authentication-modes";
+// types
+// components
+import { AuthenticationMethodCard } from "@/components/authentication";
+// helpers
+import { getBaseAuthenticationModes } from "@/lib/auth-helpers";
+// plane admin components
+import { OIDCConfiguration, SAMLConfiguration } from "@/plane-admin/components/authentication";
+// images
+import { useInstanceFlag } from "@/plane-admin/hooks/store/use-instance-flag";
+import OIDCLogo from "@/public/logos/oidc-logo.svg";
+import SAMLLogo from "@/public/logos/saml-logo.svg";
+// plane admin hooks
+
+type TInstanceAuthenticationMethodKeys = TBaseAuthenticationMethods | TInstanceEnterpriseAuthenticationMethodKeys;
+
+export type TAuthenticationModeProps = {
+  disabled: boolean;
+  updateConfig: (key: TInstanceAuthenticationMethodKeys, value: string) => void;
+};
+
+export type TGetAuthenticationModeProps = {
+  disabled: boolean;
+  updateConfig: (key: TInstanceAuthenticationMethodKeys, value: string) => void;
+  resolvedTheme: string | undefined;
+};
+
+// Enterprise authentication methods
+export const getAuthenticationModes: (props: TGetAuthenticationModeProps) => TInstanceAuthenticationModes[] = ({
+  disabled,
+  updateConfig,
+  resolvedTheme,
+}) => [
+  ...getBaseAuthenticationModes({ disabled, updateConfig, resolvedTheme }),
+  {
+    key: "oidc",
+    name: "OIDC",
+    description: "Authenticate your users via the OpenID Connect protocol.",
+    icon: <Image src={OIDCLogo} height={22} width={22} alt="OIDC Logo" />,
+    config: <OIDCConfiguration disabled={disabled} updateConfig={updateConfig} />,
+  },
+  {
+    key: "saml",
+    name: "SAML",
+    description: "Authenticate your users via the Security Assertion Markup Language protocol.",
+    icon: <Image src={SAMLLogo} height={22} width={22} alt="SAML Logo" className="pl-0.5" />,
+    config: <SAMLConfiguration disabled={disabled} updateConfig={updateConfig} />,
+  },
+];
+
+export const AuthenticationModes: React.FC<TAuthenticationModeProps> = observer((props) => {
+  const { disabled, updateConfig } = props;
+  // next-themes
+  const { resolvedTheme } = useTheme();
+  // plane admin hooks
+  const isOIDCSAMLEnabled = useInstanceFlag("OIDC_SAML_AUTH");
+
+  const authenticationModes = isOIDCSAMLEnabled
+    ? getAuthenticationModes({ disabled, updateConfig, resolvedTheme })
+    : getCEAuthenticationModes({ disabled, updateConfig, resolvedTheme });
+
+  return (
+    <>
+      {authenticationModes.map((method) => (
+        <AuthenticationMethodCard
+          key={method.key}
+          name={method.name}
+          description={method.description}
+          icon={method.icon}
+          config={method.config}
+          disabled={disabled}
+          unavailable={method.unavailable}
+        />
+      ))}
+    </>
+  );
+});

admin/ee/components/authentication/index.ts

@@ -1 +1,4 @@
 export * from "./authentication-modes";
+export * from "./oidc-config";
+export * from "./saml-config";
+export * from "./saml-attribute-mapping-table";

admin/ee/components/authentication/oidc-config.tsx

@@ -0,0 +1,57 @@
+"use client";
+
+import React from "react";
+import { observer } from "mobx-react-lite";
+import Link from "next/link";
+// icons
+import { Settings2 } from "lucide-react";
+// plane internal packages
+import { TInstanceEnterpriseAuthenticationMethodKeys } from "@plane/types";
+import { ToggleSwitch, getButtonStyling } from "@plane/ui";
+import { cn } from "@plane/utils";
+// hooks
+import { useInstance } from "@/hooks/store";
+
+type Props = {
+  disabled: boolean;
+  updateConfig: (key: TInstanceEnterpriseAuthenticationMethodKeys, value: string) => void;
+};
+
+export const OIDCConfiguration: React.FC<Props> = observer((props) => {
+  const { disabled, updateConfig } = props;
+  // store
+  const { formattedConfig } = useInstance();
+  // derived values
+  const enableOIDCConfig = formattedConfig?.IS_OIDC_ENABLED ?? "";
+  const isOIDCConfigured = !!formattedConfig?.OIDC_CLIENT_ID && !!formattedConfig?.OIDC_CLIENT_SECRET;
+
+  return (
+    <>
+      {isOIDCConfigured ? (
+        <div className="flex items-center gap-4">
+          <Link href="/authentication/oidc" className={cn(getButtonStyling("link-primary", "md"), "font-medium")}>
+            Edit
+          </Link>
+          <ToggleSwitch
+            value={Boolean(parseInt(enableOIDCConfig))}
+            onChange={() => {
+              Boolean(parseInt(enableOIDCConfig)) === true
+                ? updateConfig("IS_OIDC_ENABLED", "0")
+                : updateConfig("IS_OIDC_ENABLED", "1");
+            }}
+            size="sm"
+            disabled={disabled}
+          />
+        </div>
+      ) : (
+        <Link
+          href="/authentication/oidc"
+          className={cn(getButtonStyling("neutral-primary", "sm"), "text-custom-text-300")}
+        >
+          <Settings2 className="h-4 w-4 p-0.5 text-custom-text-300/80" />
+          Configure
+        </Link>
+      )}
+    </>
+  );
+});

admin/ee/components/authentication/saml-attribute-mapping-table.tsx

@@ -0,0 +1,28 @@
+export const SAMLAttributeMappingTable = () => (
+  <table className="table-auto border-collapse text-custom-text-200 text-sm">
+    <thead>
+      <tr className="text-left">
+        <th className="border-b border-r border-custom-border-300 px-4 py-1.5">IdP</th>
+        <th className="border-b border-custom-border-300 px-4 py-1.5">Plane</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr>
+        <td className="border-t border-r border-custom-border-300 px-4 py-1.5">Name ID format</td>
+        <td className="border-t border-custom-border-300 px-4 py-1.5">emailAddress</td>
+      </tr>
+      <tr>
+        <td className="border-t border-r border-custom-border-300 px-4 py-1.5">first_name</td>
+        <td className="border-t border-custom-border-300 px-4 py-1.5">user.firstName</td>
+      </tr>
+      <tr>
+        <td className="border-t border-r border-custom-border-300 px-4 py-1.5">last_name</td>
+        <td className="border-t border-custom-border-300 px-4 py-1.5">user.lastName</td>
+      </tr>
+      <tr>
+        <td className="border-t border-r border-custom-border-300 px-4 py-1.5">email</td>
+        <td className="border-t border-custom-border-300 px-4 py-1.5">user.email</td>
+      </tr>
+    </tbody>
+  </table>
+);

admin/ee/components/authentication/saml-config.tsx

@@ -0,0 +1,57 @@
+"use client";
+
+import React from "react";
+import { observer } from "mobx-react-lite";
+import Link from "next/link";
+// icons
+import { Settings2 } from "lucide-react";
+// plane internal packages
+import { TInstanceEnterpriseAuthenticationMethodKeys } from "@plane/types";
+import { ToggleSwitch, getButtonStyling } from "@plane/ui";
+import { cn } from "@plane/utils";
+// hooks
+import { useInstance } from "@/hooks/store";
+
+type Props = {
+  disabled: boolean;
+  updateConfig: (key: TInstanceEnterpriseAuthenticationMethodKeys, value: string) => void;
+};
+
+export const SAMLConfiguration: React.FC<Props> = observer((props) => {
+  const { disabled, updateConfig } = props;
+  // store
+  const { formattedConfig } = useInstance();
+  // derived values
+  const enableSAMLConfig = formattedConfig?.IS_SAML_ENABLED ?? "";
+  const isSAMLConfigured = !!formattedConfig?.SAML_ENTITY_ID && !!formattedConfig?.SAML_CERTIFICATE;
+
+  return (
+    <>
+      {isSAMLConfigured ? (
+        <div className="flex items-center gap-4">
+          <Link href="/authentication/saml" className={cn(getButtonStyling("link-primary", "md"), "font-medium")}>
+            Edit
+          </Link>
+          <ToggleSwitch
+            value={Boolean(parseInt(enableSAMLConfig))}
+            onChange={() => {
+              Boolean(parseInt(enableSAMLConfig)) === true
+                ? updateConfig("IS_SAML_ENABLED", "0")
+                : updateConfig("IS_SAML_ENABLED", "1");
+            }}
+            size="sm"
+            disabled={disabled}
+          />
+        </div>
+      ) : (
+        <Link
+          href="/authentication/saml"
+          className={cn(getButtonStyling("neutral-primary", "sm"), "text-custom-text-300")}
+        >
+          <Settings2 className="h-4 w-4 p-0.5 text-custom-text-300/80" />
+          Configure
+        </Link>
+      )}
+    </>
+  );
+});

admin/ee/components/common/index.ts

@@ -1 +1 @@
-export * from "ce/components/common";
+export * from "./upgrade-button";

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

@@ -0,0 +1,38 @@
+"use client";
+
+import React from "react";
+// plane internal packages
+import { WEB_BASE_URL } from "@plane/constants";
+import { AlertModalCore, Button } from "@plane/ui";
+
+export const UpgradeButton: React.FC = () => {
+  // states
+  const [isActivationModalOpen, setIsActivationModalOpen] = React.useState(false);
+  // derived values
+  const redirectionLink = encodeURI(WEB_BASE_URL + "/");
+
+  return (
+    <>
+      <AlertModalCore
+        variant="primary"
+        isOpen={isActivationModalOpen}
+        handleClose={() => setIsActivationModalOpen(false)}
+        handleSubmit={() => {
+          window.open(redirectionLink, "_blank");
+          setIsActivationModalOpen(false);
+        }}
+        isSubmitting={false}
+        title="Activate workspace"
+        content="Activate any of your workspace to get this feature."
+        primaryButtonText={{
+          loading: "Redirecting...",
+          default: "Go to Plane",
+        }}
+        secondaryButtonText="Close"
+      />
+      <Button variant="primary" size="sm" onClick={() => setIsActivationModalOpen(true)}>
+        Activate workspace
+      </Button>
+    </>
+  );
+};

admin/ee/hooks/store/use-instance-feature-flag.ts

@@ -0,0 +1,11 @@
+import { useContext } from "react";
+// context
+import { StoreContext } from "@/lib/store-provider";
+// plane admin stores
+import { IInstanceFeatureFlagsStore } from "@/plane-admin/store/instance-feature-flags.store";
+
+export const useInstanceFeatureFlags = (): IInstanceFeatureFlagsStore => {
+  const context = useContext(StoreContext);
+  if (context === undefined) throw new Error("useInstanceFeatureFlags must be used within StoreProvider");
+  return context.instanceFeatureFlags;
+};

admin/ee/hooks/store/use-instance-flag.ts

@@ -0,0 +1,13 @@
+import { useContext } from "react";
+// context
+import { StoreContext } from "@/lib/store-provider";
+
+export enum E_FEATURE_FLAGS {
+  OIDC_SAML_AUTH = "OIDC_SAML_AUTH",
+}
+
+export const useInstanceFlag = (flag: keyof typeof E_FEATURE_FLAGS, defaultValue: boolean = false): boolean => {
+  const context = useContext(StoreContext);
+  if (context === undefined) throw new Error("useInstanceFlag must be used within StoreProvider");
+  return context.instanceFeatureFlags.flags?.[E_FEATURE_FLAGS[flag]] ?? defaultValue;
+};

admin/ee/store/instance-feature-flags.store.ts

@@ -0,0 +1,48 @@
+import { set } from "lodash";
+import { action, makeObservable, observable, runInAction } from "mobx";
+// plane imports
+import { InstanceFeatureFlagService } from "@plane/services";
+import { TInstanceFeatureFlagsResponse } from "@plane/types";
+
+const instanceFeatureFlagService = new InstanceFeatureFlagService();
+
+type TFeatureFlagsMaps = Record<string, boolean>; // feature flag -> boolean
+
+export interface IInstanceFeatureFlagsStore {
+  flags: TFeatureFlagsMaps;
+  // actions
+  hydrate: (data: any) => void;
+  fetchInstanceFeatureFlags: () => Promise<TInstanceFeatureFlagsResponse>;
+}
+
+export class InstanceFeatureFlagsStore implements IInstanceFeatureFlagsStore {
+  flags: TFeatureFlagsMaps = {};
+
+  constructor() {
+    makeObservable(this, {
+      flags: observable,
+      fetchInstanceFeatureFlags: action,
+    });
+  }
+
+  hydrate = (data: any) => {
+    if (data) this.flags = data;
+  };
+
+  fetchInstanceFeatureFlags = async () => {
+    try {
+      const response = await instanceFeatureFlagService.list();
+      runInAction(() => {
+        if (response) {
+          Object.keys(response).forEach((key) => {
+            set(this.flags, key, response[key]);
+          });
+        }
+      });
+      return response;
+    } catch (error) {
+      console.error("Error fetching instance feature flags", error);
+      throw error;
+    }
+  };
+}

admin/ee/store/root.store.ts

@@ -1 +1,29 @@
-export * from "ce/store/root.store";
+import { enableStaticRendering } from "mobx-react";
+// stores
+import {
+  IInstanceFeatureFlagsStore,
+  InstanceFeatureFlagsStore,
+} from "@/plane-admin/store/instance-feature-flags.store";
+import { CoreRootStore } from "@/store/root.store";
+// plane admin store
+
+enableStaticRendering(typeof window === "undefined");
+
+export class RootStore extends CoreRootStore {
+  instanceFeatureFlags: IInstanceFeatureFlagsStore;
+
+  constructor() {
+    super();
+    this.instanceFeatureFlags = new InstanceFeatureFlagsStore();
+  }
+
+  hydrate(initialData: any) {
+    super.hydrate(initialData);
+    this.instanceFeatureFlags.hydrate(initialData.instanceFeatureFlags);
+  }
+
+  resetOnSignOut() {
+    super.resetOnSignOut();
+    this.instanceFeatureFlags = new InstanceFeatureFlagsStore();
+  }
+}

admin/next.config.js

@@ -9,6 +9,19 @@ const nextConfig = {
     unoptimized: true,
   },
   basePath: process.env.NEXT_PUBLIC_ADMIN_BASE_PATH || "",
+  transpilePackages: [
+    "@plane/constants",
+    "@plane/editor",
+    "@plane/hooks",
+    "@plane/i18n",
+    "@plane/logger",
+    "@plane/propel",
+    "@plane/services",
+    "@plane/shared-state",
+    "@plane/types",
+    "@plane/ui",
+    "@plane/utils",
+  ],
 };
 
 module.exports = nextConfig;

admin/package.json

@@ -1,7 +1,7 @@
 {
   "name": "admin",
   "description": "Admin UI for Plane",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "license": "AGPL-3.0",
   "private": true,
   "scripts": {
@@ -21,18 +21,17 @@
     "@plane/ui": "*",
     "@plane/utils": "*",
     "@plane/services": "*",
-    "@sentry/nextjs": "^8.54.0",
     "@tailwindcss/typography": "^0.5.9",
     "@types/lodash": "^4.17.0",
     "autoprefixer": "10.4.14",
-    "axios": "^1.7.9",
+    "axios": "^1.8.3",
     "lodash": "^4.17.21",
     "lucide-react": "^0.469.0",
     "mobx": "^6.12.0",
     "mobx-react": "^9.1.1",
-    "next": "^14.2.20",
+    "next": "^14.2.26",
     "next-themes": "^0.2.1",
-    "postcss": "^8.4.38",
+    "postcss": "^8.4.49",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-hook-form": "7.51.5",

admin/tsconfig.json

@@ -6,7 +6,8 @@
     "paths": {
       "@/*": ["core/*"],
       "@/public/*": ["public/*"],
-      "@/plane-admin/*": ["ce/*"]
+      "@/plane-admin/*": ["ee/*"],
+      "@/ce/*": ["ce/*"]
     }
   },
   "include": ["next-env.d.ts", "next.config.js", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],

aio/Dockerfile-app

@@ -145,11 +145,8 @@ RUN chmod +x /app/pg-setup.sh
 #  APPLICATION ENVIRONMENT SETTINGS
 # *****************************************************************************
 ENV APP_DOMAIN=localhost
-
 ENV WEB_URL=http://${APP_DOMAIN}
 ENV DEBUG=0
-ENV SENTRY_DSN=
-ENV SENTRY_ENVIRONMENT=production
 ENV CORS_ALLOWED_ORIGINS=http://${APP_DOMAIN},https://${APP_DOMAIN}
 # Secret Key
 ENV SECRET_KEY=60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5

apiserver/.env.example

@@ -3,10 +3,6 @@
 DEBUG=0
 CORS_ALLOWED_ORIGINS="http://localhost"
 
-# Error logs
-SENTRY_DSN=""
-SENTRY_ENVIRONMENT="development"
-
 # Database Settings
 POSTGRES_USER="plane"
 POSTGRES_PASSWORD="plane"
@@ -56,7 +52,14 @@ GUNICORN_WORKERS=2
 ADMIN_BASE_URL=
 SPACE_BASE_URL=
 APP_BASE_URL=
+SILO_BASE_URL=
 
 
 # Hard delete files after days
-HARD_DELETE_AFTER_DAYS=60
+HARD_DELETE_AFTER_DAYS=60
+
+# Force HTTPS for handling SSL Termination
+MINIO_ENDPOINT_SSL=0
+
+# API key rate limit
+API_KEY_RATE_LIMIT="60/minute"

apiserver/.gitignore

@@ -0,0 +1 @@
+dump.rdb

apiserver/Dockerfile.api

@@ -3,8 +3,8 @@ FROM python:3.12.5-alpine AS backend
 # set environment variables
 ENV PYTHONDONTWRITEBYTECODE 1
 ENV PYTHONUNBUFFERED 1
-ENV PIP_DISABLE_PIP_VERSION_CHECK=1 
-ENV INSTANCE_CHANGELOG_URL https://sites.plane.so/pages/691ef037bcfe416a902e48cb55f59891/
+ENV PIP_DISABLE_PIP_VERSION_CHECK=1
+ENV INSTANCE_CHANGELOG_URL https://sites.plane.so/pages/f366114e9aba4cbfbe4265b8f2b74f65
 
 WORKDIR /code
 
@@ -27,6 +27,7 @@ RUN apk add --no-cache --virtual .build-deps \
     "postgresql-dev" \
     "libc-dev" \
     "linux-headers" \
+    "xmlsec-dev"\
     && \
     pip install -r requirements.txt --compile --no-cache-dir \
     && \

apiserver/Dockerfile.dev

@@ -4,7 +4,8 @@ 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://sites.plane.so/pages/691ef037bcfe416a902e48cb55f59891/
+ENV INSTANCE_CHANGELOG_URL https://sites.plane.so/pages/f366114e9aba4cbfbe4265b8f2b74f65
+
 
 RUN apk --no-cache add \
     "bash~=5.2" \
@@ -21,7 +22,8 @@ RUN apk --no-cache add \
     "make" \
     "postgresql-dev" \
     "libc-dev" \
-    "linux-headers"
+    "linux-headers" \
+    "xmlsec-dev"
 
 WORKDIR /code
 

apiserver/README.md

@@ -0,0 +1 @@
+# API SERVER

apiserver/bin/docker-entrypoint-api-cloud.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+export SKIP_ENV_VAR=0
+
+python manage.py wait_for_db
+# Wait for migrations
+python manage.py wait_for_migrations
+
+# Clear Cache before starting to remove stale values
+python manage.py clear_cache
+
+# Register instance if INSTANCE_ADMIN_EMAIL is set
+if [ -n "$INSTANCE_ADMIN_EMAIL" ]; then
+    python manage.py setup_instance $INSTANCE_ADMIN_EMAIL
+fi
+
+exec gunicorn -w "$GUNICORN_WORKERS" -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:"${PORT:-8000}" --max-requests 1200 --max-requests-jitter 1000 --access-logfile -

apiserver/bin/docker-entrypoint-api-ee.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+set -e
+python manage.py wait_for_db
+# Wait for migrations
+python manage.py wait_for_migrations
+
+# Create the default bucket
+#!/bin/bash
+
+# Collect system information
+HOSTNAME=$(hostname)
+MAC_ADDRESS=$(ip link show | awk '/ether/ {print $2}' | head -n 1)
+CPU_INFO=$(cat /proc/cpuinfo)
+MEMORY_INFO=$(free -h)
+DISK_INFO=$(df -h)
+
+# Concatenate information and compute SHA-256 hash
+SIGNATURE=$(echo "$HOSTNAME$MAC_ADDRESS$CPU_INFO$MEMORY_INFO$DISK_INFO" | sha256sum | awk '{print $1}')
+
+# Export the variables
+MACHINE_SIGNATURE=${MACHINE_SIGNATURE:-$SIGNATURE}
+export SKIP_ENV_VAR=1
+
+# Register instance
+python manage.py register_instance_ee "$MACHINE_SIGNATURE"
+
+# Load the configuration variable
+python manage.py configure_instance
+
+# Create the default bucket
+python manage.py create_bucket
+
+# Clear Cache before starting to remove stale values
+python manage.py clear_cache
+
+# Fetch latest information from monitor and update all licenses
+python manage.py update_licenses
+
+exec gunicorn -w "$GUNICORN_WORKERS" -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:"${PORT:-8000}" --max-requests 1200 --max-requests-jitter 1000 --access-logfile -

apiserver/bin/docker-entrypoint-api.sh

@@ -32,4 +32,4 @@ python manage.py create_bucket
 # Clear Cache before starting to remove stale values
 python manage.py clear_cache
 
-exec gunicorn -w "$GUNICORN_WORKERS" -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:"${PORT:-8000}" --max-requests 1200 --max-requests-jitter 1000 --access-logfile -
+exec gunicorn -w "$GUNICORN_WORKERS" -k uvicorn.workers.UvicornWorker plane.asgi:application --bind 0.0.0.0:"${PORT:-8000}" --max-requests 1200 --max-requests-jitter 1000 --access-logfile -

apiserver/package.json

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

apiserver/plane/api/rate_limit.py

@@ -1,9 +1,13 @@
+# python imports
+import os
+
+# Third party imports
 from rest_framework.throttling import SimpleRateThrottle
 
 
 class ApiKeyRateThrottle(SimpleRateThrottle):
     scope = "api_key"
-    rate = "60/minute"
+    rate = os.environ.get("API_KEY_RATE_LIMIT", "60/minute")
 
     def get_cache_key(self, request, view):
         # Retrieve the API key from the request header

apiserver/plane/api/serializers/__init__.py

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

apiserver/plane/api/serializers/cycle.py

@@ -1,4 +1,5 @@
 # Third party imports
+import pytz
 from rest_framework import serializers
 
 # Module imports
@@ -18,6 +19,14 @@ class CycleSerializer(BaseSerializer):
     completed_estimates = serializers.FloatField(read_only=True)
     started_estimates = serializers.FloatField(read_only=True)
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        project = self.context.get("project")
+        if project and project.timezone:
+            project_timezone = pytz.timezone(project.timezone)
+            self.fields["start_date"].timezone = project_timezone
+            self.fields["end_date"].timezone = project_timezone
+
     def validate(self, data):
         if (
             data.get("start_date", None) is not None
@@ -30,7 +39,15 @@ class CycleSerializer(BaseSerializer):
             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
+            project_id = (
+                self.initial_data.get("project_id") or self.instance.project_id
+                if self.instance and hasattr(self.instance, "project_id")
+                else None
+            )
+
+            if not project_id:
+                raise serializers.ValidationError("Project ID is required")
+
             is_start_date_end_date_equal = (
                 True
                 if str(data.get("start_date")) == str(data.get("end_date"))

apiserver/plane/api/serializers/issue.py

@@ -56,7 +56,7 @@ class IssueSerializer(BaseSerializer):
     class Meta:
         model = Issue
         read_only_fields = ["id", "workspace", "project", "updated_by", "updated_at"]
-        exclude = ["description", "description_stripped"]
+        exclude = ["description"]
 
     def validate(self, data):
         if (
@@ -160,12 +160,15 @@ class IssueSerializer(BaseSerializer):
         else:
             try:
                 # Then assign it to default assignee, if it is a valid assignee
-                if default_assignee_id is not None and ProjectMember.objects.filter(
-                    member_id=default_assignee_id,
-                    project_id=project_id,
-                    role__gte=15,
-                    is_active=True
-                ).exists():
+                if (
+                    default_assignee_id is not None
+                    and ProjectMember.objects.filter(
+                        member_id=default_assignee_id,
+                        project_id=project_id,
+                        role__gte=15,
+                        is_active=True,
+                    ).exists()
+                ):
                     IssueAssignee.objects.create(
                         assignee_id=default_assignee_id,
                         issue=issue,
@@ -402,7 +405,7 @@ class IssueCommentSerializer(BaseSerializer):
             "created_at",
             "updated_at",
         ]
-        exclude = ["comment_stripped", "comment_json"]
+        exclude = ["comment_json"]
 
     def validate(self, data):
         try:

apiserver/plane/api/serializers/issue_type.py

@@ -0,0 +1,42 @@
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from plane.ee.serializers import BaseSerializer
+from plane.db.models import IssueType, ProjectIssueType
+
+
+class IssueTypeAPISerializer(BaseSerializer):
+    project_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
+
+    class Meta:
+        model = IssueType
+        fields = fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "logo_props",
+            "is_default",
+            "level",
+            "deleted_at",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+        ]
+
+
+class ProjectIssueTypeAPISerializer(BaseSerializer):
+    class Meta:
+        model = ProjectIssueType
+        fields = fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "level",
+            "is_default",
+            "deleted_at",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+        ]

apiserver/plane/api/serializers/module.py

@@ -71,9 +71,16 @@ class ModuleSerializer(BaseSerializer):
         module_name = validated_data.get("name")
         if module_name:
             # Lookup for the module name in the module table for that project
-            if Module.objects.filter(name=module_name, project_id=project_id).exists():
+            module = Module.objects.filter(
+                name=module_name, project_id=project_id
+            ).first()
+
+            if module:
                 raise serializers.ValidationError(
-                    {"error": "Module with this name already exists"}
+                    {
+                        "id": str(module.id),
+                        "error": "Module with this name already exists",
+                    }
                 )
 
         module = Module.objects.create(**validated_data, project_id=project_id)

apiserver/plane/api/serializers/project.py

@@ -16,7 +16,6 @@ class ProjectSerializer(BaseSerializer):
     member_role = serializers.IntegerField(read_only=True)
     is_deployed = serializers.BooleanField(read_only=True)
     cover_image_url = serializers.CharField(read_only=True)
-    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
 
     class Meta:
         model = Project

apiserver/plane/api/urls/__init__.py

@@ -5,6 +5,12 @@ from .cycle import urlpatterns as cycle_patterns
 from .module import urlpatterns as module_patterns
 from .intake import urlpatterns as intake_patterns
 from .member import urlpatterns as member_patterns
+from .user import urlpatterns as user_patterns
+from .asset import urlpatterns as asset_patterns
+from .issue_type import urlpatterns as issue_type_patterns
+
+# ee imports
+from plane.ee.urls.api import urlpatterns as ee_api_urls
 
 urlpatterns = [
     *project_patterns,
@@ -12,6 +18,10 @@ urlpatterns = [
     *issue_patterns,
     *cycle_patterns,
     *module_patterns,
+    *user_patterns,
     *intake_patterns,
     *member_patterns,
+    *issue_type_patterns,
+    *asset_patterns,
+    *ee_api_urls,
 ]

apiserver/plane/api/urls/asset.py

@@ -0,0 +1,30 @@
+from django.urls import path
+
+from plane.api.views import (
+    UserAssetEndpoint,
+    UserServerAssetEndpoint,
+    GenericAssetEndpoint
+)
+
+urlpatterns = [
+    path("assets/user-assets/", UserAssetEndpoint.as_view(), name="users"),
+    path(
+        "assets/user-assets/<uuid:asset_id>/", UserAssetEndpoint.as_view(), name="users"
+    ),
+    path("assets/user-assets/server/", UserServerAssetEndpoint.as_view(), name="users"),
+    path(
+        "assets/user-assets/<uuid:asset_id>/server/",
+        UserServerAssetEndpoint.as_view(),
+        name="users",
+    ),
+    path(
+        "workspaces/<str:slug>/assets/",
+        GenericAssetEndpoint.as_view(),
+        name="generic-asset",
+    ),
+    path(
+        "workspaces/<str:slug>/assets/<uuid:asset_id>/",
+        GenericAssetEndpoint.as_view(),
+        name="generic-asset-detail",
+    ),
+]

apiserver/plane/api/urls/intake.py

@@ -4,16 +4,6 @@ from plane.api.views import IntakeIssueAPIEndpoint
 
 
 urlpatterns = [
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:issue_id>/",
-        IntakeIssueAPIEndpoint.as_view(),
-        name="inbox-issue",
-    ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/",
         IntakeIssueAPIEndpoint.as_view(),

apiserver/plane/api/urls/issue.py

@@ -8,6 +8,7 @@ from plane.api.views import (
     IssueActivityAPIEndpoint,
     WorkspaceIssueAPIEndpoint,
     IssueAttachmentEndpoint,
+    IssueAttachmentServerEndpoint,
 )
 
 urlpatterns = [
@@ -76,4 +77,14 @@ urlpatterns = [
         IssueAttachmentEndpoint.as_view(),
         name="issue-attachment",
     ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/server/",
+        IssueAttachmentServerEndpoint.as_view(),
+        name="attachment",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/<uuid:pk>/server/",
+        IssueAttachmentServerEndpoint.as_view(),
+        name="attachment",
+    ),
 ]

apiserver/plane/api/urls/issue_type.py

@@ -0,0 +1,18 @@
+from django.urls import path
+
+from plane.api.views import IssueTypeAPIEndpoint
+
+urlpatterns = [
+    # ======================== issue types start ========================
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-types/",
+        IssueTypeAPIEndpoint.as_view(),
+        name="external-issue-type",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-types/<uuid:type_id>/",
+        IssueTypeAPIEndpoint.as_view(),
+        name="external-issue-type-detail",
+    ),
+    # ======================== issue types end ========================
+]

apiserver/plane/api/urls/member.py

@@ -1,11 +1,16 @@
 from django.urls import path
 
-from plane.api.views import ProjectMemberAPIEndpoint
+from plane.api.views import ProjectMemberAPIEndpoint, WorkspaceMemberAPIEndpoint
 
 urlpatterns = [
     path(
         "workspaces/<str:slug>/projects/<str:project_id>/members/",
         ProjectMemberAPIEndpoint.as_view(),
         name="users",
-    )
+    ),
+    path(
+        "workspaces/<str:slug>/members/",
+        WorkspaceMemberAPIEndpoint.as_view(),
+        name="users",
+    ),
 ]

apiserver/plane/api/urls/user.py

@@ -0,0 +1,5 @@
+from django.urls import path
+
+from plane.api.views import UserEndpoint
+
+urlpatterns = [path("users/me/", UserEndpoint.as_view(), name="users")]

apiserver/plane/api/views/__init__.py

@@ -10,6 +10,7 @@ from .issue import (
     IssueCommentAPIEndpoint,
     IssueActivityAPIEndpoint,
     IssueAttachmentEndpoint,
+    IssueAttachmentServerEndpoint,
 )
 
 from .cycle import (
@@ -25,6 +26,10 @@ from .module import (
     ModuleArchiveUnarchiveAPIEndpoint,
 )
 
-from .member import ProjectMemberAPIEndpoint
+from .member import ProjectMemberAPIEndpoint, WorkspaceMemberAPIEndpoint
+from .user import UserEndpoint
 
+from .asset import UserAssetEndpoint, UserServerAssetEndpoint, GenericAssetEndpoint
+
+from .issue_type import IssueTypeAPIEndpoint
 from .intake import IntakeIssueAPIEndpoint

apiserver/plane/api/views/asset.py

@@ -0,0 +1,414 @@
+# Python Imports
+import uuid
+
+# Django Imports
+from django.utils import timezone
+from django.conf import settings
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module Imports
+from plane.bgtasks.storage_metadata_task import get_asset_object_metadata
+from plane.settings.storage import S3Storage
+from plane.db.models import FileAsset, User, Workspace
+from plane.api.views.base import BaseAPIView
+
+
+class UserAssetEndpoint(BaseAPIView):
+    """This endpoint is used to upload user profile images."""
+
+    def asset_delete(self, asset_id):
+        asset = FileAsset.objects.filter(id=asset_id).first()
+        if asset is None:
+            return
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return
+
+    def entity_asset_delete(self, entity_type, asset, request):
+        # User Avatar
+        if entity_type == FileAsset.EntityTypeContext.USER_AVATAR:
+            user = User.objects.get(id=asset.user_id)
+            user.avatar_asset_id = None
+            user.save()
+            return
+        # User Cover
+        if entity_type == FileAsset.EntityTypeContext.USER_COVER:
+            user = User.objects.get(id=asset.user_id)
+            user.cover_image_asset_id = None
+            user.save()
+            return
+        return
+
+    def post(self, request):
+        # get the asset key
+        name = request.data.get("name")
+        type = request.data.get("type", "image/jpeg")
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+        entity_type = request.data.get("entity_type", False)
+
+        # Check if the file size is within the limit
+        size_limit = min(size, settings.FILE_SIZE_LIMIT)
+
+        #  Check if the entity type is allowed
+        if not entity_type or entity_type not in ["USER_AVATAR", "USER_COVER"]:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file type is allowed
+        allowed_types = [
+            "image/jpeg",
+            "image/png",
+            "image/webp",
+            "image/jpg",
+            "image/gif",
+        ]
+        if type not in allowed_types:
+            return Response(
+                {
+                    "error": "Invalid file type. Only JPEG and PNG files are allowed.",
+                    "status": False,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # asset key
+        asset_key = f"{uuid.uuid4().hex}-{name}"
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            user=request.user,
+            created_by=request.user,
+            entity_type=entity_type,
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(
+            object_name=asset_key, file_type=type, file_size=size_limit
+        )
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    def patch(self, request, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id, user_id=request.user.id)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if not asset.storage_metadata:
+            get_asset_object_metadata.delay(asset_id=str(asset_id))
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save(update_fields=["is_uploaded", "attributes"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, asset_id):
+        asset = FileAsset.objects.get(id=asset_id, user_id=request.user.id)
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        # get the entity and save the asset id for the request field
+        self.entity_asset_delete(
+            entity_type=asset.entity_type, asset=asset, request=request
+        )
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class UserServerAssetEndpoint(BaseAPIView):
+    """This endpoint is used to upload user profile images."""
+
+    def asset_delete(self, asset_id):
+        asset = FileAsset.objects.filter(id=asset_id).first()
+        if asset is None:
+            return
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return
+
+    def entity_asset_delete(self, entity_type, asset, request):
+        # User Avatar
+        if entity_type == FileAsset.EntityTypeContext.USER_AVATAR:
+            user = User.objects.get(id=asset.user_id)
+            user.avatar_asset_id = None
+            user.save()
+            return
+        # User Cover
+        if entity_type == FileAsset.EntityTypeContext.USER_COVER:
+            user = User.objects.get(id=asset.user_id)
+            user.cover_image_asset_id = None
+            user.save()
+            return
+        return
+
+    def post(self, request):
+        # get the asset key
+        name = request.data.get("name")
+        type = request.data.get("type", "image/jpeg")
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+        entity_type = request.data.get("entity_type", False)
+
+        # Check if the file size is within the limit
+        size_limit = min(size, settings.FILE_SIZE_LIMIT)
+
+        #  Check if the entity type is allowed
+        if not entity_type or entity_type not in ["USER_AVATAR", "USER_COVER"]:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file type is allowed
+        allowed_types = [
+            "image/jpeg",
+            "image/png",
+            "image/webp",
+            "image/jpg",
+            "image/gif",
+        ]
+        if type not in allowed_types:
+            return Response(
+                {
+                    "error": "Invalid file type. Only JPEG and PNG files are allowed.",
+                    "status": False,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # asset key
+        asset_key = f"{uuid.uuid4().hex}-{name}"
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            user=request.user,
+            created_by=request.user,
+            entity_type=entity_type,
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request, is_server=True)
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(
+            object_name=asset_key, file_type=type, file_size=size_limit
+        )
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    def patch(self, request, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id, user_id=request.user.id)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if not asset.storage_metadata:
+            get_asset_object_metadata.delay(asset_id=str(asset_id))
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save(update_fields=["is_uploaded", "attributes"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, asset_id):
+        asset = FileAsset.objects.get(id=asset_id, user_id=request.user.id)
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        # get the entity and save the asset id for the request field
+        self.entity_asset_delete(
+            entity_type=asset.entity_type, asset=asset, request=request
+        )
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class GenericAssetEndpoint(BaseAPIView):
+    """This endpoint is used to upload generic assets that can be later bound to entities."""
+
+    def get(self, request, slug, asset_id=None):
+        """Get a presigned URL for an asset"""
+        try:
+            # Get the workspace
+            workspace = Workspace.objects.get(slug=slug)
+
+            # If asset_id is not provided, return 400
+            if not asset_id:
+                return Response(
+                    {"error": "Asset ID is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            # Get the asset
+            asset = FileAsset.objects.get(
+                id=asset_id, workspace_id=workspace.id, is_deleted=False
+            )
+
+            # Check if the asset exists and is uploaded
+            if not asset.is_uploaded:
+                return Response(
+                    {"error": "Asset not yet uploaded"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            size_limit = settings.FILE_SIZE_LIMIT
+
+            # Generate presigned URL for GET
+            storage = S3Storage(request=request, is_server=True)
+            presigned_url = storage.generate_presigned_url(
+                object_name=asset.asset.name, filename=asset.attributes.get("name")
+            )
+
+            return Response(
+                {
+                    "asset_id": str(asset.id),
+                    "asset_url": presigned_url,
+                    "asset_name": asset.attributes.get("name", ""),
+                    "asset_type": asset.attributes.get("type", ""),
+                },
+                status=status.HTTP_200_OK,
+            )
+
+        except Workspace.DoesNotExist:
+            return Response(
+                {"error": "Workspace not found"}, status=status.HTTP_404_NOT_FOUND
+            )
+        except FileAsset.DoesNotExist:
+            return Response(
+                {"error": "Asset not found"}, status=status.HTTP_404_NOT_FOUND
+            )
+        except Exception as e:
+            return Response(
+                {"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def post(self, request, slug):
+        name = request.data.get("name")
+        type = request.data.get("type")
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+        project_id = request.data.get("project_id")
+        external_id = request.data.get("external_id")
+        external_source = request.data.get("external_source")
+
+        # Check if the request is valid
+        if not name or not size:
+            return Response(
+                {"error": "Name and size are required fields.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file size is within the limit
+        size_limit = min(size, settings.FILE_SIZE_LIMIT)
+
+        # Check if the file type is allowed
+        if not type or type not in settings.ATTACHMENT_MIME_TYPES:
+            return Response(
+                {"error": "Invalid file type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the workspace
+        workspace = Workspace.objects.get(slug=slug)
+
+        # asset key
+        asset_key = f"{workspace.id}/{uuid.uuid4().hex}-{name}"
+
+        # Check for existing asset with same external details if provided
+        if external_id and external_source:
+            existing_asset = FileAsset.objects.filter(
+                workspace__slug=slug,
+                external_source=external_source,
+                external_id=external_id,
+                is_deleted=False,
+            ).first()
+
+            if existing_asset:
+                return Response(
+                    {
+                        "message": "Asset with same external id and source already exists",
+                        "asset_id": str(existing_asset.id),
+                        "asset_url": existing_asset.asset_url,
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            workspace_id=workspace.id,
+            project_id=project_id,
+            created_by=request.user,
+            external_id=external_id,
+            external_source=external_source,
+            entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,  # Using ISSUE_ATTACHMENT since we'll bind it to issues
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request, is_server=True)
+        presigned_url = storage.generate_presigned_post(
+            object_name=asset_key,
+            file_type=type,
+            file_size=size_limit
+        )
+
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    def patch(self, request, slug, asset_id):
+        try:
+            asset = FileAsset.objects.get(
+                id=asset_id,
+                workspace__slug=slug,
+                is_deleted=False
+            )
+
+            # Update is_uploaded status
+            asset.is_uploaded = request.data.get("is_uploaded", asset.is_uploaded)
+
+            # Update storage metadata if not present
+            if not asset.storage_metadata:
+                get_asset_object_metadata.delay(asset_id=str(asset_id))
+
+            asset.save(update_fields=["is_uploaded"])
+
+            return Response(
+                status=status.HTTP_204_NO_CONTENT
+            )
+        except FileAsset.DoesNotExist:
+            return Response(
+                {"error": "Asset not found"},
+                status=status.HTTP_404_NOT_FOUND
+            )

apiserver/plane/api/views/cycle.py

@@ -39,7 +39,7 @@ from plane.db.models import (
     UserFavorite,
 )
 from plane.utils.analytics_plot import burndown_plot
-
+from plane.utils.host import base_host
 from .base import BaseAPIView
 from plane.bgtasks.webhook_task import model_activity
 
@@ -137,10 +137,12 @@ class CycleAPIEndpoint(BaseAPIView):
         )
 
     def get(self, request, slug, project_id, pk=None):
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)
         if pk:
             queryset = self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
             data = CycleSerializer(
-                queryset, fields=self.fields, expand=self.expand
+                queryset, fields=self.fields,
+                expand=self.expand, context={"project": project}
             ).data
             return Response(data, status=status.HTTP_200_OK)
         queryset = self.get_queryset().filter(archived_at__isnull=True)
@@ -152,7 +154,8 @@ class CycleAPIEndpoint(BaseAPIView):
                 start_date__lte=timezone.now(), end_date__gte=timezone.now()
             )
             data = CycleSerializer(
-                queryset, many=True, fields=self.fields, expand=self.expand
+                queryset, many=True, fields=self.fields,
+                expand=self.expand, context={"project": project}
             ).data
             return Response(data, status=status.HTTP_200_OK)
 
@@ -163,7 +166,8 @@ class CycleAPIEndpoint(BaseAPIView):
                 request=request,
                 queryset=(queryset),
                 on_results=lambda cycles: CycleSerializer(
-                    cycles, many=True, fields=self.fields, expand=self.expand
+                    cycles, many=True, fields=self.fields,
+                    expand=self.expand, context={"project": project}
                 ).data,
             )
 
@@ -174,7 +178,8 @@ class CycleAPIEndpoint(BaseAPIView):
                 request=request,
                 queryset=(queryset),
                 on_results=lambda cycles: CycleSerializer(
-                    cycles, many=True, fields=self.fields, expand=self.expand
+                    cycles, many=True, fields=self.fields,
+                    expand=self.expand, context={"project": project}
                 ).data,
             )
 
@@ -185,7 +190,8 @@ class CycleAPIEndpoint(BaseAPIView):
                 request=request,
                 queryset=(queryset),
                 on_results=lambda cycles: CycleSerializer(
-                    cycles, many=True, fields=self.fields, expand=self.expand
+                    cycles, many=True, fields=self.fields,
+                    expand=self.expand, context={"project": project}
                 ).data,
             )
 
@@ -198,14 +204,16 @@ class CycleAPIEndpoint(BaseAPIView):
                 request=request,
                 queryset=(queryset),
                 on_results=lambda cycles: CycleSerializer(
-                    cycles, many=True, fields=self.fields, expand=self.expand
+                    cycles, many=True, fields=self.fields,
+                    expand=self.expand, context={"project": project}
                 ).data,
             )
         return self.paginate(
             request=request,
             queryset=(queryset),
             on_results=lambda cycles: CycleSerializer(
-                cycles, many=True, fields=self.fields, expand=self.expand
+                cycles, many=True, fields=self.fields,
+                expand=self.expand, context={"project": project}
             ).data,
         )
 
@@ -251,7 +259,7 @@ class CycleAPIEndpoint(BaseAPIView):
                     current_instance=None,
                     actor_id=request.user.id,
                     slug=slug,
-                    origin=request.META.get("HTTP_ORIGIN"),
+                    origin=base_host(request=request, is_app=True),
                 )
                 return Response(serializer.data, status=status.HTTP_201_CREATED)
             return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -323,7 +331,7 @@ class CycleAPIEndpoint(BaseAPIView):
                 current_instance=current_instance,
                 actor_id=request.user.id,
                 slug=slug,
-                origin=request.META.get("HTTP_ORIGIN"),
+                origin=base_host(request=request, is_app=True),
             )
             return Response(serializer.data, status=status.HTTP_200_OK)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -694,7 +702,7 @@ class CycleIssueAPIEndpoint(BaseAPIView):
             ),
             epoch=int(timezone.now().timestamp()),
             notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
+            origin=base_host(request=request, is_app=True),
         )
         # Return all Cycle Issues
         return Response(
@@ -1168,7 +1176,7 @@ class TransferCycleIssueAPIEndpoint(BaseAPIView):
             ),
             epoch=int(timezone.now().timestamp()),
             notification=True,
-            origin=request.META.get("HTTP_ORIGIN"),
+            origin=base_host(request=request, is_app=True),
         )
 
         return Response({"message": "Success"}, status=status.HTTP_200_OK)

apiserver/plane/api/views/intake.py

@@ -17,8 +17,17 @@ from rest_framework.response import Response
 from plane.api.serializers import IntakeIssueSerializer, IssueSerializer
 from plane.app.permissions import ProjectLitePermission
 from plane.bgtasks.issue_activities_task import issue_activity
-from plane.db.models import Intake, IntakeIssue, Issue, Project, ProjectMember, State
-
+from plane.db.models import (
+    Intake,
+    IntakeIssue,
+    Issue,
+    Project,
+    ProjectMember,
+    State,
+    IssueType,
+)
+from plane.utils.host import base_host
+from plane.ee.models import IntakeSetting
 from .base import BaseAPIView
 
 
@@ -109,6 +118,11 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                 {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
             )
 
+        # Get the issue type
+        issue_type = IssueType.objects.filter(
+            project_issue_types__project_id=project_id, is_epic=False, is_default=True
+        ).first()
+
         # create an issue
         issue = Issue.objects.create(
             name=request.data.get("issue", {}).get("name"),
@@ -118,6 +132,7 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
             ),
             priority=request.data.get("issue", {}).get("priority", "none"),
             project_id=project_id,
+            type=issue_type,
         )
 
         # create an intake issue
@@ -158,6 +173,16 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
+        intake_settings = IntakeSetting.objects.filter(
+            workspace__slug=slug, project_id=project_id, intake=intake
+        ).first()
+
+        if intake_settings is not None and not intake_settings.is_in_app_enabled:
+            return Response(
+                {"error": "Creating intake issues is disabled"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
         # Get the intake issue
         intake_issue = IntakeIssue.objects.get(
             issue_id=issue_id,
@@ -297,7 +322,7 @@ class IntakeIssueAPIEndpoint(BaseAPIView):
                     current_instance=current_instance,
                     epoch=int(timezone.now().timestamp()),
                     notification=False,
-                    origin=request.META.get("HTTP_ORIGIN"),
+                    origin=base_host(request=request, is_app=True),
                     intake=str(intake_issue.id),
                 )
 

apiserver/plane/api/views/issue.py

@@ -56,6 +56,10 @@ from plane.db.models import (
 from plane.settings.storage import S3Storage
 from plane.bgtasks.storage_metadata_task import get_asset_object_metadata
 from .base import BaseAPIView
+from plane.utils.host import base_host
+from plane.payment.flags.flag_decorator import check_workspace_feature_flag
+from plane.payment.flags.flag import FeatureFlag
+from plane.ee.utils.workflow import WorkflowStateManager
 
 
 class WorkspaceIssueAPIEndpoint(BaseAPIView):
@@ -276,6 +280,18 @@ class IssueAPIEndpoint(BaseAPIView):
                 "default_assignee_id": project.default_assignee_id,
             },
         )
+        if request.data.get("state_id"):
+            workflow_state_manager = WorkflowStateManager(
+                project_id=project_id, slug=slug
+            )
+            if workflow_state_manager.validate_issue_creation(
+                state_id=request.data.get("state_id"),
+                user_id=request.user.id,
+            ):
+                return Response(
+                    {"error": "You cannot create a work item in this state"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
 
         if serializer.is_valid():
             if (
@@ -361,6 +377,23 @@ class IssueAPIEndpoint(BaseAPIView):
                     },
                     partial=True,
                 )
+
+                # Check if state is updated then is the transition allowed
+                workflow_state_manager = WorkflowStateManager(
+                    project_id=project_id, slug=slug
+                )
+                if request.data.get(
+                    "state_id"
+                ) and not workflow_state_manager.validate_state_transition(
+                    issue=issue,
+                    new_state_id=request.data.get("state_id"),
+                    user_id=request.user.id,
+                ):
+                    return Response(
+                        {"error": "State transition is not allowed"},
+                        status=status.HTTP_403_FORBIDDEN,
+                    )
+
                 if serializer.is_valid():
                     # If the serializer is valid, save the issue and dispatch
                     # the update issue activity worker event.
@@ -447,6 +480,21 @@ class IssueAPIEndpoint(BaseAPIView):
             context={"project_id": project_id, "workspace_id": project.workspace_id},
             partial=True,
         )
+
+        # Check if state is updated then is the transition allowed
+        workflow_state_manager = WorkflowStateManager(project_id=project_id, slug=slug)
+        if request.data.get(
+            "state_id"
+        ) and not workflow_state_manager.validate_state_transition(
+            issue=issue,
+            new_state_id=request.data.get("state_id"),
+            user_id=request.user.id,
+        ):
+            return Response(
+                {"error": "State transition is not allowed"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
         if serializer.is_valid():
             if (
                 request.data.get("external_id")
@@ -776,12 +824,39 @@ class IssueCommentAPIEndpoint(BaseAPIView):
         )
 
     def get(self, request, slug, project_id, issue_id, pk=None):
+        external_id = request.GET.get("external_id")
+        external_source = request.GET.get("external_source")
+
+        if external_id and external_source:
+            try:
+                issue_comment = IssueComment.objects.get(
+                    external_id=external_id,
+                    external_source=external_source,
+                    workspace__slug=slug,
+                    project_id=project_id,
+                    issue_id=issue_id,
+                )
+                serializer = IssueCommentSerializer(
+                    issue_comment, fields=self.fields, expand=self.expand
+                )
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            except IssueComment.DoesNotExist:
+                return Response(
+                    {"error": "Comment not found"}, status=status.HTTP_404_NOT_FOUND
+                )
+
         if pk:
-            issue_comment = self.get_queryset().get(pk=pk)
-            serializer = IssueCommentSerializer(
-                issue_comment, fields=self.fields, expand=self.expand
-            )
-            return Response(serializer.data, status=status.HTTP_200_OK)
+            try:
+                issue_comment = self.get_queryset().get(pk=pk)
+                serializer = IssueCommentSerializer(
+                    issue_comment, fields=self.fields, expand=self.expand
+                )
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            except IssueComment.DoesNotExist:
+                return Response(
+                    {"error": "Comment not found"}, status=status.HTTP_404_NOT_FOUND
+                )
+
         return self.paginate(
             request=request,
             queryset=(self.get_queryset()),
@@ -827,7 +902,8 @@ class IssueCommentAPIEndpoint(BaseAPIView):
             issue_comment.created_by_id = request.data.get(
                 "created_by", request.user.id
             )
-            issue_comment.save(update_fields=["created_at", "created_by"])
+            issue_comment.actor_id = request.data.get("created_by", request.user.id)
+            issue_comment.save(update_fields=["created_at", "created_by", "actor"])
 
             issue_activity.delay(
                 type="comment.activity.created",
@@ -958,7 +1034,15 @@ class IssueAttachmentEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        size_limit = min(size, settings.FILE_SIZE_LIMIT)
+        # Check if the file size is greater than the limit
+        if check_workspace_feature_flag(
+            feature_key=FeatureFlag.FILE_SIZE_LIMIT_PRO,
+            slug=slug,
+            user_id=str(request.user.id),
+        ):
+            size_limit = min(size, settings.PRO_FILE_SIZE_LIMIT)
+        else:
+            size_limit = min(size, settings.FILE_SIZE_LIMIT)
 
         if not type or type not in settings.ATTACHMENT_MIME_TYPES:
             return Response(
@@ -1031,6 +1115,197 @@ class IssueAttachmentEndpoint(BaseAPIView):
             status=status.HTTP_200_OK,
         )
 
+    def delete(self, request, slug, project_id, issue_id, pk):
+        issue_attachment = FileAsset.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id
+        )
+        issue_attachment.is_deleted = True
+        issue_attachment.deleted_at = timezone.now()
+        issue_attachment.save()
+
+        issue_activity.delay(
+            type="attachment.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+
+        # Get the storage metadata
+        if not issue_attachment.storage_metadata:
+            get_asset_object_metadata.delay(str(issue_attachment.id))
+        issue_attachment.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def get(self, request, slug, project_id, issue_id, pk=None):
+        if pk:
+            # Get the asset
+            asset = FileAsset.objects.get(
+                id=pk, workspace__slug=slug, project_id=project_id
+            )
+
+            # Check if the asset is uploaded
+            if not asset.is_uploaded:
+                return Response(
+                    {"error": "The asset is not uploaded.", "status": False},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            storage = S3Storage(request=request)
+            presigned_url = storage.generate_presigned_url(
+                object_name=asset.asset.name,
+                disposition="attachment",
+                filename=asset.attributes.get("name"),
+            )
+            return HttpResponseRedirect(presigned_url)
+
+        # Get all the attachments
+        issue_attachments = FileAsset.objects.filter(
+            issue_id=issue_id,
+            entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            workspace__slug=slug,
+            project_id=project_id,
+            is_uploaded=True,
+        )
+        # Serialize the attachments
+        serializer = IssueAttachmentSerializer(issue_attachments, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def patch(self, request, slug, project_id, issue_id, pk):
+        issue_attachment = FileAsset.objects.get(
+            pk=pk, workspace__slug=slug, project_id=project_id
+        )
+        serializer = IssueAttachmentSerializer(issue_attachment)
+
+        # Send this activity only if the attachment is not uploaded before
+        if not issue_attachment.is_uploaded:
+            issue_activity.delay(
+                type="attachment.activity.created",
+                requested_data=None,
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id", None)),
+                project_id=str(self.kwargs.get("project_id", None)),
+                current_instance=json.dumps(serializer.data, cls=DjangoJSONEncoder),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+
+            # Update the attachment
+            issue_attachment.is_uploaded = True
+            issue_attachment.created_by = request.user
+
+        # Get the storage metadata
+        if not issue_attachment.storage_metadata:
+            get_asset_object_metadata.delay(str(issue_attachment.id))
+        issue_attachment.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class IssueAttachmentServerEndpoint(BaseAPIView):
+    serializer_class = IssueAttachmentSerializer
+    permission_classes = [ProjectEntityPermission]
+    model = FileAsset
+
+    def post(self, request, slug, project_id, issue_id):
+        name = request.data.get("name")
+        type = request.data.get("type", False)
+        size = request.data.get("size")
+        external_id = request.data.get("external_id")
+        external_source = request.data.get("external_source")
+
+        # Check if the request is valid
+        if not name or not size:
+            return Response(
+                {"error": "Invalid request.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file size is greater than the limit
+        if check_workspace_feature_flag(
+            feature_key=FeatureFlag.FILE_SIZE_LIMIT_PRO,
+            slug=slug,
+            user_id=str(request.user.id),
+        ):
+            size_limit = min(size, settings.PRO_FILE_SIZE_LIMIT)
+        else:
+            size_limit = min(size, settings.FILE_SIZE_LIMIT)
+
+        if not type or type not in settings.ATTACHMENT_MIME_TYPES:
+            return Response(
+                {"error": "Invalid file type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the workspace
+        workspace = Workspace.objects.get(slug=slug)
+
+        # asset key
+        asset_key = f"{workspace.id}/{uuid.uuid4().hex}-{name}"
+
+        if (
+            request.data.get("external_id")
+            and request.data.get("external_source")
+            and FileAsset.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+                external_source=request.data.get("external_source"),
+                external_id=request.data.get("external_id"),
+                issue_id=issue_id,
+                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            ).exists()
+        ):
+            asset = FileAsset.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+                external_source=request.data.get("external_source"),
+                external_id=request.data.get("external_id"),
+                issue_id=issue_id,
+                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            ).first()
+            return Response(
+                {
+                    "error": "Issue with the same external id and external source already exists",
+                    "id": str(asset.id),
+                },
+                status=status.HTTP_409_CONFLICT,
+            )
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            workspace_id=workspace.id,
+            created_by=request.user,
+            issue_id=issue_id,
+            project_id=project_id,
+            entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            external_id=external_id,
+            external_source=external_source,
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request, is_server=True)
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(
+            object_name=asset_key, file_type=type, file_size=size_limit
+        )
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "attachment": IssueAttachmentSerializer(asset).data,
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
     def delete(self, request, slug, project_id, issue_id, pk):
         issue_attachment = FileAsset.objects.get(
             pk=pk, workspace__slug=slug, project_id=project_id

apiserver/plane/api/views/issue_type.py

@@ -0,0 +1,258 @@
+# Python imports
+import random
+
+# Django imports
+from django.db.models import OuterRef, Subquery
+from django.db.models.functions import Coalesce
+from django.contrib.postgres.aggregates import ArrayAgg
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.api.views.base import BaseAPIView
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import Workspace, Project, IssueType, ProjectIssueType
+from plane.api.serializers import IssueTypeAPISerializer, ProjectIssueTypeAPISerializer
+from plane.payment.flags.flag_decorator import check_feature_flag
+from plane.payment.flags.flag import FeatureFlag
+
+
+class IssueTypeAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to issue types.
+
+    """
+
+    logo_icons = [
+        "Activity",
+        "AlertCircle",
+        "Archive",
+        "Bell",
+        "Calendar",
+        "Camera",
+        "Check",
+        "Clock",
+        "Code",
+        "Database",
+        "Download",
+        "Edit",
+        "File",
+        "Folder",
+        "Globe",
+        "Heart",
+        "Home",
+        "Mail",
+        "Search",
+        "User",
+    ]
+
+    logo_backgrounds = [
+        "#EF5974",
+        "#FF7474",
+        "#FC964D",
+        "#1FA191",
+        "#6DBCF5",
+        "#748AFF",
+        "#4C49F8",
+        "#5D407A",
+        "#999AA0",
+    ]
+
+    model = IssueType
+    serializer_class = IssueTypeAPISerializer
+    permission_classes = [ProjectEntityPermission]
+    webhook_event = "issue_type"
+
+    @property
+    def workspace_slug(self):
+        return self.kwargs.get("slug", None)
+
+    @property
+    def project_id(self):
+        return self.kwargs.get("project_id", None)
+
+    @property
+    def type_id(self):
+        return self.kwargs.get("type_id", None)
+
+    def generate_logo_prop(self):
+        return {
+            "in_use": "icon",
+            "icon": {
+                "name": self.logo_icons[random.randint(0, len(self.logo_icons) - 1)],
+                "background_color": self.logo_backgrounds[
+                    random.randint(0, len(self.logo_backgrounds) - 1)
+                ],
+            },
+        }
+
+    # list issue types and get issue type by id
+    @check_feature_flag(FeatureFlag.ISSUE_TYPES)
+    def get(self, request, slug, project_id, type_id=None):
+        if self.workspace_slug and self.project_id:
+            # list of issue types
+            if self.type_id is None:
+                issue_types = self.model.objects.filter(
+                    workspace__slug=self.workspace_slug,
+                    project_issue_types__project_id=self.project_id,
+                    is_epic=False,
+                ).annotate(
+                    project_ids=Coalesce(
+                        Subquery(
+                            ProjectIssueType.objects.filter(
+                                issue_type=OuterRef("pk"), workspace__slug=slug
+                            )
+                            .values("issue_type")
+                            .annotate(project_ids=ArrayAgg("project_id", distinct=True))
+                            .values("project_ids")
+                        ),
+                        [],
+                    )
+                )
+                serializer = self.serializer_class(issue_types, many=True)
+                return Response(serializer.data, status=status.HTTP_200_OK)
+
+            # getting issue type by id
+            issue_type = self.model.objects.get(
+                workspace__slug=self.workspace_slug,
+                project_issue_types__project_id=self.project_id,
+                pk=self.type_id,
+                is_epic=False,
+            )
+            return self.paginate(
+                request=request,
+                queryset=(issue_types),
+                on_results=lambda issues: IssueTypeAPISerializer(
+                    issues, many=True
+                ).data,
+            )
+
+        # getting issue type by id
+        issue_type = self.model.objects.get(
+            workspace__slug=self.workspace_slug,
+            project_issue_types__project_id=self.project_id,
+            pk=self.type_id,
+        )
+        serializer = self.serializer_class(issue_type)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    # create issue type
+    @check_feature_flag(FeatureFlag.ISSUE_TYPES)
+    def post(self, request, slug, project_id):
+        if self.workspace_slug and self.project_id:
+            workspace = Workspace.objects.get(slug=self.workspace_slug)
+            project = Project.objects.get(pk=self.project_id)
+
+            # check if issue type with the same external id and external source already exists
+            external_id = request.data.get("external_id")
+            external_existing_issue_type = self.model.objects.filter(
+                workspace__slug=slug,
+                project_issue_types__project=project_id,
+                external_source=request.data.get("external_source"),
+                external_id=request.data.get("external_id"),
+                is_epic=False,
+            )
+            if (
+                external_id
+                and request.data.get("external_source")
+                and external_existing_issue_type.exists()
+            ):
+                issue_type = self.model.objects.filter(
+                    workspace__slug=slug,
+                    project_issue_types__project=project_id,
+                    external_source=request.data.get("external_source"),
+                    external_id=external_id,
+                    is_epic=False,
+                ).first()
+                return Response(
+                    {
+                        "error": "Work item type with the same external id and external source already exists",
+                        "id": str(issue_type.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
+
+            # creating issue type
+            issue_type_serializer = self.serializer_class(data=request.data)
+            issue_type_serializer.is_valid(raise_exception=True)
+            issue_type_serializer.save(
+                workspace=workspace, logo_props=self.generate_logo_prop()
+            )
+
+            # adding the issue type to the project
+            project_issue_type_serializer = ProjectIssueTypeAPISerializer(
+                data={"issue_type": issue_type_serializer.data["id"]}
+            )
+            project_issue_type_serializer.is_valid(raise_exception=True)
+            project_issue_type_serializer.save(project=project, level=0)
+
+            # getting the issue type
+            issue_type = self.model.objects.get(
+                workspace=workspace,
+                project_issue_types__project=project,
+                pk=issue_type_serializer.data["id"],
+                is_epic=False,
+            )
+            serializer = self.serializer_class(issue_type)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    # update issue type by id
+    @check_feature_flag(FeatureFlag.ISSUE_TYPES)
+    def patch(self, request, slug, project_id, type_id):
+        if self.workspace_slug and self.project_id and self.type_id:
+            issue_type = self.model.objects.get(
+                workspace__slug=self.workspace_slug,
+                project_issue_types__project_id=self.project_id,
+                pk=self.type_id,
+                is_epic=False,
+            )
+
+            data = request.data
+            data_is_active = data.get("is_active", False)
+            update_issue_type = (
+                False if issue_type.is_default and not data_is_active else True
+            )
+
+            if update_issue_type:
+                issue_type_serializer = self.serializer_class(
+                    issue_type, data=data, partial=True
+                )
+                issue_type_serializer.is_valid(raise_exception=True)
+
+                # check if issue type with the same external id and external source already exists
+                external_id = request.data.get("external_id")
+                external_existing_issue_type = self.model.objects.filter(
+                    workspace__slug=slug,
+                    project_issue_types__project_id=self.project_id,
+                    external_source=request.data.get(
+                        "external_source", issue_type.external_source
+                    ),
+                    external_id=external_id,
+                    is_epic=False,
+                )
+                if (
+                    external_id
+                    and (issue_type.external_id != external_id)
+                    and external_existing_issue_type.exists()
+                ):
+                    return Response(
+                        {
+                            "error": "Work item type with the same external id and external source already exists",
+                            "id": str(issue_type.id),
+                        },
+                        status=status.HTTP_409_CONFLICT,
+                    )
+
+                issue_type_serializer.save()
+                return Response(issue_type_serializer.data, status=status.HTTP_200_OK)
+
+    # delete issue type by id
+    @check_feature_flag(FeatureFlag.ISSUE_TYPES)
+    def delete(self, request, slug, project_id, type_id):
+        if self.workspace_slug and self.project_id and self.type_id:
+            issue_type = self.model.objects.get(pk=self.type_id, is_epic=False)
+            issue_type.delete()
+            return Response(status=status.HTTP_204_NO_CONTENT)

apiserver/plane/api/views/member.py

@@ -15,7 +15,35 @@ from .base import BaseAPIView
 from plane.api.serializers import UserLiteSerializer
 from plane.db.models import User, Workspace, Project, WorkspaceMember, ProjectMember
 
-from plane.app.permissions import ProjectMemberPermission
+from plane.app.permissions import ProjectMemberPermission, WorkSpaceAdminPermission
+
+from plane.payment.bgtasks.member_sync_task import member_sync_task
+
+
+class WorkspaceMemberAPIEndpoint(BaseAPIView):
+    permission_classes = [WorkSpaceAdminPermission]
+
+    # Get all the users that are present inside the workspace
+    def get(self, request, slug):
+        # Check if the workspace exists
+        if not Workspace.objects.filter(slug=slug).exists():
+            return Response(
+                {"error": "Provided workspace does not exist"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace_members = WorkspaceMember.objects.filter(
+            workspace__slug=slug
+        ).select_related("member")
+
+        # Get all the users with their roles
+        users_with_roles = []
+        for workspace_member in workspace_members:
+            user_data = UserLiteSerializer(workspace_member.member).data
+            user_data["role"] = workspace_member.role
+            users_with_roles.append(user_data)
+
+        return Response(users_with_roles, status=status.HTTP_200_OK)
 
 
 # API endpoint to get and insert users inside the workspace
@@ -30,7 +58,6 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
                 {"error": "Provided workspace does not exist"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-
         # Get the workspace members that are present inside the workspace
         project_members = ProjectMember.objects.filter(
             project_id=project_id, workspace__slug=slug
@@ -43,10 +70,7 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
 
         return Response(users, status=status.HTTP_200_OK)
 
-    # Insert a new user inside the workspace, and assign the user to the project
     def post(self, request, slug, project_id):
-        # Check if user with email already exists, and send bad request if it's
-        # not present, check for workspace and valid project mandat
         # ------------------- Validation -------------------
         if (
             request.data.get("email") is None
@@ -77,8 +101,8 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        # Check if user exists
         user = User.objects.filter(email=email).first()
+
         workspace_member = None
         project_member = None
 
@@ -109,6 +133,7 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
                 password=make_password(uuid.uuid4().hex),
                 is_password_autoset=True,
                 is_active=False,
+                avatar_asset_id=request.data.get("avatar_asset_id", None),
             )
             user.save()
 
@@ -126,6 +151,9 @@ class ProjectMemberAPIEndpoint(BaseAPIView):
             )
             project_member.save()
 
+        # Run the member sync task for the workspace
+        member_sync_task.delay(workspace.slug)
+
         # Serialize the user and return the response
         user_data = UserLiteSerializer(user).data
 

apiserver/plane/api/views/module.py

@@ -33,6 +33,7 @@ from plane.db.models import (
 
 from .base import BaseAPIView
 from plane.bgtasks.webhook_task import model_activity
+from plane.utils.host import base_host
 
 
 class ModuleAPIEndpoint(BaseAPIView):
@@ -174,7 +175,7 @@ class ModuleAPIEndpoint(BaseAPIView):
                 current_instance=None,
                 actor_id=request.user.id,
                 slug=slug,
-                origin=request.META.get("HTTP_ORIGIN"),
+                origin=base_host(request=request, is_app=True),
             )
             module = Module.objects.get(pk=serializer.data["id"])
             serializer = ModuleSerializer(module)
@@ -226,7 +227,7 @@ class ModuleAPIEndpoint(BaseAPIView):
                 current_instance=current_instance,
                 actor_id=request.user.id,
                 slug=slug,
-                origin=request.META.get("HTTP_ORIGIN"),
+                origin=base_host(request=request, is_app=True),
             )
 
             return Response(serializer.data, status=status.HTTP_200_OK)
@@ -280,6 +281,7 @@ class ModuleAPIEndpoint(BaseAPIView):
             project_id=str(project_id),
             current_instance=json.dumps({"module_name": str(module.name)}),
             epoch=int(timezone.now().timestamp()),
+            origin=base_host(request=request, is_app=True),
         )
         module.delete()
         # Delete the module issues
@@ -449,6 +451,7 @@ class ModuleIssueAPIEndpoint(BaseAPIView):
                 }
             ),
             epoch=int(timezone.now().timestamp()),
+            origin=base_host(request=request, is_app=True),
         )
 
         return Response(

apiserver/plane/api/views/project.py

@@ -30,7 +30,7 @@ from plane.db.models import (
 )
 from plane.bgtasks.webhook_task import model_activity, webhook_activity
 from .base import BaseAPIView
-
+from plane.utils.host import base_host
 
 class ProjectAPIEndpoint(BaseAPIView):
     """Project Endpoints to create, update, list, retrieve and delete endpoint"""
@@ -228,7 +228,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                     current_instance=None,
                     actor_id=request.user.id,
                     slug=slug,
-                    origin=request.META.get("HTTP_ORIGIN"),
+                    origin=base_host(request=request, is_app=True),
                 )
 
                 serializer = ProjectSerializer(project)
@@ -258,9 +258,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                 ProjectSerializer(project).data, cls=DjangoJSONEncoder
             )
 
-            intake_view = request.data.get(
-                "inbox_view", request.data.get("intake_view", project.intake_view)
-            )
+            intake_view = request.data.get("intake_view", project.intake_view)
 
             if project.archived_at:
                 return Response(
@@ -297,7 +295,7 @@ class ProjectAPIEndpoint(BaseAPIView):
                     current_instance=current_instance,
                     actor_id=request.user.id,
                     slug=slug,
-                    origin=request.META.get("HTTP_ORIGIN"),
+                    origin=base_host(request=request, is_app=True),
                 )
 
                 serializer = ProjectSerializer(project)
@@ -334,7 +332,7 @@ class ProjectAPIEndpoint(BaseAPIView):
             new_value=None,
             actor_id=request.user.id,
             slug=slug,
-            current_site=request.META.get("HTTP_ORIGIN"),
+            current_site=base_host(request=request, is_app=True),
             event_id=project.id,
             old_identifier=None,
             new_identifier=None,

apiserver/plane/api/views/user.py

@@ -0,0 +1,17 @@
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.api.serializers import UserLiteSerializer
+from plane.api.views.base import BaseAPIView
+from plane.db.models import User
+
+
+class UserEndpoint(BaseAPIView):
+    serializer_class = UserLiteSerializer
+    model = User
+
+    def get(self, request):
+        serializer = UserLiteSerializer(request.user)
+        return Response(serializer.data, status=status.HTTP_200_OK)

apiserver/plane/app/authentication/session.py

@@ -0,0 +1,7 @@
+from rest_framework.authentication import SessionAuthentication
+
+
+class BaseSessionAuthentication(SessionAuthentication):
+    # Disable csrf for the rest apis
+    def enforce_csrf(self, request):
+        return

apiserver/plane/app/serializers/__init__.py

@@ -1,4 +1,4 @@
-from .base import BaseSerializer
+from .base import BaseSerializer, DynamicBaseSerializer
 from .user import (
     UserSerializer,
     UserLiteSerializer,
@@ -23,6 +23,7 @@ from .workspace import (
     WorkspaceRecentVisitSerializer,
     WorkspaceHomePreferenceSerializer,
     StickySerializer,
+    WorkspaceUserMeSerializer,
 )
 from .project import (
     ProjectSerializer,
@@ -33,7 +34,6 @@ from .project import (
     ProjectIdentifierSerializer,
     ProjectLiteSerializer,
     ProjectMemberLiteSerializer,
-    DeployBoardSerializer,
     ProjectMemberAdminSerializer,
     ProjectPublicMemberSerializer,
     ProjectMemberRoleSerializer,
@@ -45,6 +45,7 @@ from .cycle import (
     CycleIssueSerializer,
     CycleWriteSerializer,
     CycleUserPropertiesSerializer,
+    EntityProgressSerializer,
 )
 from .asset import FileAssetSerializer
 from .issue import (
@@ -128,3 +129,14 @@ from .draft import (
     DraftIssueSerializer,
     DraftIssueDetailSerializer,
 )
+from .integration import (
+    IntegrationSerializer,
+    WorkspaceIntegrationSerializer,
+    GithubIssueSyncSerializer,
+    GithubRepositorySerializer,
+    GithubRepositorySyncSerializer,
+    GithubCommentSyncSerializer,
+    SlackProjectSyncSerializer,
+)
+
+from .deploy_board import DeployBoardSerializer

apiserver/plane/app/serializers/cycle.py

@@ -3,9 +3,11 @@ from rest_framework import serializers
 
 # Module imports
 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
+from plane.ee.models import EntityProgress
 
 
 class CycleWriteSerializer(BaseSerializer):
@@ -45,7 +47,7 @@ class CycleWriteSerializer(BaseSerializer):
     class Meta:
         model = Cycle
         fields = "__all__"
-        read_only_fields = ["workspace", "project", "owned_by", "archived_at"]
+        read_only_fields = ["workspace", "project", "owned_by", "archived_at", "version"]
 
 
 class CycleSerializer(BaseSerializer):
@@ -108,4 +110,10 @@ class CycleUserPropertiesSerializer(BaseSerializer):
     class Meta:
         model = CycleUserProperties
         fields = "__all__"
-        read_only_fields = ["workspace", "project", "cycle" "user"]
+        read_only_fields = ["workspace", "project", "cycle", "user"]
+
+
+class EntityProgressSerializer(BaseSerializer):
+    class Meta:
+        model = EntityProgress
+        fields = "__all__"

apiserver/plane/app/serializers/deploy_board.py

@@ -0,0 +1,15 @@
+# Module imports
+from .base import BaseSerializer
+from plane.app.serializers.project import ProjectLiteSerializer
+from plane.app.serializers.workspace import WorkspaceLiteSerializer
+from plane.db.models import DeployBoard
+
+
+class DeployBoardSerializer(BaseSerializer):
+    project_details = ProjectLiteSerializer(read_only=True, source="project")
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+
+    class Meta:
+        model = DeployBoard
+        fields = "__all__"
+        read_only_fields = ["workspace", "project", "anchor"]

apiserver/plane/app/serializers/draft.py

@@ -12,6 +12,7 @@ from plane.db.models import (
     Label,
     State,
     DraftIssue,
+    IssueType,
     DraftIssueAssignee,
     DraftIssueLabel,
     DraftIssueCycle,
@@ -27,6 +28,9 @@ class DraftIssueCreateSerializer(BaseSerializer):
     parent_id = serializers.PrimaryKeyRelatedField(
         source="parent", queryset=Issue.objects.all(), required=False, allow_null=True
     )
+    type_id = serializers.PrimaryKeyRelatedField(
+        source="type", queryset=IssueType.objects.all(), required=False, allow_null=True
+    )
     label_ids = serializers.ListField(
         child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
         write_only=True,
@@ -76,9 +80,23 @@ class DraftIssueCreateSerializer(BaseSerializer):
         workspace_id = self.context["workspace_id"]
         project_id = self.context["project_id"]
 
+        issue_type = validated_data.pop("type", None)
+
+        if not issue_type:
+            # Get default issue type
+            issue_type = IssueType.objects.filter(
+                project_issue_types__project_id=project_id,
+                is_epic=False,
+                is_default=True,
+            ).first()
+            issue_type = issue_type
+
         # Create Issue
         issue = DraftIssue.objects.create(
-            **validated_data, workspace_id=workspace_id, project_id=project_id
+            **validated_data,
+            workspace_id=workspace_id,
+            project_id=project_id,
+            type=issue_type,
         )
 
         # Issue Audit Users

apiserver/plane/app/serializers/favorite.py

@@ -1,6 +1,7 @@
 from rest_framework import serializers
 
 from plane.db.models import UserFavorite, Cycle, Module, Issue, IssueView, Page, Project
+from plane.ee.models import Dashboard
 
 
 class ProjectFavoriteLiteSerializer(serializers.ModelSerializer):
@@ -41,6 +42,12 @@ class ViewFavoriteSerializer(serializers.ModelSerializer):
         fields = ["id", "name", "logo_props", "project_id"]
 
 
+class DashboardFavoriteLiteSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Dashboard
+        fields = ["id", "name"]
+
+
 def get_entity_model_and_serializer(entity_type):
     entity_map = {
         "cycle": (Cycle, CycleFavoriteLiteSerializer),
@@ -49,10 +56,12 @@ def get_entity_model_and_serializer(entity_type):
         "view": (IssueView, ViewFavoriteSerializer),
         "page": (Page, PageFavoriteLiteSerializer),
         "project": (Project, ProjectFavoriteLiteSerializer),
+        "workspace_dashboard": (Dashboard, DashboardFavoriteLiteSerializer),
         "folder": (None, None),
     }
     return entity_map.get(entity_type, (None, None))
 
+
 class UserFavoriteSerializer(serializers.ModelSerializer):
     entity_data = serializers.SerializerMethodField()
 

apiserver/plane/app/serializers/integration/__init__.py

@@ -0,0 +1,8 @@
+from .base import IntegrationSerializer, WorkspaceIntegrationSerializer
+from .github import (
+    GithubRepositorySerializer,
+    GithubRepositorySyncSerializer,
+    GithubIssueSyncSerializer,
+    GithubCommentSyncSerializer,
+)
+from .slack import SlackProjectSyncSerializer

apiserver/plane/app/serializers/integration/base.py

@@ -0,0 +1,18 @@
+# Module imports
+from plane.app.serializers import BaseSerializer
+from plane.db.models import Integration, WorkspaceIntegration
+
+
+class IntegrationSerializer(BaseSerializer):
+    class Meta:
+        model = Integration
+        fields = "__all__"
+        read_only_fields = ["verified"]
+
+
+class WorkspaceIntegrationSerializer(BaseSerializer):
+    integration_detail = IntegrationSerializer(read_only=True, source="integration")
+
+    class Meta:
+        model = WorkspaceIntegration
+        fields = "__all__"

apiserver/plane/app/serializers/integration/github.py

@@ -0,0 +1,36 @@
+# Module imports
+from plane.app.serializers import BaseSerializer
+from plane.db.models import (
+    GithubIssueSync,
+    GithubRepository,
+    GithubRepositorySync,
+    GithubCommentSync,
+)
+
+
+class GithubRepositorySerializer(BaseSerializer):
+    class Meta:
+        model = GithubRepository
+        fields = "__all__"
+
+
+class GithubRepositorySyncSerializer(BaseSerializer):
+    repo_detail = GithubRepositorySerializer(source="repository")
+
+    class Meta:
+        model = GithubRepositorySync
+        fields = "__all__"
+
+
+class GithubIssueSyncSerializer(BaseSerializer):
+    class Meta:
+        model = GithubIssueSync
+        fields = "__all__"
+        read_only_fields = ["project", "workspace", "repository_sync"]
+
+
+class GithubCommentSyncSerializer(BaseSerializer):
+    class Meta:
+        model = GithubCommentSync
+        fields = "__all__"
+        read_only_fields = ["project", "workspace", "repository_sync", "issue_sync"]

apiserver/plane/app/serializers/integration/slack.py

@@ -0,0 +1,10 @@
+# Module imports
+from plane.app.serializers import BaseSerializer
+from plane.db.models import SlackProjectSync
+
+
+class SlackProjectSyncSerializer(BaseSerializer):
+    class Meta:
+        model = SlackProjectSync
+        fields = "__all__"
+        read_only_fields = ["project", "workspace", "workspace_integration"]

apiserver/plane/app/serializers/issue.py

@@ -37,7 +37,11 @@ from plane.db.models import (
     IssueVersion,
     IssueDescriptionVersion,
     ProjectMember,
+    IssueType,
 )
+from plane.ee.models import Customer
+from plane.payment.flags.flag_decorator import check_workspace_feature_flag
+from plane.payment.flags.flag import FeatureFlag
 
 
 class IssueFlatSerializer(BaseSerializer):
@@ -56,6 +60,7 @@ class IssueFlatSerializer(BaseSerializer):
             "sequence_id",
             "sort_order",
             "is_draft",
+            "type_id",
         ]
 
 
@@ -75,6 +80,9 @@ class IssueCreateSerializer(BaseSerializer):
     state_id = serializers.PrimaryKeyRelatedField(
         source="state", queryset=State.objects.all(), required=False, allow_null=True
     )
+    type_id = serializers.PrimaryKeyRelatedField(
+        source="type", queryset=IssueType.objects.all(), required=False, allow_null=True
+    )
     parent_id = serializers.PrimaryKeyRelatedField(
         source="parent", queryset=Issue.objects.all(), required=False, allow_null=True
     )
@@ -111,25 +119,23 @@ class IssueCreateSerializer(BaseSerializer):
         data["label_ids"] = label_ids if label_ids else []
         return data
 
-    def validate(self, data):
+    def validate(self, attrs):
         if (
-            data.get("start_date", None) is not None
-            and data.get("target_date", None) is not None
-            and data.get("start_date", None) > data.get("target_date", None)
+            attrs.get("start_date", None) is not None
+            and attrs.get("target_date", None) is not None
+            and attrs.get("start_date", None) > attrs.get("target_date", None)
         ):
             raise serializers.ValidationError("Start date cannot exceed target date")
-        return data
 
-    def get_valid_assignees(self, assignees, project_id):
-        if not assignees:
-            return []
+        if attrs.get("assignee_ids", []):
+            attrs["assignee_ids"] = ProjectMember.objects.filter(
+                project_id=self.context["project_id"],
+                role__gte=15,
+                is_active=True,
+                member_id__in=attrs["assignee_ids"],
+            ).values_list("member_id", flat=True)
 
-        return ProjectMember.objects.filter(
-            project_id=project_id,
-            role__gte=15,
-            is_active=True,
-            member_id__in=assignees
-        ).values_list('member_id', flat=True)
+        return attrs
 
     def create(self, validated_data):
         assignees = validated_data.pop("assignee_ids", None)
@@ -139,27 +145,39 @@ class IssueCreateSerializer(BaseSerializer):
         workspace_id = self.context["workspace_id"]
         default_assignee_id = self.context["default_assignee_id"]
 
+        issue_type = validated_data.pop("type", None)
+
+        if not issue_type:
+            # Get default issue type
+            issue_type = IssueType.objects.filter(
+                project_issue_types__project_id=project_id,
+                is_epic=False,
+                is_default=True,
+            ).first()
+            issue_type = issue_type
+
         # Create Issue
-        issue = Issue.objects.create(**validated_data, project_id=project_id)
+        issue = Issue.objects.create(
+            **validated_data, project_id=project_id, type=issue_type
+        )
 
         # Issue Audit Users
         created_by_id = issue.created_by_id
         updated_by_id = issue.updated_by_id
 
-        valid_assignee_ids = self.get_valid_assignees(assignees, project_id)
-        if valid_assignee_ids is not None and len(valid_assignee_ids):
+        if assignees is not None and len(assignees):
             try:
                 IssueAssignee.objects.bulk_create(
                     [
                         IssueAssignee(
-                            assignee_id=user_id,
+                            assignee_id=assignee_id,
                             issue=issue,
                             project_id=project_id,
                             workspace_id=workspace_id,
                             created_by_id=created_by_id,
                             updated_by_id=updated_by_id,
                         )
-                        for user_id in valid_assignee_ids
+                        for assignee_id in assignees
                     ],
                     batch_size=10,
                 )
@@ -167,12 +185,15 @@ class IssueCreateSerializer(BaseSerializer):
                 pass
         else:
             # Then assign it to default assignee, if it is a valid assignee
-            if default_assignee_id is not None and ProjectMember.objects.filter(
-                member_id=default_assignee_id,
-                project_id=project_id,
-                role__gte=15,
-                is_active=True
-            ).exists():
+            if (
+                default_assignee_id is not None
+                and ProjectMember.objects.filter(
+                    member_id=default_assignee_id,
+                    project_id=project_id,
+                    role__gte=15,
+                    is_active=True,
+                ).exists()
+            ):
                 try:
                     IssueAssignee.objects.create(
                         assignee_id=default_assignee_id,
@@ -216,21 +237,20 @@ class IssueCreateSerializer(BaseSerializer):
         created_by_id = instance.created_by_id
         updated_by_id = instance.updated_by_id
 
-        valid_assignee_ids = self.get_valid_assignees(assignees, project_id)
-        if valid_assignee_ids is not None:
+        if assignees is not None:
             IssueAssignee.objects.filter(issue=instance).delete()
             try:
                 IssueAssignee.objects.bulk_create(
                     [
                         IssueAssignee(
-                            assignee_id=user_id,
+                            assignee_id=assignee_id,
                             issue=instance,
                             project_id=project_id,
                             workspace_id=workspace_id,
                             created_by_id=created_by_id,
                             updated_by_id=updated_by_id,
                         )
-                        for user_id in valid_assignee_ids
+                        for assignee_id in assignees
                     ],
                     batch_size=10,
                     ignore_conflicts=True,
@@ -269,6 +289,20 @@ class IssueActivitySerializer(BaseSerializer):
     issue_detail = IssueFlatSerializer(read_only=True, source="issue")
     project_detail = ProjectLiteSerializer(read_only=True, source="project")
     workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+    source_data = serializers.SerializerMethodField()
+
+    def get_source_data(self, obj):
+        if (
+            hasattr(obj, "issue")
+            and hasattr(obj.issue, "source_data")
+            and obj.issue.source_data
+        ):
+            return {
+                "source": obj.issue.source_data[0].source,
+                "source_email": obj.issue.source_data[0].source_email,
+                "extra": obj.issue.source_data[0].extra,
+            }
+        return None
 
     class Meta:
         model = IssueActivity
@@ -319,7 +353,11 @@ class IssueRelationSerializer(BaseSerializer):
         source="related_issue.sequence_id", read_only=True
     )
     name = serializers.CharField(source="related_issue.name", read_only=True)
+    type_id = serializers.UUIDField(source="related_issue.type.id", read_only=True)
     relation_type = serializers.CharField(read_only=True)
+    is_epic = serializers.BooleanField(
+        source="related_issue.type.is_epic", read_only=True
+    )
     state_id = serializers.UUIDField(source="related_issue.state.id", read_only=True)
     priority = serializers.CharField(source="related_issue.priority", read_only=True)
     assignee_ids = serializers.ListField(
@@ -336,6 +374,8 @@ class IssueRelationSerializer(BaseSerializer):
             "sequence_id",
             "relation_type",
             "name",
+            "type_id",
+            "is_epic",
             "state_id",
             "priority",
             "assignee_ids",
@@ -350,7 +390,9 @@ class RelatedIssueSerializer(BaseSerializer):
     )
     sequence_id = serializers.IntegerField(source="issue.sequence_id", read_only=True)
     name = serializers.CharField(source="issue.name", read_only=True)
+    type_id = serializers.UUIDField(source="issue.type.id", read_only=True)
     relation_type = serializers.CharField(read_only=True)
+    is_epic = serializers.BooleanField(source="issue.type.is_epic", read_only=True)
     state_id = serializers.UUIDField(source="issue.state.id", read_only=True)
     priority = serializers.CharField(source="issue.priority", read_only=True)
     assignee_ids = serializers.ListField(
@@ -367,6 +409,8 @@ class RelatedIssueSerializer(BaseSerializer):
             "sequence_id",
             "relation_type",
             "name",
+            "type_id",
+            "is_epic",
             "state_id",
             "priority",
             "assignee_ids",
@@ -640,10 +684,28 @@ class IssueIntakeSerializer(DynamicBaseSerializer):
             "created_at",
             "label_ids",
             "created_by",
+            "type_id",
         ]
         read_only_fields = fields
 
 
+class CustomerSerializer(DynamicBaseSerializer):
+    class Meta:
+        model = Customer
+        fields = [
+            "id",
+            "name",
+            "email",
+            "website_url",
+            "domain",
+            "contract_status",
+            "stage",
+            "employees",
+            "revenue",
+            "created_by",
+        ]
+
+
 class IssueSerializer(DynamicBaseSerializer):
     # ids
     cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
@@ -686,25 +748,52 @@ class IssueSerializer(DynamicBaseSerializer):
             "link_count",
             "is_draft",
             "archived_at",
+            "type_id",
         ]
         read_only_fields = fields
 
 
 class IssueLiteSerializer(DynamicBaseSerializer):
+    is_epic = serializers.SerializerMethodField()
+
+    def get_is_epic(self, obj):
+        if hasattr(obj, "type") and obj.type:
+            return obj.type.is_epic
+        return False
+
     class Meta:
         model = Issue
-        fields = ["id", "sequence_id", "project_id"]
+        fields = ["id", "sequence_id", "project_id", "type_id", "is_epic"]
         read_only_fields = fields
 
 
 class IssueDetailSerializer(IssueSerializer):
     description_html = serializers.CharField()
     is_subscribed = serializers.BooleanField(read_only=True)
+    is_epic = serializers.BooleanField(read_only=True)
 
     class Meta(IssueSerializer.Meta):
-        fields = IssueSerializer.Meta.fields + ["description_html", "is_subscribed"]
+        fields = IssueSerializer.Meta.fields + [
+            "description_html",
+            "is_subscribed",
+            "is_epic",
+        ]
         read_only_fields = fields
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        slug = self.context.get("slug", None)
+        user_id = self.context.get("user_id", None)
+
+        # Check if the user has access to the customer request count
+        if slug and user_id:
+            if check_workspace_feature_flag(
+                feature_key=FeatureFlag.CUSTOMERS, slug=slug, user_id=user_id
+            ):
+                self.fields["customer_request_count"] = serializers.IntegerField(
+                    read_only=True
+                )
+
 
 class IssuePublicSerializer(BaseSerializer):
     project_detail = ProjectLiteSerializer(read_only=True, source="project")

apiserver/plane/app/serializers/page.py

@@ -24,6 +24,7 @@ class PageSerializer(BaseSerializer):
     # Many to many
     label_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
     project_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
+    anchor = serializers.CharField(read_only=True)
 
     class Meta:
         model = Page
@@ -47,8 +48,9 @@ class PageSerializer(BaseSerializer):
             "logo_props",
             "label_ids",
             "project_ids",
+            "anchor",
         ]
-        read_only_fields = ["workspace", "owned_by"]
+        read_only_fields = ["workspace", "owned_by", "anchor"]
 
     def create(self, validated_data):
         labels = validated_data.pop("labels", None)
@@ -120,6 +122,7 @@ class PageSerializer(BaseSerializer):
 
 class PageDetailSerializer(PageSerializer):
     description_html = serializers.CharField()
+    is_favorite = serializers.BooleanField(read_only=True)
 
     class Meta(PageSerializer.Meta):
         fields = PageSerializer.Meta.fields + ["description_html"]

apiserver/plane/app/serializers/project.py

@@ -10,7 +10,6 @@ from plane.db.models import (
     ProjectMember,
     ProjectMemberInvite,
     ProjectIdentifier,
-    DeployBoard,
     ProjectPublicMember,
 )
 
@@ -96,6 +95,12 @@ class ProjectListSerializer(DynamicBaseSerializer):
     anchor = serializers.CharField(read_only=True)
     members = serializers.SerializerMethodField()
     cover_image_url = serializers.CharField(read_only=True)
+    # EE: project_grouping starts
+    state_id = serializers.UUIDField(read_only=True)
+    priority = serializers.CharField(read_only=True)
+    start_date = serializers.DateTimeField(read_only=True)
+    target_date = serializers.DateTimeField(read_only=True)
+    # EE: project_grouping ends
     inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
 
     def get_members(self, obj):
@@ -105,7 +110,7 @@ class ProjectListSerializer(DynamicBaseSerializer):
             return [
                 member.member_id
                 for member in project_members
-                if member.is_active and not member.member.is_bot
+                if member.is_active and (member.member and not member.member.is_bot)
             ]
         return []
 
@@ -179,16 +184,6 @@ class ProjectMemberLiteSerializer(BaseSerializer):
         read_only_fields = fields
 
 
-class DeployBoardSerializer(BaseSerializer):
-    project_details = ProjectLiteSerializer(read_only=True, source="project")
-    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
-
-    class Meta:
-        model = DeployBoard
-        fields = "__all__"
-        read_only_fields = ["workspace", "project", "anchor"]
-
-
 class ProjectPublicMemberSerializer(BaseSerializer):
     class Meta:
         model = ProjectPublicMember

apiserver/plane/app/serializers/view.py

@@ -9,6 +9,7 @@ from plane.utils.issue_filters import issue_filters
 
 class IssueViewSerializer(DynamicBaseSerializer):
     is_favorite = serializers.BooleanField(read_only=True)
+    anchor = serializers.CharField(read_only=True)
 
     class Meta:
         model = IssueView

apiserver/plane/app/serializers/webhook.py

@@ -3,6 +3,9 @@ import socket
 import ipaddress
 from urllib.parse import urlparse
 
+# Django imports
+from django.conf import settings
+
 # Third party imports
 from rest_framework import serializers
 
@@ -45,6 +48,12 @@ class WebhookSerializer(DynamicBaseSerializer):
                     {"url": "URL resolves to a blocked IP address."}
                 )
 
+            # if in cloud environment, private IP addresses are also not allowed
+            if settings.IS_MULTI_TENANT and ip.is_private:
+                raise serializers.ValidationError(
+                    {"url": "URL resolves to a blocked IP address."}
+                )
+
         # Additional validation for multiple request domains and their subdomains
         request = self.context.get("request")
         disallowed_domains = ["plane.so"]  # Add your disallowed domains here
@@ -93,6 +102,12 @@ class WebhookSerializer(DynamicBaseSerializer):
                         {"url": "URL resolves to a blocked IP address."}
                     )
 
+                # if in cloud environment, private IP addresses are also not allowed
+                if settings.IS_MULTI_TENANT and ip.is_private:
+                    raise serializers.ValidationError(
+                        {"url": "URL resolves to a blocked IP address."}
+                    )
+
             # Additional validation for multiple request domains and their subdomains
             request = self.context.get("request")
             disallowed_domains = ["plane.so"]  # Add your disallowed domains here

apiserver/plane/app/serializers/workspace.py

@@ -56,6 +56,31 @@ class WorkSpaceSerializer(DynamicBaseSerializer):
         ]
 
 
+class WorkspaceUserMeSerializer(DynamicBaseSerializer):
+    owner = UserLiteSerializer(read_only=True)
+    total_members = serializers.IntegerField(read_only=True)
+    total_issues = serializers.IntegerField(read_only=True)
+    logo_url = serializers.CharField(read_only=True)
+    current_plan = serializers.CharField(read_only=True)
+    role = serializers.IntegerField(read_only=True)
+    is_on_trial = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = Workspace
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "owner",
+            "logo_url",
+            "role",
+            "is_on_trial",
+        ]
+
+
 class WorkspaceLiteSerializer(BaseSerializer):
     class Meta:
         model = Workspace
@@ -74,6 +99,7 @@ class WorkSpaceMemberSerializer(DynamicBaseSerializer):
 
 class WorkspaceMemberMeSerializer(BaseSerializer):
     draft_issue_count = serializers.IntegerField(read_only=True)
+    active_cycles_count = serializers.IntegerField(read_only=True)
 
     class Meta:
         model = WorkspaceMember
@@ -223,6 +249,18 @@ class ProjectRecentVisitSerializer(serializers.ModelSerializer):
         return members
 
 
+class WorkspacePageRecentVisitSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Page
+        fields = [
+            "id",
+            "name",
+            "logo_props",
+            "owned_by",
+        ]
+
+
 class PageRecentVisitSerializer(serializers.ModelSerializer):
     project_id = serializers.SerializerMethodField()
     project_identifier = serializers.SerializerMethodField()
@@ -256,6 +294,7 @@ def get_entity_model_and_serializer(entity_type):
         "issue": (Issue, IssueRecentVisitSerializer),
         "page": (Page, PageRecentVisitSerializer),
         "project": (Project, ProjectRecentVisitSerializer),
+        "workspace_page": (Page, WorkspacePageRecentVisitSerializer),
     }
     return entity_map.get(entity_type, (None, None))
 

apiserver/plane/app/urls/__init__.py

@@ -18,6 +18,13 @@ from .webhook import urlpatterns as webhook_urls
 from .workspace import urlpatterns as workspace_urls
 from .timezone import urlpatterns as timezone_urls
 
+# Integrations URLS
+from .importer import urlpatterns as importer_urls
+from .integration import urlpatterns as integration_urls
+
+# url patterns
+from plane.ee.urls.app import urlpatterns as ee_urls
+
 urlpatterns = [
     *analytic_urls,
     *asset_urls,
@@ -38,4 +45,8 @@ urlpatterns = [
     *api_urls,
     *webhook_urls,
     *timezone_urls,
+    # ee
+    *integration_urls,
+    *importer_urls,
+    *ee_urls,
 ]

apiserver/plane/app/urls/cycle.py

@@ -99,4 +99,5 @@ urlpatterns = [
         CycleAnalyticsEndpoint.as_view(),
         name="project-cycle",
     ),
+
 ]

apiserver/plane/app/urls/importer.py

@@ -0,0 +1,43 @@
+from django.urls import path
+
+
+from plane.app.views import (
+    ServiceIssueImportSummaryEndpoint,
+    ImportServiceEndpoint,
+    UpdateServiceImportStatusEndpoint,
+    BulkImportIssuesEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/importers/<str:service>/",
+        ServiceIssueImportSummaryEndpoint.as_view(),
+        name="importer-summary",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/importers/<str:service>/",
+        ImportServiceEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/importers/",
+        ImportServiceEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/importers/<str:service>/<uuid:pk>/",
+        ImportServiceEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/service/<str:service>/importers/<uuid:importer_id>/",
+        UpdateServiceImportStatusEndpoint.as_view(),
+        name="importer-status",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-import-issues/<str:service>/",
+        BulkImportIssuesEndpoint.as_view(),
+        name="bulk-import-issues",
+    ),
+]

apiserver/plane/app/urls/intake.py

@@ -1,7 +1,11 @@
 from django.urls import path
 
 
-from plane.app.views import IntakeViewSet, IntakeIssueViewSet
+from plane.app.views import (
+    IntakeViewSet,
+    IntakeIssueViewSet,
+    IntakeWorkItemDescriptionVersionEndpoint,
+)
 
 
 urlpatterns = [
@@ -53,4 +57,14 @@ urlpatterns = [
         ),
         name="inbox-issue",
     ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-work-items/<uuid:work_item_id>/description-versions/",
+        IntakeWorkItemDescriptionVersionEndpoint.as_view(),
+        name="intake-work-item-versions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-work-items/<uuid:work_item_id>/description-versions/<uuid:pk>/",
+        IntakeWorkItemDescriptionVersionEndpoint.as_view(),
+        name="intake-work-item-versions",
+    ),
 ]

apiserver/plane/app/urls/integration.py

@@ -0,0 +1,88 @@
+from django.urls import path
+
+
+from plane.app.views import (
+    IntegrationViewSet,
+    WorkspaceIntegrationViewSet,
+    GithubRepositoriesEndpoint,
+    GithubRepositorySyncViewSet,
+    GithubIssueSyncViewSet,
+    GithubCommentSyncViewSet,
+    BulkCreateGithubIssueSyncEndpoint,
+    SlackProjectSyncViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "integrations/",
+        IntegrationViewSet.as_view({"get": "list", "post": "create"}),
+        name="integrations",
+    ),
+    path(
+        "integrations/<uuid:pk>/",
+        IntegrationViewSet.as_view(
+            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
+        ),
+        name="integrations",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-integrations/",
+        WorkspaceIntegrationViewSet.as_view({"get": "list"}),
+        name="workspace-integrations",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-integrations/<str:provider>/",
+        WorkspaceIntegrationViewSet.as_view({"post": "create"}),
+        name="workspace-integrations",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-integrations/<uuid:pk>/provider/",
+        WorkspaceIntegrationViewSet.as_view({"get": "retrieve", "delete": "destroy"}),
+        name="workspace-integrations",
+    ),
+    # Github Integrations
+    path(
+        "workspaces/<str:slug>/workspace-integrations/<uuid:workspace_integration_id>/github-repositories/",
+        GithubRepositoriesEndpoint.as_view(),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/github-repository-sync/",
+        GithubRepositorySyncViewSet.as_view({"get": "list", "post": "create"}),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/github-repository-sync/<uuid:pk>/",
+        GithubRepositorySyncViewSet.as_view({"get": "retrieve", "delete": "destroy"}),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/",
+        GithubIssueSyncViewSet.as_view({"post": "create", "get": "list"}),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/bulk-create-github-issue-sync/",
+        BulkCreateGithubIssueSyncEndpoint.as_view(),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:pk>/",
+        GithubIssueSyncViewSet.as_view({"get": "retrieve", "delete": "destroy"}),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:issue_sync_id>/github-comment-sync/",
+        GithubCommentSyncViewSet.as_view({"post": "create", "get": "list"}),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/github-repository-sync/<uuid:repo_sync_id>/github-issue-sync/<uuid:issue_sync_id>/github-comment-sync/<uuid:pk>/",
+        GithubCommentSyncViewSet.as_view({"get": "retrieve", "delete": "destroy"}),
+    ),
+    ## End Github Integrations
+    # Slack Integration
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/project-slack-sync/",
+        SlackProjectSyncViewSet.as_view({"post": "create", "get": "list"}),
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/workspace-integrations/<uuid:workspace_integration_id>/project-slack-sync/<uuid:pk>/",
+        SlackProjectSyncViewSet.as_view({"delete": "destroy", "get": "retrieve"}),
+    ),
+    ## End Slack Integration
+]

apiserver/plane/app/urls/issue.py

@@ -18,14 +18,13 @@ from plane.app.views import (
     IssueUserDisplayPropertyEndpoint,
     IssueViewSet,
     LabelViewSet,
-    BulkArchiveIssuesEndpoint,
     DeletedIssuesListViewSet,
     IssuePaginatedViewSet,
     IssueDetailEndpoint,
     IssueAttachmentV2Endpoint,
     IssueBulkUpdateDateEndpoint,
     IssueVersionEndpoint,
-    IssueDescriptionVersionEndpoint,
+    WorkItemDescriptionVersionEndpoint,
     IssueMetaEndpoint,
     IssueDetailIdentifierEndpoint,
 )
@@ -92,11 +91,6 @@ urlpatterns = [
         BulkDeleteIssuesEndpoint.as_view(),
         name="project-issues-bulk",
     ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-archive-issues/",
-        BulkArchiveIssuesEndpoint.as_view(),
-        name="bulk-archive-issues",
-    ),
     ##
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/sub-issues/",
@@ -263,22 +257,22 @@ urlpatterns = [
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/versions/",
         IssueVersionEndpoint.as_view(),
-        name="page-versions",
+        name="issue-versions",
     ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/versions/<uuid:pk>/",
         IssueVersionEndpoint.as_view(),
-        name="page-versions",
+        name="issue-versions",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/description-versions/",
-        IssueDescriptionVersionEndpoint.as_view(),
-        name="page-versions",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/work-items/<uuid:work_item_id>/description-versions/",
+        WorkItemDescriptionVersionEndpoint.as_view(),
+        name="work-item-versions",
     ),
     path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/description-versions/<uuid:pk>/",
-        IssueDescriptionVersionEndpoint.as_view(),
-        name="page-versions",
+        "workspaces/<str:slug>/projects/<uuid:project_id>/work-items/<uuid:work_item_id>/description-versions/<uuid:pk>/",
+        WorkItemDescriptionVersionEndpoint.as_view(),
+        name="work-item-versions",
     ),
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/meta/",

apiserver/plane/app/urls/page.py

@@ -31,6 +31,12 @@ urlpatterns = [
         PageFavoriteViewSet.as_view({"post": "create", "delete": "destroy"}),
         name="user-favorite-pages",
     ),
+    # Lock
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/lock/",
+        PageViewSet.as_view({"post": "lock", "delete": "unlock"}),
+        name="project-page-lock-unlock",
+    ),
     # archived pages
     path(
         "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:pk>/archive/",

apiserver/plane/app/urls/search.py

@@ -1,7 +1,12 @@
 from django.urls import path
 
 
-from plane.app.views import GlobalSearchEndpoint, IssueSearchEndpoint, SearchEndpoint
+from plane.app.views import (
+    GlobalSearchEndpoint,
+    IssueSearchEndpoint,
+    SearchEndpoint,
+    WorkspaceSearchEndpoint,
+)
 
 
 urlpatterns = [
@@ -20,4 +25,9 @@ urlpatterns = [
         SearchEndpoint.as_view(),
         name="entity-search",
     ),
+    path(
+        "workspaces/<str:slug>/app-search/",
+        WorkspaceSearchEndpoint.as_view(),
+        name="app-search",
+    )
 ]

apiserver/plane/app/urls/user.py

@@ -7,6 +7,7 @@ from plane.app.views import (
     UpdateUserTourCompletedEndpoint,
     UserActivityEndpoint,
     UserActivityGraphEndpoint,
+    UserTokenVerificationEndpoint,
     ## User
     UserEndpoint,
     UserIssueCompletedGraphEndpoint,
@@ -55,6 +56,9 @@ urlpatterns = [
     path(
         "users/me/activities/", UserActivityEndpoint.as_view(), name="user-activities"
     ),
+    path(
+        "users/me/verify/", UserTokenVerificationEndpoint.as_view(), name="user-verify"
+    ),
     # user workspaces
     path(
         "users/me/workspaces/", UserWorkSpacesEndpoint.as_view(), name="user-workspace"

apiserver/plane/app/views/__init__.py

@@ -97,7 +97,6 @@ from .cycle.base import (
 )
 from .cycle.issue import CycleIssueViewSet
 from .cycle.archive import CycleArchiveUnarchiveEndpoint
-
 from .asset.base import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
 from .asset.v2 import (
     WorkspaceFileAssetEndpoint,
@@ -122,7 +121,7 @@ from .issue.base import (
 
 from .issue.activity import IssueActivityEndpoint
 
-from .issue.archive import IssueArchiveViewSet, BulkArchiveIssuesEndpoint
+from .issue.archive import IssueArchiveViewSet
 
 from .issue.attachment import (
     IssueAttachmentEndpoint,
@@ -144,7 +143,7 @@ from .issue.sub_issue import SubIssuesEndpoint
 
 from .issue.subscriber import IssueSubscriberViewSet
 
-from .issue.version import IssueVersionEndpoint, IssueDescriptionVersionEndpoint
+from .issue.version import IssueVersionEndpoint, WorkItemDescriptionVersionEndpoint
 
 from .module.base import (
     ModuleViewSet,
@@ -172,6 +171,7 @@ from .page.version import PageVersionEndpoint
 from .search.base import GlobalSearchEndpoint, SearchEndpoint
 from .search.issue import IssueSearchEndpoint
 
+from .search.workspace import WorkspaceSearchEndpoint
 
 from .external.base import (
     GPTIntegrationEndpoint,
@@ -184,7 +184,11 @@ from .estimate.base import (
     EstimatePointEndpoint,
 )
 
-from .intake.base import IntakeViewSet, IntakeIssueViewSet
+from .intake.base import (
+    IntakeViewSet,
+    IntakeIssueViewSet,
+    IntakeWorkItemDescriptionVersionEndpoint,
+)
 
 from .analytic.base import (
     AnalyticsEndpoint,
@@ -212,7 +216,33 @@ from .webhook.base import (
 
 from .error_404 import custom_404_view
 
+from .importer.base import (
+    ServiceIssueImportSummaryEndpoint,
+    ImportServiceEndpoint,
+    UpdateServiceImportStatusEndpoint,
+    BulkImportIssuesEndpoint,
+    BulkImportModulesEndpoint,
+)
+
+from .integration.base import IntegrationViewSet, WorkspaceIntegrationViewSet
+
+from .integration.github import (
+    GithubRepositoriesEndpoint,
+    GithubRepositorySyncViewSet,
+    GithubIssueSyncViewSet,
+    GithubCommentSyncViewSet,
+    BulkCreateGithubIssueSyncEndpoint,
+)
+
+from .integration.slack import SlackProjectSyncViewSet
+
 from .notification.base import MarkAllReadNotificationViewSet
-from .user.base import AccountEndpoint, ProfileEndpoint, UserSessionEndpoint
+
+from .user.base import (
+    AccountEndpoint,
+    ProfileEndpoint,
+    UserSessionEndpoint,
+    UserTokenVerificationEndpoint,
+)
 
 from .timezone.base import TimezoneEndpoint

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

@@ -109,6 +109,7 @@ class AnalyticsEndpoint(BaseAPIView):
                     labels__id__isnull=False,
                     label_issue__deleted_at__isnull=True,
                 )
+                .filter(Q(type__isnull=True) | Q(type__is_epic=False))
                 .distinct("labels__id")
                 .order_by("labels__id")
                 .values("labels__id", "labels__color", "labels__name")

apiserver/plane/app/views/api.py

@@ -1,5 +1,9 @@
 # Python import
 from uuid import uuid4
+from datetime import timedelta
+
+# Django imports
+from django.utils import timezone
 
 # Third party
 from rest_framework.response import Response
@@ -74,7 +78,10 @@ class ServiceApiTokenEndpoint(BaseAPIView):
         workspace = Workspace.objects.get(slug=slug)
 
         api_token = APIToken.objects.filter(
-            workspace=workspace, is_service=True
+            workspace=workspace,
+            is_service=True,
+            user=request.user,
+            expired_at__isnull=True,
         ).first()
 
         if api_token:

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

@@ -2,11 +2,13 @@
 from rest_framework import status
 from rest_framework.response import Response
 from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
+from rest_framework_simplejwt.authentication import JWTAuthentication
 
 # Module imports
 from ..base import BaseAPIView, BaseViewSet
 from plane.db.models import FileAsset, Workspace
 from plane.app.serializers import FileAssetSerializer
+from plane.authentication.session import BaseSessionAuthentication
 
 
 class FileAssetEndpoint(BaseAPIView):
@@ -16,6 +18,8 @@ class FileAssetEndpoint(BaseAPIView):
     A viewset for viewing and editing task instances.
     """
 
+    authentication_classes = [JWTAuthentication, BaseSessionAuthentication]
+
     def get(self, request, workspace_id, asset_key):
         asset_key = str(workspace_id) + "/" + asset_key
         files = FileAsset.objects.filter(asset=asset_key)
@@ -50,6 +54,8 @@ class FileAssetEndpoint(BaseAPIView):
 
 
 class FileAssetViewSet(BaseViewSet):
+    authentication_classes = [JWTAuthentication, BaseSessionAuthentication]
+
     def restore(self, request, workspace_id, asset_key):
         asset_key = str(workspace_id) + "/" + asset_key
         file_asset = FileAsset.objects.get(asset=asset_key)