build: merge frontend and backend into a single repo

apiserver/plane/api/apps.py

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

apiserver/plane/api/permissions/__init__.py

@@ -0,0 +1,2 @@
+from .workspace import WorkSpaceBasePermission, WorkSpaceAdminPermission
+from .project import ProjectBasePermission, ProjectEntityPermission, ProjectMemberPermission

apiserver/plane/api/permissions/project.py

@@ -0,0 +1,63 @@
+# Third Party imports
+from rest_framework.permissions import BasePermission, SAFE_METHODS
+
+# Module import
+from plane.db.models import WorkspaceMember, ProjectMember
+
+
+class ProjectBasePermission(BasePermission):
+    def has_permission(self, request, view):
+
+        if request.user.is_anonymous:
+            return False
+
+        ## Safe Methods -> Handle the filtering logic in queryset
+        if request.method in SAFE_METHODS:
+            return True
+        ## Only workspace owners or admins can create the projects
+        if request.method == "POST":
+            return WorkspaceMember.objects.filter(
+                workspace=view.workspace, member=request.user, role__in=[15, 20]
+            ).exists()
+
+        ## Only Project Admins can update project attributes
+        return ProjectMember.objects.filter(
+            workspace=view.workspace, member=request.user, role=20
+        ).exists()
+
+
+class ProjectMemberPermission(BasePermission):
+    def has_permission(self, request, view):
+
+        if request.user.is_anonymous:
+            return False
+
+        ## Safe Methods -> Handle the filtering logic in queryset
+        if request.method in SAFE_METHODS:
+            return True
+        ## Only workspace owners or admins can create the projects
+        if request.method == "POST":
+            return WorkspaceMember.objects.filter(
+                workspace=view.workspace, member=request.user, role__in=[15, 20]
+            ).exists()
+
+        ## Only Project Admins can update project attributes
+        return ProjectMember.objects.filter(
+            workspace=view.workspace, member=request.user, role__in=[15, 20]
+        ).exists()
+
+
+class ProjectEntityPermission(BasePermission):
+    def has_permission(self, request, view):
+
+        if request.user.is_anonymous:
+            return False
+    
+        ## Safe Methods -> Handle the filtering logic in queryset
+        if request.method in SAFE_METHODS:
+            return True
+        ## Only workspace owners or admins can create the projects
+
+        return ProjectMember.objects.filter(
+            workspace=view.workspace, member=request.user, role__in=[15, 20]
+        ).exists()

apiserver/plane/api/permissions/workspace.py

@@ -0,0 +1,43 @@
+# Third Party imports
+from rest_framework.permissions import BasePermission, SAFE_METHODS
+
+# Module imports
+from plane.db.models import WorkspaceMember, ProjectMember
+
+
+# TODO: Move the below logic to python match - python v3.10
+class WorkSpaceBasePermission(BasePermission):
+    def has_permission(self, request, view):
+        # allow anyone to create a workspace
+        if request.user.is_anonymous:
+            return False
+
+        if request.method == "POST":
+            return True
+
+        ## Safe Methods
+        if request.method in SAFE_METHODS:
+            return True
+
+        # allow only admins and owners to update the workspace settings
+        if request.method in ["PUT", "PATCH"]:
+            return WorkspaceMember.objects.filter(
+                member=request.user, workspace=view.workspace, role__in=[15, 20]
+            ).exists()
+
+        # allow only owner to delete the workspace
+        if request.method == "DELETE":
+            return WorkspaceMember.objects.filter(
+                member=request.user, workspace=view.workspace, role=20
+            ).exists()
+
+
+class WorkSpaceAdminPermission(BasePermission):
+    def has_permission(self, request, view):
+
+        if request.user.is_anonymous:
+            return False
+
+        return WorkspaceMember.objects.filter(
+            member=request.user, workspace=view.workspace, role__in=[15, 20]
+        ).exists()

apiserver/plane/api/serializers/__init__.py

@@ -0,0 +1,40 @@
+from .base import BaseSerializer
+from .people import (
+    ChangePasswordSerializer,
+    ResetPasswordSerializer,
+    TokenSerializer,
+)
+from .user import UserSerializer, UserLiteSerializer
+from .workspace import (
+    WorkSpaceSerializer,
+    WorkSpaceMemberSerializer,
+    TeamSerializer,
+    WorkSpaceMemberInviteSerializer,
+)
+from .project import (
+    ProjectSerializer,
+    ProjectDetailSerializer,
+    ProjectMemberSerializer,
+    ProjectMemberInviteSerializer,
+    ProjectIdentifierSerializer,
+)
+from .state import StateSerializer
+from .shortcut import ShortCutSerializer
+from .view import ViewSerializer
+from .cycle import CycleSerializer, CycleIssueSerializer
+from .asset import FileAssetSerializer
+from .issue import (
+    IssueCreateSerializer,
+    IssueActivitySerializer,
+    IssueCommentSerializer,
+    TimeLineIssueSerializer,
+    IssuePropertySerializer,
+    IssueLabelSerializer,
+    BlockerIssueSerializer,
+    BlockedIssueSerializer,
+    IssueAssigneeSerializer,
+    LabelSerializer,
+    IssueSerializer,
+    IssueFlatSerializer,
+    IssueStateSerializer,
+)

apiserver/plane/api/serializers/asset.py

@@ -0,0 +1,14 @@
+from .base import BaseSerializer
+from plane.db.models import FileAsset
+
+
+class FileAssetSerializer(BaseSerializer):
+    class Meta:
+        model = FileAsset
+        fields = "__all__"
+        read_only_fields = [
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]

apiserver/plane/api/serializers/base.py

@@ -0,0 +1,5 @@
+from rest_framework import serializers
+
+
+class BaseSerializer(serializers.ModelSerializer):
+    id = serializers.PrimaryKeyRelatedField(read_only=True)

apiserver/plane/api/serializers/cycle.py

@@ -0,0 +1,33 @@
+# Module imports
+from .base import BaseSerializer
+from .user import UserLiteSerializer
+from .issue import IssueStateSerializer
+from plane.db.models import Cycle, CycleIssue
+
+
+class CycleSerializer(BaseSerializer):
+
+    owned_by = UserLiteSerializer(read_only=True)
+
+    class Meta:
+        model = Cycle
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "owned_by",
+        ]
+
+
+class CycleIssueSerializer(BaseSerializer):
+
+    issue_details = IssueStateSerializer(read_only=True, source="issue")
+
+    class Meta:
+        model = CycleIssue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "cycle",
+        ]

apiserver/plane/api/serializers/issue.py

@@ -0,0 +1,324 @@
+# Third Party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from .user import UserLiteSerializer
+from .state import StateSerializer
+from .user import UserLiteSerializer
+from .project import ProjectSerializer
+from plane.db.models import (
+    User,
+    Issue,
+    IssueActivity,
+    IssueComment,
+    TimelineIssue,
+    IssueProperty,
+    IssueBlocker,
+    IssueAssignee,
+    IssueLabel,
+    Label,
+    IssueBlocker,
+)
+
+
+class IssueFlatSerializer(BaseSerializer):
+    ## Contain only flat fields
+
+    class Meta:
+        model = Issue
+        fields = [
+            "id",
+            "name",
+            "description",
+            "priority",
+            "start_date",
+            "target_date",
+        ]
+
+
+# Issue Serializer with state details
+class IssueStateSerializer(BaseSerializer):
+
+    state_detail = StateSerializer(read_only=True, source="state")
+
+    class Meta:
+        model = Issue
+        fields = "__all__"
+
+
+##TODO: Find a better way to write this serializer
+## Find a better approach to save manytomany?
+class IssueCreateSerializer(BaseSerializer):
+
+    state_detail = StateSerializer(read_only=True, source="state")
+
+    assignees_list = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
+        write_only=True,
+        required=False,
+    )
+    blockers_list = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=Issue.objects.all()),
+        write_only=True,
+        required=False,
+    )
+    labels_list = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
+        write_only=True,
+        required=False,
+    )
+
+    class Meta:
+        model = Issue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+    def create(self, validated_data):
+        blockers = validated_data.pop("blockers_list", None)
+        assignees = validated_data.pop("assignees_list", None)
+        labels = validated_data.pop("labels_list", None)
+
+        project = self.context["project"]
+        issue = Issue.objects.create(**validated_data, project=project)
+
+        if blockers is not None:
+            IssueBlocker.objects.bulk_create(
+                [
+                    IssueBlocker(
+                        block=issue,
+                        blocked_by=blocker,
+                        project=project,
+                        workspace=project.workspace,
+                        created_by=issue.created_by,
+                        updated_by=issue.updated_by,
+                    )
+                    for blocker in blockers
+                ],
+                batch_size=10,
+            )
+
+        if assignees is not None:
+            IssueAssignee.objects.bulk_create(
+                [
+                    IssueAssignee(
+                        assignee=user,
+                        issue=issue,
+                        project=project,
+                        workspace=project.workspace,
+                        created_by=issue.created_by,
+                        updated_by=issue.updated_by,
+                    )
+                    for user in assignees
+                ],
+                batch_size=10,
+            )
+
+        if labels is not None:
+            IssueLabel.objects.bulk_create(
+                [
+                    IssueLabel(
+                        label=label,
+                        issue=issue,
+                        project=project,
+                        workspace=project.workspace,
+                        created_by=issue.created_by,
+                        updated_by=issue.updated_by,
+                    )
+                    for label in labels
+                ],
+                batch_size=10,
+            )
+
+        return issue
+
+    def update(self, instance, validated_data):
+
+        blockers = validated_data.pop("blockers_list", None)
+        assignees = validated_data.pop("assignees_list", None)
+        labels = validated_data.pop("labels_list", None)
+
+        if blockers is not None:
+            IssueBlocker.objects.filter(block=instance).delete()
+            IssueBlocker.objects.bulk_create(
+                [
+                    IssueBlocker(
+                        block=instance,
+                        blocked_by=blocker,
+                        project=instance.project,
+                        workspace=instance.project.workspace,
+                        created_by=instance.created_by,
+                        updated_by=instance.updated_by,
+                    )
+                    for blocker in blockers
+                ],
+                batch_size=10,
+            )
+
+        if assignees is not None:
+            IssueAssignee.objects.filter(issue=instance).delete()
+            IssueAssignee.objects.bulk_create(
+                [
+                    IssueAssignee(
+                        assignee=user,
+                        issue=instance,
+                        project=instance.project,
+                        workspace=instance.project.workspace,
+                        created_by=instance.created_by,
+                        updated_by=instance.updated_by,
+                    )
+                    for user in assignees
+                ],
+                batch_size=10,
+            )
+
+        if labels is not None:
+            IssueLabel.objects.filter(issue=instance).delete()
+            IssueLabel.objects.bulk_create(
+                [
+                    IssueLabel(
+                        label=label,
+                        issue=instance,
+                        project=instance.project,
+                        workspace=instance.project.workspace,
+                        created_by=instance.created_by,
+                        updated_by=instance.updated_by,
+                    )
+                    for label in labels
+                ],
+                batch_size=10,
+            )
+
+        return super().update(instance, validated_data)
+
+
+class IssueActivitySerializer(BaseSerializer):
+
+    actor_detail = UserLiteSerializer(read_only=True, source="actor")
+
+    class Meta:
+        model = IssueActivity
+        fields = "__all__"
+
+
+class IssueCommentSerializer(BaseSerializer):
+
+    actor_detail = UserLiteSerializer(read_only=True, source="actor")
+
+    class Meta:
+        model = IssueComment
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "issue",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class TimeLineIssueSerializer(BaseSerializer):
+    class Meta:
+        model = TimelineIssue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "issue",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class IssuePropertySerializer(BaseSerializer):
+    class Meta:
+        model = IssueProperty
+        fields = "__all__"
+        read_only_fields = [
+            "user",
+            "workspace",
+            "project",
+        ]
+
+
+class LabelSerializer(BaseSerializer):
+    class Meta:
+        model = Label
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]
+
+
+class IssueLabelSerializer(BaseSerializer):
+
+    # label_details = LabelSerializer(read_only=True, source="label")
+
+    class Meta:
+        model = IssueLabel
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]
+
+
+class BlockedIssueSerializer(BaseSerializer):
+
+    blocked_issue_detail = IssueFlatSerializer(source="block", read_only=True)
+
+    class Meta:
+        model = IssueBlocker
+        fields = "__all__"
+
+
+class BlockerIssueSerializer(BaseSerializer):
+
+    blocker_issue_detail = IssueFlatSerializer(source="blocked_by", read_only=True)
+
+    class Meta:
+        model = IssueBlocker
+        fields = "__all__"
+
+
+class IssueAssigneeSerializer(BaseSerializer):
+
+    assignee_details = UserLiteSerializer(read_only=True, source="assignee")
+
+    class Meta:
+        model = IssueAssignee
+        fields = "__all__"
+
+
+class IssueSerializer(BaseSerializer):
+    project_detail = ProjectSerializer(read_only=True, source="project")
+    state_detail = StateSerializer(read_only=True, source="state")
+    parent_detail = IssueFlatSerializer(read_only=True, source="parent")
+    label_details = LabelSerializer(read_only=True, source="labels", many=True)
+    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
+    blocked_issues = BlockedIssueSerializer(read_only=True, many=True)
+    blocker_issues = BlockerIssueSerializer(read_only=True, many=True)
+
+    class Meta:
+        model = Issue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]

apiserver/plane/api/serializers/people.py

@@ -0,0 +1,57 @@
+from rest_framework.serializers import (
+    ModelSerializer,
+    Serializer,
+    CharField,
+    SerializerMethodField,
+)
+from rest_framework.authtoken.models import Token
+from rest_framework_simplejwt.tokens import RefreshToken
+
+
+from plane.db.models import User
+
+
+class UserSerializer(ModelSerializer):
+    class Meta:
+        model = User
+        fields = "__all__"
+        extra_kwargs = {"password": {"write_only": True}}
+
+
+class ChangePasswordSerializer(Serializer):
+    model = User
+
+    """
+    Serializer for password change endpoint.
+    """
+    old_password = CharField(required=True)
+    new_password = CharField(required=True)
+
+
+class ResetPasswordSerializer(Serializer):
+    model = User
+
+    """
+    Serializer for password change endpoint.
+    """
+    new_password = CharField(required=True)
+    confirm_password = CharField(required=True)
+
+
+class TokenSerializer(ModelSerializer):
+
+    user = UserSerializer()
+    access_token = SerializerMethodField()
+    refresh_token = SerializerMethodField()
+
+    def get_access_token(self, obj):
+        refresh_token = RefreshToken.for_user(obj.user)
+        return str(refresh_token.access_token)
+
+    def get_refresh_token(self, obj):
+        refresh_token = RefreshToken.for_user(obj.user)
+        return str(refresh_token)
+
+    class Meta:
+        model = Token
+        fields = "__all__"

apiserver/plane/api/serializers/project.py

@@ -0,0 +1,104 @@
+# Django imports
+from django.db import IntegrityError
+
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from plane.api.serializers.workspace import WorkSpaceSerializer
+from plane.api.serializers.user import UserLiteSerializer
+from plane.db.models import (
+    Project,
+    ProjectMember,
+    ProjectMemberInvite,
+    ProjectIdentifier,
+)
+
+
+class ProjectSerializer(BaseSerializer):
+    class Meta:
+        model = Project
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+        ]
+
+    def create(self, validated_data):
+        identifier = validated_data.get("identifier", "").strip().upper()
+        if identifier == "":
+            raise serializers.ValidationError(detail="Project Identifier is required")
+
+        if ProjectIdentifier.objects.filter(name=identifier).exists():
+            raise serializers.ValidationError(detail="Project Identifier is taken")
+        project = Project.objects.create(
+            **validated_data, workspace_id=self.context["workspace_id"]
+        )
+        _ = ProjectIdentifier.objects.create(name=project.identifier, project=project)
+        return project
+
+    def update(self, instance, validated_data):
+
+        identifier = validated_data.get("identifier", "").strip().upper()
+
+        # If identifier is not passed update the project and return
+        if identifier == "":
+            project = super().update(instance, validated_data)
+            return project
+
+        # If no Project Identifier is found create it
+        project_identifier = ProjectIdentifier.objects.filter(name=identifier).first()
+
+        if project_identifier is None:
+            project = super().update(instance, validated_data)
+            _ = ProjectIdentifier.objects.update(name=identifier, project=project)
+            return project
+
+        # If found check if the project_id to be updated and identifier project id is same
+        if project_identifier.project_id == instance.id:
+            # If same pass update
+            project = super().update(instance, validated_data)
+            return project
+
+        # If not same fail update
+        raise serializers.ValidationError(
+            detail="Project Identifier is already taken"
+        )
+
+
+class ProjectDetailSerializer(BaseSerializer):
+
+    workspace = WorkSpaceSerializer(read_only=True)
+    default_assignee = UserLiteSerializer(read_only=True)
+    project_lead = UserLiteSerializer(read_only=True)
+
+    class Meta:
+        model = Project
+        fields = "__all__"
+
+
+class ProjectMemberSerializer(BaseSerializer):
+
+    workspace = WorkSpaceSerializer(read_only=True)
+    project = ProjectSerializer(read_only=True)
+    member = UserLiteSerializer(read_only=True)
+
+    class Meta:
+        model = ProjectMember
+        fields = "__all__"
+
+
+class ProjectMemberInviteSerializer(BaseSerializer):
+
+    project = ProjectSerializer(read_only=True)
+    workspace = WorkSpaceSerializer(read_only=True)
+
+    class Meta:
+        model = ProjectMemberInvite
+        fields = "__all__"
+
+
+class ProjectIdentifierSerializer(BaseSerializer):
+    class Meta:
+        model = ProjectIdentifier
+        fields = "__all__"

apiserver/plane/api/serializers/shortcut.py

@@ -0,0 +1,14 @@
+# Module imports
+from .base import BaseSerializer
+
+from plane.db.models import Shortcut
+
+
+class ShortCutSerializer(BaseSerializer):
+    class Meta:
+        model = Shortcut
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]

apiserver/plane/api/serializers/state.py

@@ -0,0 +1,14 @@
+# Module imports
+from .base import BaseSerializer
+
+from plane.db.models import State
+
+
+class StateSerializer(BaseSerializer):
+    class Meta:
+        model = State
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]

apiserver/plane/api/serializers/user.py

@@ -0,0 +1,40 @@
+# Module import
+from .base import BaseSerializer
+from plane.db.models import User
+
+
+class UserSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "is_superuser",
+            "is_staff",
+            "last_active",
+            "last_login_time",
+            "last_logout_time",
+            "last_login_ip",
+            "last_logout_ip",
+            "last_login_uagent",
+            "token_updated_at",
+            "is_onboarded",
+        ]
+        extra_kwargs = {"password": {"write_only": True}}
+
+
+class UserLiteSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "first_name",
+            "last_name",
+            "email",
+            "avatar",
+        ]
+        read_only_fields = [
+            "id",
+        ]

apiserver/plane/api/serializers/view.py

@@ -0,0 +1,14 @@
+# Module imports
+from .base import BaseSerializer
+
+from plane.db.models import View
+
+
+class ViewSerializer(BaseSerializer):
+    class Meta:
+        model = View
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+        ]

apiserver/plane/api/serializers/workspace.py

@@ -0,0 +1,100 @@
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from .user import UserLiteSerializer
+
+from plane.db.models import User, Workspace, WorkspaceMember, Team, TeamMember
+from plane.db.models import Workspace, WorkspaceMember, Team, WorkspaceMemberInvite
+
+
+class WorkSpaceSerializer(BaseSerializer):
+
+    owner = UserLiteSerializer(read_only=True)
+
+    class Meta:
+        model = Workspace
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "slug",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "owner",
+        ]
+        extra_kwargs = {
+            "slug": {
+                "required": False,
+            },
+        }
+
+
+class WorkSpaceMemberSerializer(BaseSerializer):
+
+    member = UserLiteSerializer(read_only=True)
+    workspace = WorkSpaceSerializer(read_only=True)
+
+    class Meta:
+        model = WorkspaceMember
+        fields = "__all__"
+
+
+class WorkSpaceMemberInviteSerializer(BaseSerializer):
+
+    workspace = WorkSpaceSerializer(read_only=True)
+
+    class Meta:
+        model = WorkspaceMemberInvite
+        fields = "__all__"
+
+
+class TeamSerializer(BaseSerializer):
+
+    members_detail = UserLiteSerializer(read_only=True, source="members", many=True)
+    members = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
+        write_only=True,
+        required=False,
+    )
+
+    class Meta:
+        model = Team
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+    def create(self, validated_data, **kwargs):
+        if "members" in validated_data:
+            members = validated_data.pop("members")
+            workspace = self.context["workspace"]
+            team = Team.objects.create(**validated_data, workspace=workspace)
+            team_members = [
+                TeamMember(member=member, team=team, workspace=workspace)
+                for member in members
+            ]
+            TeamMember.objects.bulk_create(team_members, batch_size=10)
+            return team
+        else:
+            team = Team.objects.create(**validated_data)
+            return team
+
+    def update(self, instance, validated_data):
+        if "members" in validated_data:
+            members = validated_data.pop("members")
+            TeamMember.objects.filter(team=instance).delete()
+            team_members = [
+                TeamMember(member=member, team=instance, workspace=instance.workspace)
+                for member in members
+            ]
+            TeamMember.objects.bulk_create(team_members, batch_size=10)
+            return super().update(instance, validated_data)
+        else:
+            return super().update(instance, validated_data)

apiserver/plane/api/urls.py

@@ -0,0 +1,584 @@
+from django.urls import path
+
+
+# Create your urls here.
+
+from plane.api.views import (
+    SignInEndpoint,
+    SignOutEndpoint,
+    MagicSignInEndpoint,
+    MagicSignInGenerateEndpoint,
+    ForgotPasswordEndpoint,
+    PeopleEndpoint,
+    UserEndpoint,
+    VerifyEmailEndpoint,
+    ResetPasswordEndpoint,
+    RequestEmailVerificationEndpoint,
+    OauthEndpoint,
+    ChangePasswordEndpoint,
+)
+
+from plane.api.views import (
+    UserWorkspaceInvitationsEndpoint,
+    WorkSpaceViewSet,
+    UserWorkSpacesEndpoint,
+    InviteWorkspaceEndpoint,
+    JoinWorkspaceEndpoint,
+    WorkSpaceMemberViewSet,
+    WorkspaceInvitationsViewset,
+    UserWorkspaceInvitationsEndpoint,
+    ProjectViewSet,
+    InviteProjectEndpoint,
+    ProjectMemberViewSet,
+    ProjectMemberInvitationsViewset,
+    StateViewSet,
+    ShortCutViewSet,
+    ViewViewSet,
+    CycleViewSet,
+    FileAssetEndpoint,
+    IssueViewSet,
+    UserIssuesEndpoint,
+    WorkSpaceIssuesEndpoint,
+    IssueActivityEndpoint,
+    IssueCommentViewSet,
+    TeamMemberViewSet,
+    TimeLineIssueViewSet,
+    CycleIssueViewSet,
+    IssuePropertyViewSet,
+    UpdateUserOnBoardedEndpoint,
+    UserWorkspaceInvitationEndpoint,
+    UserProjectInvitationsViewset,
+    ProjectIdentifierEndpoint,
+    LabelViewSet,
+    AddMemberToProjectEndpoint,
+    ProjectJoinEndpoint,
+    BulkDeleteIssuesEndpoint,
+    BulkAssignIssuesToCycleEndpoint,
+)
+
+from plane.api.views.project import AddTeamToProjectEndpoint
+
+
+urlpatterns = [
+    #  Social Auth
+    path("social-auth/", OauthEndpoint.as_view(), name="oauth"),
+    # Auth
+    path("sign-in/", SignInEndpoint.as_view(), name="sign-in"),
+    path("sign-out/", SignOutEndpoint.as_view(), name="sign-out"),
+    # Magic Sign In/Up
+    path(
+        "magic-generate/", MagicSignInGenerateEndpoint.as_view(), name="magic-generate"
+    ),
+    path("magic-sign-in/", MagicSignInEndpoint.as_view(), name="magic-sign-in"),
+    # Email verification
+    path("email-verify/", VerifyEmailEndpoint.as_view(), name="email-verify"),
+    path(
+        "request-email-verify/",
+        RequestEmailVerificationEndpoint.as_view(),
+        name="request-reset-email",
+    ),
+    # Password Manipulation
+    path(
+        "password-reset/<uidb64>/<token>/",
+        ResetPasswordEndpoint.as_view(),
+        name="password-reset",
+    ),
+    path(
+        "forgot-password/",
+        ForgotPasswordEndpoint.as_view(),
+        name="forgot-password",
+    ),
+    # List Users
+    path("users/", PeopleEndpoint.as_view()),
+    # User Profile
+    path(
+        "users/me/",
+        UserEndpoint.as_view(
+            {"get": "retrieve", "patch": "partial_update", "delete": "destroy"}
+        ),
+        name="users",
+    ),
+    path(
+        "users/me/change-password/",
+        ChangePasswordEndpoint.as_view(),
+        name="change-password",
+    ),
+    path(
+        "users/me/onboard/",
+        UpdateUserOnBoardedEndpoint.as_view(),
+        name="change-password",
+    ),
+    # user workspaces
+    path(
+        "users/me/workspaces/",
+        UserWorkSpacesEndpoint.as_view(),
+        name="user-workspace",
+    ),
+    # user workspace invitations
+    path(
+        "users/me/invitations/workspaces/",
+        UserWorkspaceInvitationsEndpoint.as_view({"get": "list", "post": "create"}),
+        name="user-workspace-invitations",
+    ),
+    # user workspace invitation
+    path(
+        "users/me/invitations/<uuid:pk>/",
+        UserWorkspaceInvitationEndpoint.as_view(
+            {
+                "get": "retrieve",
+            }
+        ),
+        name="workspace",
+    ),
+    # user join workspace
+    path(
+        "users/me/invitations/workspaces/<str:slug>/<uuid:pk>/join/",
+        JoinWorkspaceEndpoint.as_view(),
+        name="user-join-workspace",
+    ),
+    # user project invitations
+    path(
+        "users/me/invitations/projects/",
+        UserProjectInvitationsViewset.as_view({"get": "list", "post": "create"}),
+        name="user-project-invitaions",
+    ),
+    # user issues
+    path(
+        "users/me/issues/",
+        UserIssuesEndpoint.as_view(),
+        name="user-issues",
+    ),
+    ## Workspaces ##
+    path(
+        "workspaces/",
+        WorkSpaceViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/",
+        WorkSpaceViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/invite/",
+        InviteWorkspaceEndpoint.as_view(),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/invitations/",
+        WorkspaceInvitationsViewset.as_view({"get": "list"}),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/invitations/<uuid:pk>/",
+        WorkspaceInvitationsViewset.as_view(
+            {
+                "delete": "destroy",
+                "get": "retrieve",
+                "get": "retrieve",
+            }
+        ),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/members/",
+        WorkSpaceMemberViewSet.as_view({"get": "list"}),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/members/<uuid:pk>/",
+        WorkSpaceMemberViewSet.as_view(
+            {
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+                "get": "retrieve",
+            }
+        ),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/teams/",
+        TeamMemberViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/teams/<uuid:pk>/",
+        TeamMemberViewSet.as_view(
+            {
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+                "get": "retrieve",
+            }
+        ),
+        name="workspace",
+    ),
+    ## End Workspaces ##
+    # Projects
+    path(
+        "workspaces/<str:slug>/projects/",
+        ProjectViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:pk>/",
+        ProjectViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/project-identifiers/",
+        ProjectIdentifierEndpoint.as_view(),
+        name="project-identifiers",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/invite/",
+        InviteProjectEndpoint.as_view(),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/",
+        ProjectMemberViewSet.as_view({"get": "list"}),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/<uuid:pk>/",
+        ProjectMemberViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/add/",
+        AddMemberToProjectEndpoint.as_view(),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/join/",
+        ProjectJoinEndpoint.as_view(),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/team-invite/",
+        AddTeamToProjectEndpoint.as_view(),
+        name="projects",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/invitations/",
+        ProjectMemberInvitationsViewset.as_view({"get": "list"}),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/invitations/<uuid:pk>/",
+        ProjectMemberInvitationsViewset.as_view(
+            {
+                "get": "retrieve",
+                "delete": "destroy",
+            }
+        ),
+        name="project",
+    ),
+    #  States
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/states/",
+        StateViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-states",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/states/<uuid:pk>/",
+        StateViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-state",
+    ),
+    # End States ##
+    # Shortcuts
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/shortcuts/",
+        ShortCutViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-shortcut",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/shortcuts/<uuid:pk>/",
+        ShortCutViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-shortcut",
+    ),
+    ## End Shortcuts
+    # Views
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/views/",
+        ViewViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-view",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/views/<uuid:pk>/",
+        ViewViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-view",
+    ),
+    ## End Views
+    ## Cycles
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/",
+        CycleViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:pk>/",
+        CycleViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/",
+        CycleIssueViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:pk>/",
+        CycleIssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/bulk-assign-issues/",
+        BulkAssignIssuesToCycleEndpoint.as_view(),
+        name="bulk-assign-cycle-issues",
+    ),
+    ## End Cycles
+    # Issue
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
+        IssueViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/",
+        IssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/issues/",
+        WorkSpaceIssuesEndpoint.as_view(),
+        name="workspace-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/",
+        LabelViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/<uuid:pk>/",
+        LabelViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-delete-issues/",
+        BulkDeleteIssuesEndpoint.as_view(),
+    ),
+    ## End Issues
+    ## Issue Activity
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/history/",
+        IssueActivityEndpoint.as_view(),
+        name="project-issue-history",
+    ),
+    ## Issue Activity
+    ## IssueComments
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/",
+        IssueCommentViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-comment",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/<uuid:pk>/",
+        IssueCommentViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-comment",
+    ),
+    ## End IssueComments
+    ## Roadmap
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/roadmaps/",
+        TimeLineIssueViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-roadmap",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/roadmaps/<uuid:pk>/",
+        TimeLineIssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-roadmap",
+    ),
+    ## End Roadmap
+    ## IssueProperty
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-properties/",
+        IssuePropertyViewSet.as_view(
+            {
+                "get": "list",
+                "post": "create",
+            }
+        ),
+        name="project-issue-roadmap",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-properties/<uuid:pk>/",
+        IssuePropertyViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-roadmap",
+    ),
+    ## IssueProperty Ebd
+    ## File Assets
+    path(
+        "file-assets/",
+        FileAssetEndpoint.as_view(),
+        name="File Assets",
+    ),
+    ## End File Assets
+    # path(
+    #     "issues/<int:pk>/all/",
+    #     IssueViewSet.as_view({"get": "list_issue_history_comments"}),
+    #     name="Issue history and comments",
+    # ),
+]

apiserver/plane/api/views/__init__.py

@@ -0,0 +1,66 @@
+from .project import (
+    ProjectViewSet,
+    ProjectMemberViewSet,
+    UserProjectInvitationsViewset,
+    InviteProjectEndpoint,
+    AddTeamToProjectEndpoint,
+    ProjectMemberInvitationsViewset,
+    ProjectMemberInviteDetailViewSet,
+    ProjectIdentifierEndpoint,
+    AddMemberToProjectEndpoint,
+    ProjectJoinEndpoint,
+)
+from .people import (
+    PeopleEndpoint,
+    UserEndpoint,
+    UpdateUserOnBoardedEndpoint,
+)
+
+from .oauth import OauthEndpoint
+
+from .base import BaseAPIView, BaseViewSet
+
+from .workspace import (
+    WorkSpaceViewSet,
+    UserWorkSpacesEndpoint,
+    WorkSpaceAvailabilityCheckEndpoint,
+    InviteWorkspaceEndpoint,
+    JoinWorkspaceEndpoint,
+    WorkSpaceMemberViewSet,
+    TeamMemberViewSet,
+    WorkspaceInvitationsViewset,
+    UserWorkspaceInvitationsEndpoint,
+    UserWorkspaceInvitationEndpoint,
+)
+from .state import StateViewSet
+from .shortcut import ShortCutViewSet
+from .view import ViewViewSet
+from .cycle import CycleViewSet, CycleIssueViewSet, BulkAssignIssuesToCycleEndpoint
+from .asset import FileAssetEndpoint
+from .issue import (
+    IssueViewSet,
+    UserIssuesEndpoint,
+    WorkSpaceIssuesEndpoint,
+    IssueActivityEndpoint,
+    IssueCommentViewSet,
+    TimeLineIssueViewSet,
+    IssuePropertyViewSet,
+    LabelViewSet,
+    BulkDeleteIssuesEndpoint,
+)
+
+from .auth_extended import (
+    VerifyEmailEndpoint,
+    RequestEmailVerificationEndpoint,
+    ForgotPasswordEndpoint,
+    ResetPasswordEndpoint,
+    ChangePasswordEndpoint,
+)
+
+
+from .authentication import (
+    SignInEndpoint,
+    SignOutEndpoint,
+    MagicSignInEndpoint,
+    MagicSignInGenerateEndpoint,
+)

apiserver/plane/api/views/asset.py

@@ -0,0 +1,30 @@
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.parsers import MultiPartParser, FormParser
+
+# Module imports
+from .base import BaseAPIView
+from plane.db.models import FileAsset
+from plane.api.serializers import FileAssetSerializer
+
+
+class FileAssetEndpoint(BaseAPIView):
+
+    parser_classes = (MultiPartParser, FormParser)
+
+    """
+    A viewset for viewing and editing task instances.
+    """
+
+    def get(self, request):
+        files = FileAsset.objects.all()
+        serializer = FileAssetSerializer(files, context={"request": request}, many=True)
+        return Response(serializer.data)
+
+    def post(self, request, *args, **kwargs):
+        serializer = FileAssetSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/api/views/auth_extended.py

@@ -0,0 +1,159 @@
+## Python imports
+import jwt
+
+## Django imports
+from django.contrib.auth.tokens import PasswordResetTokenGenerator
+from django.utils.encoding import (
+    smart_str,
+    smart_bytes,
+    DjangoUnicodeDecodeError,
+)
+from django.utils.http import urlsafe_base64_decode, urlsafe_base64_encode
+from django.contrib.sites.shortcuts import get_current_site
+from django.conf import settings
+
+## Third Party Imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework import permissions
+from rest_framework_simplejwt.tokens import RefreshToken
+
+from sentry_sdk import capture_exception
+
+## Module imports
+from . import BaseAPIView
+from plane.api.serializers.people import (
+    ChangePasswordSerializer,
+    ResetPasswordSerializer,
+)
+from plane.db.models import User
+from plane.bgtasks.email_verification_task import email_verification
+from plane.bgtasks.forgot_password_task import forgot_password
+
+
+class RequestEmailVerificationEndpoint(BaseAPIView):
+    def get(self, request):
+        token = RefreshToken.for_user(request.user).access_token
+        current_site = settings.WEB_URL
+        email_verification.delay(
+            request.user.first_name, request.user.email, token, current_site
+        )
+        return Response(
+            {"message": "Email sent successfully"}, status=status.HTTP_200_OK
+        )
+
+
+class VerifyEmailEndpoint(BaseAPIView):
+    def get(self, request):
+        token = request.GET.get("token")
+        try:
+            payload = jwt.decode(token, settings.SECRET_KEY, algorithms="HS256")
+            user = User.objects.get(id=payload["user_id"])
+
+            if not user.is_email_verified:
+                user.is_email_verified = True
+                user.save()
+            return Response(
+                {"email": "Successfully activated"}, status=status.HTTP_200_OK
+            )
+        except jwt.ExpiredSignatureError as indentifier:
+            return Response(
+                {"email": "Activation expired"}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except jwt.exceptions.DecodeError as indentifier:
+            return Response(
+                {"email": "Invalid token"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+
+class ForgotPasswordEndpoint(BaseAPIView):
+    permission_classes = [permissions.AllowAny]
+
+    def post(self, request):
+        email = request.data.get("email")
+
+        if User.objects.filter(email=email).exists():
+            user = User.objects.get(email=email)
+            uidb64 = urlsafe_base64_encode(smart_bytes(user.id))
+            token = PasswordResetTokenGenerator().make_token(user)
+
+            current_site = settings.WEB_URL
+
+            forgot_password.delay(
+                user.first_name, user.email, uidb64, token, current_site
+            )
+
+            return Response(
+                {"messgae": "Check your email to reset your password"},
+                status=status.HTTP_200_OK,
+            )
+        return Response(
+            {"error": "Please check the email"}, status=status.HTTP_400_BAD_REQUEST
+        )
+
+
+class ResetPasswordEndpoint(BaseAPIView):
+    permission_classes = [permissions.AllowAny]
+
+    def post(self, request, uidb64, token):
+        try:
+            id = smart_str(urlsafe_base64_decode(uidb64))
+            user = User.objects.get(id=id)
+            if not PasswordResetTokenGenerator().check_token(user, token):
+                return Response(
+                    {"error": "token is not valid, please check the new one"},
+                    status=status.HTTP_401_UNAUTHORIZED,
+                )
+            serializer = ResetPasswordSerializer(data=request.data)
+
+            if serializer.is_valid():
+                # set_password also hashes the password that the user will get
+                user.set_password(serializer.data.get("new_password"))
+                user.save()
+                response = {
+                    "status": "success",
+                    "code": status.HTTP_200_OK,
+                    "message": "Password updated successfully",
+                }
+
+                return Response(response)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+        except DjangoUnicodeDecodeError as indentifier:
+            return Response(
+                {"error": "token is not valid, please check the new one"},
+                status=status.HTTP_401_UNAUTHORIZED,
+            )
+
+
+class ChangePasswordEndpoint(BaseAPIView):
+    def post(self, request):
+        try:
+            serializer = ChangePasswordSerializer(data=request.data)
+
+            user = User.objects.get(pk=request.user.id)
+            if serializer.is_valid():
+                # Check old password
+                if not user.object.check_password(serializer.data.get("old_password")):
+                    return Response(
+                        {"old_password": ["Wrong password."]},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+                # set_password also hashes the password that the user will get
+                self.object.set_password(serializer.data.get("new_password"))
+                self.object.save()
+                response = {
+                    "status": "success",
+                    "code": status.HTTP_200_OK,
+                    "message": "Password updated successfully",
+                }
+
+                return Response(response)
+
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

apiserver/plane/api/views/authentication.py

@@ -0,0 +1,299 @@
+# Python imports
+import uuid
+import random
+import string
+import json
+
+# Django imports
+from django.utils import timezone
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_email
+from django.conf import settings
+
+# Third party imports
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+from rest_framework import status
+from rest_framework_simplejwt.tokens import RefreshToken
+
+from sentry_sdk import capture_exception, capture_message
+
+# Module imports
+from . import BaseAPIView
+from plane.db.models import User
+from plane.api.serializers import UserSerializer
+from plane.settings.redis import redis_instance
+from plane.bgtasks.magic_link_code_task import magic_link
+
+
+def get_tokens_for_user(user):
+    refresh = RefreshToken.for_user(user)
+    return (
+        str(refresh.access_token),
+        str(refresh),
+    )
+
+
+class SignInEndpoint(BaseAPIView):
+    permission_classes = (AllowAny,)
+
+    def post(self, request):
+        try:
+            email = request.data.get("email", False)
+            password = request.data.get("password", False)
+
+            ## Raise exception if any of the above are missing
+            if not email or not password:
+                return Response(
+                    {"error": "Both email and password are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            email = email.strip().lower()
+
+            try:
+                validate_email(email)
+            except ValidationError as e:
+                return Response(
+                    {"error": "Please provide a valid email address."},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            user = User.objects.get(email=email)
+
+            if not user.check_password(password):
+                return Response(
+                    {
+                        "error": "Sorry, we could not find a user with the provided credentials. Please try again."
+                    },
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+            if not user.is_active:
+                return Response(
+                    {
+                        "error": "Your account has been deactivated. Please contact your site administrator."
+                    },
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
+            serialized_user = UserSerializer(user).data
+
+            # settings last active for the user
+            user.last_active = timezone.now()
+            user.last_login_time = timezone.now()
+            user.last_login_ip = request.META.get("REMOTE_ADDR")
+            user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
+            user.token_updated_at = timezone.now()
+            user.save()
+
+            access_token, refresh_token = get_tokens_for_user(user)
+
+            data = {
+                "access_token": access_token,
+                "refresh_token": refresh_token,
+                "user": serialized_user,
+            }
+
+            return Response(data, status=status.HTTP_200_OK)
+
+        except User.DoesNotExist:
+            return Response(
+                {
+                    "error": "Sorry, we could not find a user with the provided credentials. Please try again."
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
+        except Exception as e:
+            print(e)
+            capture_exception(e)
+            return Response(
+                {
+                    "error": "Something went wrong. Please try again later or contact the support team."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+
+class SignOutEndpoint(BaseAPIView):
+    def post(self, request):
+        try:
+            refresh_token = request.data.get("refresh_token", False)
+
+            if not refresh_token:
+                capture_message("No refresh token provided")
+                return Response(
+                    {
+                        "error": "Something went wrong. Please try again later or contact the support team."
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            user = User.objects.get(pk=request.user.id)
+
+            user.last_logout_time = timezone.now()
+            user.last_logout_ip = request.META.get("REMOTE_ADDR")
+
+            user.save()
+
+            token = RefreshToken(refresh_token)
+            token.blacklist()
+            return Response({"message": "success"}, status=status.HTTP_200_OK)
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {
+                    "error": "Something went wrong. Please try again later or contact the support team."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+
+class MagicSignInGenerateEndpoint(BaseAPIView):
+
+    permission_classes = [
+        AllowAny,
+    ]
+
+    def post(self, request):
+        try:
+
+            email = request.data.get("email", False)
+
+            if not email:
+                return Response(
+                    {"error": "Please provide a valid email address"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            validate_email(email)
+
+            ## Generate a random token
+            token = (
+                "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
+                + "-"
+                + "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
+                + "-"
+                + "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
+            )
+
+            ri = redis_instance()
+
+            key = "magic_" + str(email)
+
+            # Check if the key already exists in python
+            if ri.exists(key):
+                data = json.loads(ri.get(key))
+
+                current_attempt = data["current_attempt"] + 1
+
+                if data["current_attempt"] > 2:
+                    return Response(
+                        {"error": "Max attempts exhausted. Please try again later."},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+                value = {
+                    "current_attempt": current_attempt,
+                    "email": email,
+                    "token": token,
+                }
+                expiry = 600
+
+                ri.set(key, json.dumps(value), ex=expiry)
+
+            else:
+
+                value = {"current_attempt": 0, "email": email, "token": token}
+                expiry = 600
+
+                ri.set(key, json.dumps(value), ex=expiry)
+
+            current_site = settings.WEB_URL
+            magic_link.delay(email, key, token, current_site)
+
+            return Response({"key": key}, status=status.HTTP_200_OK)
+        except ValidationError:
+            return Response(
+                {"error": "Please provide a valid email address."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        except Exception as e:
+            print(e)
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class MagicSignInEndpoint(BaseAPIView):
+
+    permission_classes = [
+        AllowAny,
+    ]
+
+    def post(self, request):
+        try:
+
+            user_token = request.data.get("token", "").strip().lower()
+            key = request.data.get("key", False)
+
+            if not key or user_token == "":
+                return Response(
+                    {"error": "User token and key are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            ri = redis_instance()
+
+            if ri.exists(key):
+
+                data = json.loads(ri.get(key))
+
+                token = data["token"]
+                email = data["email"]
+
+                if str(token) == str(user_token):
+
+                    if User.objects.filter(email=email).exists():
+                        user = User.objects.get(email=email)
+                    else:
+                        user = User.objects.create(
+                            email=email, username=uuid.uuid4().hex
+                        )
+
+                    user.last_active = timezone.now()
+                    user.last_login_time = timezone.now()
+                    user.last_login_ip = request.META.get("REMOTE_ADDR")
+                    user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
+                    user.token_updated_at = timezone.now()
+                    user.save()
+                    serialized_user = UserSerializer(user).data
+
+                    access_token, refresh_token = get_tokens_for_user(user)
+                    data = {
+                        "access_token": access_token,
+                        "refresh_token": refresh_token,
+                        "user": serialized_user,
+                    }
+
+                    return Response(data, status=status.HTTP_200_OK)
+
+                else:
+                    return Response(
+                        {"error": "Your login code was incorrect. Please try again."},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+            else:
+                return Response(
+                    {"error": "The magic code/link has expired please try again"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

apiserver/plane/api/views/base.py

@@ -0,0 +1,142 @@
+# Django imports
+from django.urls import resolve
+from django.conf import settings
+# Third part imports
+from rest_framework import status
+from rest_framework.viewsets import ModelViewSet
+from rest_framework.exceptions import APIException
+from rest_framework.views import APIView
+from rest_framework.filters import SearchFilter
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.exceptions import NotFound
+
+from django_filters.rest_framework import DjangoFilterBackend
+
+# Module imports
+from plane.db.models import Workspace, Project
+from plane.utils.paginator import BasePaginator
+
+
+class BaseViewSet(ModelViewSet, BasePaginator):
+
+    model = None
+
+    permission_classes = [
+        IsAuthenticated,
+    ]
+
+    filter_backends = (
+        DjangoFilterBackend,
+        SearchFilter,
+    )
+
+    filterset_fields = []
+
+    search_fields = []
+
+    def get_queryset(self):
+        try:
+            return self.model.objects.all()
+        except Exception as e:
+            print(e)
+            raise APIException(
+                "Please check the view", status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def dispatch(self, request, *args, **kwargs):
+        response = super().dispatch(request, *args, **kwargs)
+
+        if settings.DEBUG:
+            from django.db import connection
+            print(f'# of Queries: {len(connection.queries)}')
+        return response
+
+    @property
+    def workspace_slug(self):
+        return self.kwargs.get("slug", None)
+
+    @property
+    def workspace(self):
+        if self.workspace_slug:
+            try:
+                return Workspace.objects.get(slug=self.workspace_slug)
+            except Workspace.DoesNotExist:
+                raise NotFound(detail="Workspace does not exist")
+        else:
+            return None
+
+    @property
+    def project_id(self):
+        project_id = self.kwargs.get("project_id", None)
+        if project_id:
+            return project_id
+
+        if resolve(self.request.path_info).url_name == "project":
+            return self.kwargs.get("pk", None)
+
+    @property
+    def project(self):
+        if self.project_id:
+            try:
+                return Project.objects.get(pk=self.project_id)
+            except Project.DoesNotExist:
+                raise NotFound(detail="Project does not exist")
+        else:
+            return None
+
+
+class BaseAPIView(APIView, BasePaginator):
+
+    permission_classes = [
+        IsAuthenticated,
+    ]
+
+    filter_backends = (
+        DjangoFilterBackend,
+        SearchFilter,
+    )
+
+    filterset_fields = []
+
+    search_fields = []
+
+    def filter_queryset(self, queryset):
+        for backend in list(self.filter_backends):
+            queryset = backend().filter_queryset(self.request, queryset, self)
+        return queryset
+
+    def dispatch(self, request, *args, **kwargs):
+        response = super().dispatch(request, *args, **kwargs)
+
+        if settings.DEBUG:
+            from django.db import connection
+            print(f'# of Queries: {len(connection.queries)}')
+        return response
+
+    @property
+    def workspace_slug(self):
+        return self.kwargs.get("slug", None)
+
+    @property
+    def workspace(self):
+        if self.workspace_slug:
+            try:
+                return Workspace.objects.get(slug=self.workspace_slug)
+            except Workspace.DoesNotExist:
+                raise NotFound(detail="Workspace does not exist")
+        else:
+            return None
+
+    @property
+    def project_id(self):
+        return self.kwargs.get("project_id", None)
+
+    @property
+    def project(self):
+        if self.project_id:
+            try:
+                return Project.objects.get(pk=self.project_id)
+            except Project.DoesNotExist:
+                raise NotFound(detail="Project does not exist")
+        else:
+            return None

apiserver/plane/api/views/cycle.py

@@ -0,0 +1,109 @@
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from . import BaseViewSet, BaseAPIView
+from plane.api.serializers import CycleSerializer, CycleIssueSerializer
+from plane.api.permissions import ProjectEntityPermission
+from plane.db.models import Cycle, CycleIssue, Issue
+
+
+class CycleViewSet(BaseViewSet):
+
+    serializer_class = CycleSerializer
+    model = Cycle
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"), owned_by=self.request.user
+        )
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .distinct()
+        )
+
+
+class CycleIssueViewSet(BaseViewSet):
+
+    serializer_class = CycleIssueSerializer
+    model = CycleIssue
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+            cycle_id=self.kwargs.get("cycle_id"),
+        )
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .filter(cycle_id=self.kwargs.get("cycle_id"))
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("cycle")
+            .select_related("issue")
+            .select_related("issue__state")
+            .distinct()
+        )
+
+
+class BulkAssignIssuesToCycleEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def post(self, request, slug, project_id, cycle_id):
+        try:
+
+            issue_ids = request.data.get("issue_ids")
+
+            cycle = Cycle.objects.get(
+                workspace__slug=slug, project_id=project_id, pk=cycle_id
+            )
+
+            issues = Issue.objects.filter(
+                pk__in=issue_ids, workspace__slug=slug, project_id=project_id
+            )
+
+            CycleIssue.objects.bulk_create(
+                [
+                    CycleIssue(
+                        project_id=project_id,
+                        workspace=cycle.workspace,
+                        created_by=request.user,
+                        updated_by=request.user,
+                        cycle=cycle,
+                        issue=issue,
+                    )
+                    for issue in issues
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
+            )
+            return Response({"message": "Success"}, status=status.HTTP_200_OK)
+
+        except Cycle.DoesNotExist:
+            return Response(
+                {"error": "Cycle not found"}, status=status.HTTP_404_NOT_FOUND
+            )

apiserver/plane/api/views/issue.py

@@ -0,0 +1,394 @@
+# Python imports
+from itertools import groupby
+
+# Django imports
+from django.db.models import Prefetch
+from django.db.models import Count, Sum
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+from sentry_sdk import capture_exception
+
+# Module imports
+from . import BaseViewSet, BaseAPIView
+from plane.api.serializers import (
+    IssueCreateSerializer,
+    IssueActivitySerializer,
+    IssueCommentSerializer,
+    TimeLineIssueSerializer,
+    IssuePropertySerializer,
+    LabelSerializer,
+    IssueSerializer,
+    LabelSerializer,
+)
+from plane.api.permissions import (
+    ProjectEntityPermission,
+    WorkSpaceAdminPermission,
+    ProjectMemberPermission,
+)
+from plane.db.models import (
+    Project,
+    Issue,
+    IssueActivity,
+    IssueComment,
+    TimelineIssue,
+    IssueProperty,
+    Label,
+    IssueBlocker,
+)
+
+
+class IssueViewSet(BaseViewSet):
+    def get_serializer_class(self):
+        return (
+            IssueCreateSerializer
+            if self.action in ["create", "update", "partial_update"]
+            else IssueSerializer
+        )
+
+    model = Issue
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    search_fields = [
+        "name",
+    ]
+
+    filterset_fields = [
+        "state__name",
+        "assignees__id",
+        "workspace__id",
+    ]
+
+    def perform_create(self, serializer):
+        serializer.save(project_id=self.kwargs.get("project_id"))
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("state")
+            .select_related("parent")
+            .prefetch_related("assignees")
+            .prefetch_related("labels")
+            .prefetch_related(
+                Prefetch(
+                    "blocked_issues",
+                    queryset=IssueBlocker.objects.select_related("blocked_by", "block"),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "blocker_issues",
+                    queryset=IssueBlocker.objects.select_related("block", "blocked_by"),
+                )
+            )
+        )
+
+    def grouper(self, issue, group_by):
+        group_by = issue.get(group_by, "")
+
+        if isinstance(group_by, list):
+            if len(group_by):
+                return group_by[0]
+            else:
+                return ""
+
+        else:
+            return group_by
+
+    def list(self, request, slug, project_id):
+        try:
+            issue_queryset = self.get_queryset()
+
+            ## Grouping the results
+            group_by = request.GET.get("group_by", False)
+            # TODO: Move this group by from ittertools to ORM for better performance - nk
+            if group_by:
+                issue_dict = dict()
+
+                issues = IssueSerializer(issue_queryset, many=True).data
+
+                for key, value in groupby(
+                    issues, lambda issue: self.grouper(issue, group_by)
+                ):
+                    issue_dict[str(key)] = list(value)
+
+                return Response(issue_dict, status=status.HTTP_200_OK)
+
+            return self.paginate(
+                request=request,
+                queryset=issue_queryset,
+                on_results=lambda issues: IssueSerializer(issues, many=True).data,
+            )
+
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    def create(self, request, slug, project_id):
+        try:
+            project = Project.objects.get(workspace__slug=slug, pk=project_id)
+            serializer = IssueCreateSerializer(
+                data=request.data, context={"project": project}
+            )
+
+            if serializer.is_valid():
+                serializer.save()
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+        except Project.DoesNotExist:
+            return Response(
+                {"error": "Project was not found"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+
+class UserIssuesEndpoint(BaseAPIView):
+    def get(self, request):
+        try:
+            issues = Issue.objects.filter(assignees__in=[request.user])
+            serializer = IssueSerializer(issues, many=True)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class WorkSpaceIssuesEndpoint(BaseAPIView):
+
+    permission_classes = [
+        WorkSpaceAdminPermission,
+    ]
+
+    def get(self, request, slug):
+        try:
+            issues = Issue.objects.filter(workspace__slug=slug).filter(
+                project__project_projectmember__member=self.request.user
+            )
+            serializer = IssueSerializer(issues, many=True)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class IssueActivityEndpoint(BaseAPIView):
+    def get(self, request, slug, project_id, issue_id):
+        try:
+            issue_activities = IssueActivity.objects.filter(issue_id=issue_id).filter(
+                project__project_projectmember__member=self.request.user
+            )
+            serializer = IssueActivitySerializer(issue_activities, many=True)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class IssueCommentViewSet(BaseViewSet):
+
+    serializer_class = IssueCommentSerializer
+    model = IssueComment
+
+    filterset_fields = [
+        "issue__id",
+        "workspace__id",
+    ]
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+            issue_id=self.kwargs.get("issue_id"),
+            actor=self.request.user if self.request.user is not None else None,
+        )
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(issue_id=self.kwargs.get("issue_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .distinct()
+        )
+
+
+class TimeLineIssueViewSet(BaseViewSet):
+    serializer_class = TimeLineIssueSerializer
+    model = TimelineIssue
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    filterset_fields = [
+        "issue__id",
+        "workspace__id",
+    ]
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+            issue_id=self.kwargs.get("issue_id"),
+        )
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(issue_id=self.kwargs.get("issue_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .distinct()
+        )
+
+
+class IssuePropertyViewSet(BaseViewSet):
+    serializer_class = IssuePropertySerializer
+    model = IssueProperty
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    filterset_fields = []
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"), user=self.request.user
+        )
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(user=self.request.user)
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+        )
+
+    def list(self, request, slug, project_id):
+        queryset = self.get_queryset()
+        serializer = IssuePropertySerializer(queryset, many=True)
+        return Response(
+            serializer.data[0] if len(serializer.data) > 0 else [],
+            status=status.HTTP_200_OK,
+        )
+
+    def create(self, request, slug, project_id):
+        try:
+
+            issue_property, created = IssueProperty.objects.get_or_create(
+                user=request.user,
+                project_id=project_id,
+            )
+
+            if not created:
+                issue_property.properties = request.data.get("properties", {})
+                issue_property.save()
+
+                serializer = IssuePropertySerializer(issue_property)
+                return Response(serializer.data, status=status.HTTP_200_OK)
+
+            issue_property.properties = request.data.get("properties", {})
+            issue_property.save()
+            serializer = IssuePropertySerializer(issue_property)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class LabelViewSet(BaseViewSet):
+
+    serializer_class = LabelSerializer
+    model = Label
+    permission_classes = [
+        ProjectMemberPermission,
+    ]
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+        )
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("parent")
+            .distinct()
+        )
+
+
+class BulkDeleteIssuesEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def delete(self, request, slug, project_id):
+        try:
+
+            issue_ids = request.data.get("issue_ids", [])
+
+            if not len(issue_ids):
+                return Response(
+                    {"error": "Issue IDs are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            issues = Issue.objects.filter(
+                workspace__slug=slug, project_id=project_id, pk__in=issue_ids
+            )
+
+            total_issues = len(issues)
+
+            issues.delete()
+
+            return Response(
+                {"message": f"{total_issues} issues were deleted"}, status=status.HTTP_200_OK
+            )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

apiserver/plane/api/views/oauth.py

@@ -0,0 +1,269 @@
+# Python imports
+import uuid
+import requests
+import os
+
+# Django imports
+from django.utils import timezone
+
+# Third Party modules
+from rest_framework.response import Response
+from rest_framework import exceptions
+from rest_framework.permissions import AllowAny
+from rest_framework.views import APIView
+from rest_framework_simplejwt.tokens import RefreshToken
+from rest_framework import status
+
+# sso authentication
+from google.oauth2 import id_token
+from google.auth.transport import requests as google_auth_request
+
+# Module imports
+from plane.db.models import SocialLoginConnection, User
+from plane.api.serializers import UserSerializer
+from .base import BaseAPIView
+
+
+def get_tokens_for_user(user):
+    refresh = RefreshToken.for_user(user)
+    return (
+        str(refresh.access_token),
+        str(refresh),
+    )
+
+
+def validate_google_token(token, client_id):
+    try:
+
+        id_info = id_token.verify_oauth2_token(
+            token, google_auth_request.Request(), client_id
+        )
+        email = id_info.get("email")
+        first_name = id_info.get("given_name")
+        last_name = id_info.get("family_name", "")
+        data = {
+            "email": email,
+            "first_name": first_name,
+            "last_name": last_name,
+        }
+        return data
+    except Exception as e:
+        print(e)
+        raise exceptions.AuthenticationFailed("Error with Google connection.")
+
+
+def get_access_token(request_token: str, client_id: str) -> str:
+    """Obtain the request token from github.
+    Given the client id, client secret and request issued out by GitHub, this method
+    should give back an access token
+    Parameters
+    ----------
+    CLIENT_ID: str
+        A string representing the client id issued out by github
+    CLIENT_SECRET: str
+        A string representing the client secret issued out by github
+    request_token: str
+        A string representing the request token issued out by github
+    Throws
+    ------
+    ValueError:
+        if CLIENT_ID or CLIENT_SECRET or request_token is empty or not a string
+    Returns
+    -------
+    access_token: str
+        A string representing the access token issued out by github
+    """
+
+    if not request_token:
+        raise ValueError("The request token has to be supplied!")
+
+    CLIENT_SECRET = os.environ.get("GITHUB_CLIENT_SECRET")
+
+    url = f"https://github.com/login/oauth/access_token?client_id={client_id}&client_secret={CLIENT_SECRET}&code={request_token}"
+    headers = {"accept": "application/json"}
+
+    res = requests.post(url, headers=headers)
+
+    data = res.json()
+    access_token = data["access_token"]
+
+    return access_token
+
+
+def get_user_data(access_token: str) -> dict:
+    """
+    Obtain the user data from github.
+    Given the access token, this method should give back the user data
+    """
+    if not access_token:
+        raise ValueError("The request token has to be supplied!")
+    if not isinstance(access_token, str):
+        raise ValueError("The request token has to be a string!")
+
+    access_token = "token " + access_token
+    url = "https://api.github.com/user"
+    headers = {"Authorization": access_token}
+
+    resp = requests.get(url=url, headers=headers)
+
+    userData = resp.json()
+
+    return userData
+
+
+class OauthEndpoint(BaseAPIView):
+    permission_classes = [AllowAny]
+
+    def post(self, request):
+        try:
+
+            medium = request.data.get("medium", False)
+            id_token = request.data.get("credential", False)
+            client_id = request.data.get("clientId", False)
+
+            if not medium or not id_token:
+                return Response(
+                    {
+                        "error": "Something went wrong. Please try again later or contact the support team."
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if medium == "google":
+                data = validate_google_token(id_token, client_id)
+
+            if medium == "github":
+                access_token = get_access_token(id_token, client_id)
+                data = get_user_data(access_token)
+
+            email = data.get("email", None)
+            if email == None:
+
+                return Response(
+                    {
+                        "error": "Something went wrong. Please try again later or contact the support team."
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if "@" in email:
+                user = User.objects.get(email=email)
+                email = data["email"]
+                channel = "email"
+                mobile_number = uuid.uuid4().hex
+                email_verified = True
+            else:
+
+                return Response(
+                    {
+                        "error": "Something went wrong. Please try again later or contact the support team."
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            ## Login Case
+
+            if not user.is_active:
+                return Response(
+                    {
+                        "error": "Your account has been deactivated. Please contact your site administrator."
+                    },
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
+            user.last_active = timezone.now()
+            user.last_login_time = timezone.now()
+            user.last_login_ip = request.META.get("REMOTE_ADDR")
+            user.last_login_medium = f"oauth"
+            user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
+            user.is_email_verified = email_verified
+            user.save()
+
+            serialized_user = UserSerializer(user).data
+
+            access_token, refresh_token = get_tokens_for_user(user)
+
+            data = {
+                "access_token": access_token,
+                "refresh_token": refresh_token,
+                "user": serialized_user,
+            }
+
+            SocialLoginConnection.objects.update_or_create(
+                medium=medium,
+                extra_data={},
+                user=user,
+                defaults={
+                    "token_data": {"id_token": id_token},
+                    "last_login_at": timezone.now(),
+                },
+            )
+
+            return Response(data, status=status.HTTP_200_OK)
+
+        except User.DoesNotExist:
+            ## Signup Case
+
+            username = uuid.uuid4().hex
+
+            if "@" in email:
+                email = data["email"]
+                mobile_number = uuid.uuid4().hex
+                channel = "email"
+                email_verified = True
+            else:
+                return Response(
+                    {
+                        "error": "Something went wrong. Please try again later or contact the support team."
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            user = User(
+                username=username,
+                email=email,
+                mobile_number=mobile_number,
+                first_name=data["first_name"],
+                last_name=data["last_name"],
+                is_email_verified=email_verified,
+                is_password_autoset=True,
+            )
+
+            user.set_password(uuid.uuid4().hex)
+            user.is_password_autoset = True
+            user.last_active = timezone.now()
+            user.last_login_time = timezone.now()
+            user.last_login_ip = request.META.get("REMOTE_ADDR")
+            user.last_login_medium = "oauth"
+            user.last_login_uagent = request.META.get("HTTP_USER_AGENT")
+            user.token_updated_at = timezone.now()
+            user.save()
+            serialized_user = UserSerializer(user).data
+
+            access_token, refresh_token = get_tokens_for_user(user)
+            data = {
+                "access_token": access_token,
+                "refresh_token": refresh_token,
+                "user": serialized_user,
+                "permissions": [],
+            }
+
+            SocialLoginConnection.objects.update_or_create(
+                medium=medium,
+                extra_data={},
+                user=user,
+                defaults={
+                    "token_data": {"id_token": id_token},
+                    "last_login_at": timezone.now(),
+                },
+            )
+            return Response(data, status=status.HTTP_201_CREATED)
+        except Exception as e:
+            print(e)
+
+            return Response(
+                {
+                    "error": "Something went wrong. Please try again later or contact the support team."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )

apiserver/plane/api/views/people.py

@@ -0,0 +1,76 @@
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+from sentry_sdk import capture_exception
+
+# Module imports
+from plane.api.serializers import (
+    UserSerializer,
+)
+
+from plane.api.views.base import BaseViewSet, BaseAPIView
+from plane.db.models import User
+
+
+
+class PeopleEndpoint(BaseAPIView):
+
+    filterset_fields = ("date_joined",)
+
+    search_fields = (
+        "^first_name",
+        "^last_name",
+        "^email",
+        "^username",
+    )
+
+    def get(self, request):
+        try:
+            users = User.objects.all().order_by("-date_joined")
+            if (
+                request.GET.get("search", None) is not None
+                and len(request.GET.get("search")) < 3
+            ):
+                return Response(
+                    {"message": "Search term must be at least 3 characters long"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+            return self.paginate(
+                request=request,
+                queryset=self.filter_queryset(users),
+                on_results=lambda data: UserSerializer(data, many=True).data,
+            )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"message": "Something went wrong"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class UserEndpoint(BaseViewSet):
+    serializer_class = UserSerializer
+    model = User
+    serializers = {}
+
+    def get_object(self):
+        return self.request.user
+
+
+
+class UpdateUserOnBoardedEndpoint(BaseAPIView):
+    def patch(self, request):
+        try:
+            user = User.objects.get(pk=request.user.id)
+            user.is_onboarded = request.data.get("is_onboarded", False)
+            user.save()
+            return Response(
+                {"message": "Updated successfully"}, status=status.HTTP_200_OK
+            )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )

apiserver/plane/api/views/project.py

@@ -0,0 +1,526 @@
+# Python imports
+import jwt
+from datetime import datetime
+
+# Django imports
+from django.core.exceptions import ValidationError
+from django.db import IntegrityError
+from django.db.models import Q
+from django.core.validators import validate_email
+from django.conf import settings
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework import serializers
+from sentry_sdk import capture_exception
+
+# Module imports
+from .base import BaseViewSet, BaseAPIView
+from plane.api.serializers import (
+    ProjectSerializer,
+    ProjectMemberSerializer,
+    ProjectDetailSerializer,
+    ProjectMemberInviteSerializer,
+    ProjectIdentifierSerializer,
+)
+
+from plane.api.permissions import ProjectBasePermission
+
+from plane.db.models import (
+    Project,
+    ProjectMember,
+    Workspace,
+    ProjectMemberInvite,
+    User,
+    WorkspaceMember,
+    State,
+    TeamMember,
+)
+
+from plane.db.models import (
+    Project,
+    ProjectMember,
+    Workspace,
+    ProjectMemberInvite,
+    User,
+    ProjectIdentifier,
+)
+from plane.bgtasks.project_invitation_task import project_invitation
+
+
+class ProjectViewSet(BaseViewSet):
+    serializer_class = ProjectSerializer
+    model = Project
+
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def get_serializer_class(self, *args, **kwargs):
+        if self.action == "update" or self.action == "partial_update":
+            return ProjectSerializer
+        return ProjectDetailSerializer
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(Q(project_projectmember__member=self.request.user) | Q(network=2))
+            .select_related("workspace", "workspace__owner")
+            .distinct()
+        )
+
+    def create(self, request, slug):
+        try:
+
+            workspace = Workspace.objects.get(slug=slug)
+
+            serializer = ProjectSerializer(
+                data={**request.data}, context={"workspace_id": workspace.id}
+            )
+            if serializer.is_valid():
+                serializer.save()
+
+                ## Add the user as Administrator to the project
+                ProjectMember.objects.create(
+                    project_id=serializer.data["id"], member=request.user, role=20
+                )
+
+                ## Default states
+                states = [
+                    {"name": "Backlog", "color": "#5e6ad2", "sequence": 15000},
+                    {"name": "ToDo", "color": "#eb5757", "sequence": 25000},
+                    {"name": "Started", "color": "#26b5ce", "sequence": 35000},
+                    {"name": "InProgress", "color": "#f2c94c", "sequence": 45000},
+                    {"name": "Done", "color": "#4cb782", "sequence": 55000},
+                    {"name": "Cancelled", "color": "#cc1d10", "sequence": 65000},
+                ]
+
+                State.objects.bulk_create(
+                    [
+                        State(
+                            name=state["name"],
+                            color=state["color"],
+                            project=serializer.instance,
+                            sequence=state["sequence"],
+                            workspace=serializer.instance.workspace,
+                        )
+                        for state in states
+                    ]
+                )
+
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(
+                [serializer.errors[error][0] for error in serializer.errors],
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"name": "The project name is already taken"},
+                    status=status.HTTP_410_GONE,
+                )
+        except serializers.ValidationError as e:
+            return Response(
+                {"identifier": "The project identifier is already taken"},
+                status=status.HTTP_410_GONE,
+            )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class InviteProjectEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def post(self, request, slug, project_id):
+        try:
+
+            email = request.data.get("email", False)
+            role = request.data.get("role", False)
+
+            # Check if email is provided
+            if not email:
+                return Response(
+                    {"error": "Email is required"}, status=status.HTTP_400_BAD_REQUEST
+                )
+
+            validate_email(email)
+            # Check if user is already a member of workspace
+            if ProjectMember.objects.filter(
+                project_id=project_id, member__email=email
+            ).exists():
+                return Response(
+                    {"error": "User is already member of workspace"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            user = User.objects.filter(email=email).first()
+
+            if user is None:
+                token = jwt.encode(
+                    {"email": email, "timestamp": datetime.now().timestamp()},
+                    settings.SECRET_KEY,
+                    algorithm="HS256",
+                )
+                project_invitation_obj = ProjectMemberInvite.objects.create(
+                    email=email.strip().lower(),
+                    project_id=project_id,
+                    token=token,
+                    role=role,
+                )
+                domain = settings.WEB_URL
+                project_invitation.delay(email, project_id, token, domain)
+
+                return Response(
+                    {
+                        "message": "Email sent successfully",
+                        "id": project_invitation_obj.id,
+                    },
+                    status=status.HTTP_200_OK,
+                )
+
+            project_member = ProjectMember.objects.create(
+                member=user, project_id=project_id, role=role
+            )
+
+            return Response(
+                ProjectMemberSerializer(project_member).data, status=status.HTTP_200_OK
+            )
+
+        except ValidationError:
+            return Response(
+                {
+                    "error": "Invalid email address provided a valid email address is required to send the invite"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        except (Workspace.DoesNotExist, Project.DoesNotExist) as e:
+            return Response(
+                {"error": "Workspace or Project does not exists"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class UserProjectInvitationsViewset(BaseViewSet):
+
+    serializer_class = ProjectMemberInviteSerializer
+    model = ProjectMemberInvite
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(email=self.request.user.email)
+            .select_related("workspace")
+        )
+
+    def create(self, request):
+        try:
+
+            invitations = request.data.get("invitations")
+            project_invitations = ProjectMemberInvite.objects.filter(
+                pk__in=invitations, accepted=True
+            )
+            ProjectMember.objects.bulk_create(
+                [
+                    ProjectMember(
+                        project=invitation.project,
+                        workspace=invitation.project.workspace,
+                        member=request.user,
+                        role=invitation.role,
+                    )
+                    for invitation in project_invitations
+                ]
+            )
+
+            ## Delete joined project invites
+            project_invitations.delete()
+
+            return Response(status=status.HTTP_200_OK)
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class ProjectMemberViewSet(BaseViewSet):
+
+    serializer_class = ProjectMemberSerializer
+    model = ProjectMember
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    search_fields = [
+        "member__email",
+        "member__first_name",
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .select_related("project")
+            .select_related("member")
+        )
+
+
+class AddMemberToProjectEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id):
+        try:
+
+            member_id = request.data.get("member_id", False)
+            role = request.data.get("role", False)
+
+            if not member_id or not role:
+                return Response(
+                    {"error": "Member ID and role is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            # Check if the user is a member in the workspace
+            if not WorkspaceMember.objects.filter(
+                workspace__slug=slug, member_id=member_id
+            ).exists():
+                # TODO: Update this error message - nk
+                return Response(
+                    {
+                        "error": "User is not a member of the workspace. Invite the user to the workspace to add him to project"
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            # Check if the user is already member of project
+            if ProjectMember.objects.filter(
+                project=project_id, member_id=member_id
+            ).exists():
+                return Response(
+                    {"error": "User is already a member of the project"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            # Add the user to project
+            project_member = ProjectMember.objects.create(
+                project_id=project_id, member_id=member_id, role=role
+            )
+
+            serializer = ProjectMemberSerializer(project_member)
+
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class AddTeamToProjectEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id):
+
+        try:
+            team_members = TeamMember.objects.filter(
+                workspace__slug=slug, team__in=request.data.get("teams", [])
+            ).values_list("member", flat=True)
+
+            if len(team_members) == 0:
+                return Response(
+                    {"error": "No such team exists"}, status=status.HTTP_400_BAD_REQUEST
+                )
+
+            workspace = Workspace.objects.get(slug=slug)
+
+            project_members = []
+            for member in team_members:
+                project_members.append(
+                    ProjectMember(
+                        project_id=project_id,
+                        member_id=member,
+                        workspace=workspace,
+                    )
+                )
+
+            ProjectMember.objects.bulk_create(
+                project_members, batch_size=10, ignore_conflicts=True
+            )
+
+            serializer = ProjectMemberSerializer(project_members, many=True)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"error": "The team with the name already exists"},
+                    status=status.HTTP_410_GONE,
+                )
+        except Workspace.DoesNotExist:
+            return Response(
+                {"error": "The requested workspace could not be found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class ProjectMemberInvitationsViewset(BaseViewSet):
+
+    serializer_class = ProjectMemberInviteSerializer
+    model = ProjectMemberInvite
+
+    search_fields = []
+
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .select_related("project")
+        )
+
+
+class ProjectMemberInviteDetailViewSet(BaseViewSet):
+
+    serializer_class = ProjectMemberInviteSerializer
+    model = ProjectMemberInvite
+
+    search_fields = []
+
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(super().get_queryset().select_related("project"))
+
+
+class ProjectIdentifierEndpoint(BaseAPIView):
+
+    permission_classes = [
+        ProjectBasePermission,
+    ]
+
+    def get(self, request, slug):
+        try:
+
+            name = request.GET.get("name", "").strip().upper()
+
+            if name == "":
+                return Response(
+                    {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
+                )
+
+            exists = ProjectIdentifier.objects.filter(name=name).values(
+                "id", "name", "project"
+            )
+
+            return Response(
+                {"exists": len(exists), "identifiers": exists},
+                status=status.HTTP_200_OK,
+            )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    def delete(self, request, slug):
+        try:
+
+            name = request.data.get("name", "").strip().upper()
+
+            if name == "":
+                return Response(
+                    {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
+                )
+
+            if Project.objects.filter(identifier=name).exists():
+                return Response(
+                    {"error": "Cannot delete an identifier of an existing project"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            ProjectIdentifier.objects.filter(name=name).delete()
+
+            return Response(
+                status=status.HTTP_204_NO_CONTENT,
+            )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class ProjectJoinEndpoint(BaseAPIView):
+    def post(self, request, slug):
+        try:
+            project_ids = request.data.get("project_ids", [])
+
+            # Get the workspace user role
+            workspace_member = WorkspaceMember.objects.get(
+                member=request.user, workspace__slug=slug
+            )
+
+            workspace_role = workspace_member.role
+            workspace = workspace_member.workspace
+
+            ProjectMember.objects.bulk_create(
+                [
+                    ProjectMember(
+                        project_id=project_id,
+                        member=request.user,
+                        role=20
+                        if workspace_role >= 15
+                        else (15 if workspace_role == 10 else workspace_role),
+                        workspace=workspace,
+                    )
+                    for project_id in project_ids
+                ],
+                ignore_conflicts=True,
+            )
+
+            return Response(
+                {"message": "Projects joined successfully"},
+                status=status.HTTP_201_CREATED,
+            )
+        except WorkspaceMember.DoesNotExist:
+            return Response(
+                {"error": "User is not a member of workspace"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

apiserver/plane/api/views/shortcut.py

@@ -0,0 +1,29 @@
+# Module imports
+from . import BaseViewSet
+from plane.api.serializers import ShortCutSerializer
+from plane.api.permissions import ProjectEntityPermission
+from plane.db.models import Shortcut
+
+
+class ShortCutViewSet(BaseViewSet):
+
+    serializer_class = ShortCutSerializer
+    model = Shortcut
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def perform_create(self, serializer):
+        serializer.save(project_id=self.kwargs.get("project_id"))
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .distinct()
+        )

apiserver/plane/api/views/state.py

@@ -0,0 +1,29 @@
+# Module imports
+from . import BaseViewSet
+from plane.api.serializers import StateSerializer
+from plane.api.permissions import ProjectEntityPermission
+from plane.db.models import State
+
+
+class StateViewSet(BaseViewSet):
+
+    serializer_class = StateSerializer
+    model = State
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def perform_create(self, serializer):
+        serializer.save(project_id=self.kwargs.get("project_id"))
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .distinct()
+        )

apiserver/plane/api/views/view.py

@@ -0,0 +1,29 @@
+# Module imports
+from . import BaseViewSet
+from plane.api.serializers import ViewSerializer
+from plane.api.permissions import ProjectEntityPermission
+from plane.db.models import View
+
+
+class ViewViewSet(BaseViewSet):
+
+    serializer_class = ViewSerializer
+    model = View
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+
+    def perform_create(self, serializer):
+        serializer.save(project_id=self.kwargs.get("project_id"))
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .distinct()
+        )

apiserver/plane/api/views/workspace.py

@@ -0,0 +1,462 @@
+# Python imports
+import jwt
+from datetime import datetime
+
+# Django imports
+from django.db import IntegrityError
+from django.db.models import Prefetch
+from django.conf import settings
+from django.utils import timezone
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_email
+from django.contrib.sites.shortcuts import get_current_site
+from django.db.models import CharField
+from django.db.models.functions import Cast
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+from sentry_sdk import capture_exception
+
+# Module imports
+from plane.api.serializers import (
+    WorkSpaceSerializer,
+    WorkSpaceMemberSerializer,
+    TeamSerializer,
+    WorkSpaceMemberInviteSerializer,
+    UserLiteSerializer,
+)
+from plane.api.views.base import BaseAPIView
+from . import BaseViewSet
+from plane.db.models import (
+    User,
+    Workspace,
+    WorkspaceMember,
+    WorkspaceMemberInvite,
+    Team,
+)
+from plane.api.permissions import WorkSpaceBasePermission, WorkSpaceAdminPermission
+from plane.bgtasks.workspace_invitation_task import workspace_invitation
+
+
+class WorkSpaceViewSet(BaseViewSet):
+
+    model = Workspace
+    serializer_class = WorkSpaceSerializer
+    permission_classes = [
+        WorkSpaceBasePermission,
+    ]
+
+    search_fields = [
+        "name",
+    ]
+    filterset_fields = [
+        "owner",
+    ]
+
+    lookup_field = "slug"
+
+    def get_queryset(self):
+        return self.filter_queryset(super().get_queryset().select_related("owner"))
+
+    def create(self, request):
+        try:
+            serializer = WorkSpaceSerializer(data=request.data)
+
+            if serializer.is_valid():
+                serializer.save(owner=request.user)
+                # Create Workspace member
+                _ = WorkspaceMember.objects.create(
+                    workspace_id=serializer.data["id"],
+                    member=request.user,
+                    role=20,
+                    company_role=request.data.get("company_role", ""),
+                )
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(
+                [serializer.errors[error][0] for error in serializer.errors],
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        ## Handling unique integrity error for now
+        ## TODO: Extend this to handle other common errors which are not automatically handled by APIException
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"name": "The workspace with the name already exists"},
+                    status=status.HTTP_410_GONE,
+                )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {
+                    "error": "Something went wrong please try again later",
+                    "identifier": None,
+                },
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class UserWorkSpacesEndpoint(BaseAPIView):
+
+    search_fields = [
+        "name",
+    ]
+    filterset_fields = [
+        "owner",
+    ]
+
+    def get(self, request):
+        try:
+            workspace = (
+                Workspace.objects.prefetch_related(
+                    Prefetch("workspace_member", queryset=WorkspaceMember.objects.all())
+                )
+                .filter(
+                    workspace_member__member=request.user,
+                )
+                .select_related("owner")
+            )
+            serializer = WorkSpaceSerializer(self.filter_queryset(workspace), many=True)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            print(e)
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class WorkSpaceAvailabilityCheckEndpoint(BaseAPIView):
+
+    permission_classes = [
+        AllowAny,
+    ]
+
+    def get(self, request):
+        try:
+            name = request.GET.get("name", False)
+
+            if not name:
+                return Response(
+                    {"error": "Workspace Name is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            workspace = Workspace.objects.filter(name=name).exists()
+
+            return Response({"status": workspace}, status=status.HTTP_200_OK)
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class InviteWorkspaceEndpoint(BaseAPIView):
+
+    permission_classes = [
+        WorkSpaceAdminPermission,
+    ]
+
+    def post(self, request, slug):
+        try:
+
+            email = request.data.get("email", False)
+
+            # Check if email is provided
+            if not email:
+                return Response(
+                    {"error": "Email is required"}, status=status.HTTP_400_BAD_REQUEST
+                )
+
+            validate_email(email)
+            # Check if user is already a member of workspace
+            workspace = Workspace.objects.get(slug=slug)
+
+            if WorkspaceMember.objects.filter(
+                workspace_id=workspace.id, member__email=email
+            ).exists():
+                return Response(
+                    {"error": "User is already member of workspace"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            token = jwt.encode(
+                {"email": email, "timestamp": datetime.now().timestamp()},
+                settings.SECRET_KEY,
+                algorithm="HS256",
+            )
+
+            workspace_invitation_obj = WorkspaceMemberInvite.objects.create(
+                email=email.strip().lower(),
+                workspace_id=workspace.id,
+                token=token,
+                role=request.data.get("role", 10),
+            )
+
+            domain = settings.WEB_URL
+
+            workspace_invitation.delay(
+                email, workspace.id, token, domain, request.user.email
+            )
+
+            return Response(
+                {
+                    "message": "Email sent successfully",
+                    "id": workspace_invitation_obj.id,
+                },
+                status=status.HTTP_200_OK,
+            )
+        except ValidationError:
+            return Response(
+                {
+                    "error": "Invalid email address provided a valid email address is required to send the invite"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        except Workspace.DoesNotExist:
+            return Response(
+                {"error": "Workspace does not exists"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        except Exception as e:
+            print(e)
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class JoinWorkspaceEndpoint(BaseAPIView):
+    permission_classes = [
+        AllowAny,
+    ]
+
+    def post(self, request, slug, pk):
+        try:
+
+            workspace_invite = WorkspaceMemberInvite.objects.get(
+                pk=pk, workspace__slug=slug
+            )
+
+            email = request.data.get("email", "")
+
+            if email == "" or workspace_invite.email != email:
+                return Response(
+                    {"error": "You do not have permission to join the workspace"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
+            if workspace_invite.responded_at is None:
+                workspace_invite.accepted = request.data.get("accepted", False)
+                workspace_invite.responded_at = timezone.now()
+                workspace_invite.save()
+
+                if workspace_invite.accepted:
+                    return Response(
+                        {"message": "Workspace Invitation Accepted"},
+                        status=status.HTTP_200_OK,
+                    )
+
+                return Response(
+                    {"message": "Workspace Invitation was not accepted"},
+                    status=status.HTTP_200_OK,
+                )
+
+            return Response(
+                {"error": "You have already responded to the invitation request"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        except WorkspaceMemberInvite.DoesNotExist:
+            return Response(
+                {"error": "The invitation either got expired or could not be found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        except Exception as e:
+            print(e)
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class WorkspaceInvitationsViewset(BaseViewSet):
+
+    serializer_class = WorkSpaceMemberInviteSerializer
+    model = WorkspaceMemberInvite
+
+    permission_classes = [
+        WorkSpaceAdminPermission,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace")
+        )
+
+
+class UserWorkspaceInvitationsEndpoint(BaseViewSet):
+
+    serializer_class = WorkSpaceMemberInviteSerializer
+    model = WorkspaceMemberInvite
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(email=self.request.user.email)
+            .select_related("workspace")
+        )
+
+    def create(self, request):
+        try:
+
+            invitations = request.data.get("invitations")
+            workspace_invitations = WorkspaceMemberInvite.objects.filter(
+                pk__in=invitations
+            )
+
+            WorkspaceMember.objects.bulk_create(
+                [
+                    WorkspaceMember(
+                        workspace=invitation.workspace,
+                        member=request.user,
+                        role=invitation.role,
+                    )
+                    for invitation in workspace_invitations
+                ],
+                ignore_conflicts=True,
+            )
+
+            # Delete joined workspace invites
+            workspace_invitations.delete()
+
+            return Response(status=status.HTTP_200_OK)
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class WorkSpaceMemberViewSet(BaseViewSet):
+
+    serializer_class = WorkSpaceMemberSerializer
+    model = WorkspaceMember
+
+    permission_classes = [
+        WorkSpaceAdminPermission,
+    ]
+
+    search_fields = [
+        "member__email",
+        "member__first_name",
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "workspace__owner")
+            .select_related("member")
+        )
+
+
+class TeamMemberViewSet(BaseViewSet):
+
+    serializer_class = TeamSerializer
+    model = Team
+
+    search_fields = [
+        "member__email",
+        "member__first_name",
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "workspace__owner")
+            .prefetch_related("members")
+        )
+
+    def create(self, request, slug):
+
+        try:
+
+            members = list(
+                WorkspaceMember.objects.filter(
+                    workspace__slug=slug, member__id__in=request.data.get("members", [])
+                )
+                .annotate(member_str_id=Cast("member", output_field=CharField()))
+                .distinct()
+                .values_list("member_str_id", flat=True)
+            )
+
+            if len(members) != len(request.data.get("members", [])):
+
+                users = list(set(request.data.get("members", [])).difference(members))
+                users = User.objects.filter(pk__in=users)
+
+                serializer = UserLiteSerializer(users, many=True)
+                return Response(
+                    {
+                        "error": f"{len(users)} of the member(s) are not a part of the workspace",
+                        "members": serializer.data,
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            workspace = Workspace.objects.get(slug=slug)
+
+            serializer = TeamSerializer(
+                data=request.data, context={"workspace": workspace}
+            )
+            if serializer.is_valid():
+                serializer.save()
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"error": "The team with the name already exists"},
+                    status=status.HTTP_410_GONE,
+                )
+        except Exception as e:
+            capture_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+class UserWorkspaceInvitationEndpoint(BaseViewSet):
+
+    model = WorkspaceMemberInvite
+    serializer_class = WorkSpaceMemberInviteSerializer
+
+    permission_classes = [
+        AllowAny,
+    ]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(pk=self.kwargs.get("pk"))
+            .select_related("workspace")
+        )