dev: change update structure

chore: date filters

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

@@ -2,6 +2,8 @@ name: Create PR in Plane EE Repository to sync the changes
 
 on:
   pull_request:
+    branches: 
+      - master
     types:
       - closed
 

apiserver/plane/api/urls.py

@@ -106,7 +106,6 @@ from plane.api.views import (
     GlobalViewViewSet,
     GlobalViewIssuesViewSet,
     IssueViewViewSet,
-    ViewIssuesEndpoint,
     IssueViewFavoriteViewSet,
     ## End Views
     # Cycles
@@ -657,11 +656,6 @@ urlpatterns = [
         ),
         name="project-view",
     ),
-    path(
-        "workspaces/<str:slug>/projects/<uuid:project_id>/views/<uuid:view_id>/issues/",
-        ViewIssuesEndpoint.as_view(),
-        name="project-view-issues",
-    ),
     path(
         "workspaces/<str:slug>/views/",
         GlobalViewViewSet.as_view(

apiserver/plane/api/views/__init__.py

@@ -57,7 +57,7 @@ from .workspace import (
     LeaveWorkspaceEndpoint,
 )
 from .state import StateViewSet
-from .view import GlobalViewViewSet, GlobalViewIssuesViewSet, IssueViewViewSet, ViewIssuesEndpoint, IssueViewFavoriteViewSet
+from .view import GlobalViewViewSet, GlobalViewIssuesViewSet, IssueViewViewSet, IssueViewFavoriteViewSet
 from .cycle import (
     CycleViewSet,
     CycleIssueViewSet,

apiserver/plane/api/views/issue.py

@@ -24,7 +24,6 @@ from django.core.serializers.json import DjangoJSONEncoder
 from django.utils.decorators import method_decorator
 from django.views.decorators.gzip import gzip_page
 from django.db import IntegrityError
-from django.db import IntegrityError
 
 # Third Party imports
 from rest_framework.response import Response
@@ -84,7 +83,6 @@ from plane.db.models import (
 from plane.bgtasks.issue_activites_task import issue_activity
 from plane.utils.grouper import group_results
 from plane.utils.issue_filters import issue_filters
-from plane.bgtasks.export_task import issue_export_task
 
 
 class IssueViewSet(BaseViewSet):
@@ -113,26 +111,6 @@ class IssueViewSet(BaseViewSet):
     def perform_create(self, serializer):
         serializer.save(project_id=self.kwargs.get("project_id"))
 
-    def perform_update(self, serializer):
-        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
-        current_instance = (
-            self.get_queryset().filter(pk=self.kwargs.get("pk", None)).first()
-        )
-        if current_instance is not None:
-            issue_activity.delay(
-                type="issue.activity.updated",
-                requested_data=requested_data,
-                actor_id=str(self.request.user.id),
-                issue_id=str(self.kwargs.get("pk", None)),
-                project_id=str(self.kwargs.get("project_id", None)),
-                current_instance=json.dumps(
-                    IssueSerializer(current_instance).data, cls=DjangoJSONEncoder
-                ),
-                epoch=int(timezone.now().timestamp())
-            )
-
-        return super().perform_update(serializer)
-
     def perform_destroy(self, instance):
         current_instance = (
             self.get_queryset().filter(pk=self.kwargs.get("pk", None)).first()
@@ -342,6 +320,35 @@ class IssueViewSet(BaseViewSet):
                 {"error": "Issue Does not exist"}, status=status.HTTP_404_NOT_FOUND
             )
 
+    def partial_update(self, request, slug, project_id, pk):
+        try:
+            issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+            requested_data = json.dumps(request.data, cls=DjangoJSONEncoder)
+            current_instance = json.dumps(
+                    IssueSerializer(issue).data, cls=DjangoJSONEncoder
+                )
+            serializer = IssueSerializer(issue, data=request.data, partial=True)
+            if serializer.is_valid():
+                serializer.save()
+                # Track this data
+                issue_activity.delay(
+                    type="issue.activity.updated",
+                    requested_data=requested_data,
+                    actor_id=str(request.user.id),
+                    issue_id=str(pk),
+                    project_id=str(project_id),
+                    current_instance=json.dumps(
+                        IssueSerializer(current_instance).data, cls=DjangoJSONEncoder
+                    ),
+                    epoch=int(timezone.now().timestamp())
+                )
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except Issue.DoesNotExist:
+            return Response({"error": "Isssue does not exists"}, 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_400_BAD_REQUEST)
 
 class UserWorkSpaceIssues(BaseAPIView):
     @method_decorator(gzip_page)

apiserver/plane/api/views/view.py

@@ -243,51 +243,6 @@ class IssueViewViewSet(BaseViewSet):
         )
 
 
-class ViewIssuesEndpoint(BaseAPIView):
-    permission_classes = [
-        ProjectEntityPermission,
-    ]
-
-    def get(self, request, slug, project_id, view_id):
-        try:
-            view = IssueView.objects.get(pk=view_id)
-            queries = view.query
-
-            filters = issue_filters(request.query_params, "GET")
-
-            issues = (
-                Issue.issue_objects.filter(
-                    **queries, project_id=project_id, workspace__slug=slug
-                )
-                .filter(**filters)
-                .select_related("project")
-                .select_related("workspace")
-                .select_related("state")
-                .select_related("parent")
-                .prefetch_related("assignees")
-                .prefetch_related("labels")
-                .prefetch_related(
-                    Prefetch(
-                        "issue_reactions",
-                        queryset=IssueReaction.objects.select_related("actor"),
-                    )
-                )
-            )
-
-            serializer = IssueLiteSerializer(issues, many=True)
-            return Response(serializer.data, status=status.HTTP_200_OK)
-        except IssueView.DoesNotExist:
-            return Response(
-                {"error": "Issue View does not exist"}, 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_400_BAD_REQUEST,
-            )
-
-
 class IssueViewFavoriteViewSet(BaseViewSet):
     serializer_class = IssueViewFavoriteSerializer
     model = IssueViewFavorite

apiserver/plane/utils/issue_filters.py

@@ -1,5 +1,62 @@
-from django.utils.timezone import make_aware
-from django.utils.dateparse import parse_datetime
+import re
+from datetime import timedelta
+from django.utils import timezone
+
+# The date from pattern
+pattern = re.compile(r"\d+_(weeks|months)$")
+
+
+# Get the 2_weeks, 3_months
+def string_date_filter(filter, duration, subsequent, term, date_filter, offset):
+    now = timezone.now().date()
+    if term == "months":
+        if subsequent == "after":
+            if offset == "fromnow":
+                filter[f"{date_filter}__gte"] = now + timedelta(days=duration * 30)
+            else:
+                filter[f"{date_filter}__gte"] = now - timedelta(days=duration * 30)
+        else:
+            if offset == "fromnow":
+                filter[f"{date_filter}__lte"] = now + timedelta(days=duration * 30)
+            else:
+                filter[f"{date_filter}__lte"] = now - timedelta(days=duration * 30)
+    if term == "weeks":
+        if subsequent == "after":
+            if offset == "fromnow":
+                filter[f"{date_filter}__gte"] = now + timedelta(weeks=duration)
+            else:
+                filter[f"{date_filter}__gte"] = now - timedelta(weeks=duration)
+        else:
+            if offset == "fromnow":
+                filter[f"{date_filter}__lte"] = now + timedelta(days=duration)
+            else:
+                filter[f"{date_filter}__lte"] = now - timedelta(days=duration)
+
+
+def date_filter(filter, date_term, queries):
+    """
+        Handle all date filters
+    """
+    for query in queries:
+        date_query = query.split(";")
+        if len(date_query) >= 2:
+            match = pattern.match(date_query[0])
+            if match:
+                if len(date_query) == 3:
+                    digit, term = date_query[0].split("_")
+                    string_date_filter(
+                        filter=filter,
+                        duration=int(digit),
+                        subsequent=date_query[1],
+                        term=term,
+                        date_filter="created_at__date",
+                        offset=date_query[2],
+                    )
+            else:
+                if "after" in date_query:
+                    filter[f"{date_term}__gte"] = date_query[0]
+                else:
+                    filter[f"{date_term}__lte"] = date_query[0]
 
 
 def filter_state(params, filter, method):
@@ -97,20 +154,10 @@ def filter_created_at(params, filter, method):
     if method == "GET":
         created_ats = params.get("created_at").split(",")
         if len(created_ats) and "" not in created_ats:
-            for query in created_ats:
-                created_at_query = query.split(";")
-                if len(created_at_query) == 2 and "after" in created_at_query:
-                    filter["created_at__date__gte"] = created_at_query[0]
-                else:
-                    filter["created_at__date__lte"] = created_at_query[0]
+            date_filter(filter=filter, date_term="created_at__date", queries=created_ats)
     else:
         if params.get("created_at", None) and len(params.get("created_at")):
-            for query in params.get("created_at"):
-                created_at_query = query.split(";")
-                if len(created_at_query) == 2 and "after" in created_at_query:
-                    filter["created_at__date__gte"] = created_at_query[0]
-                else:
-                    filter["created_at__date__lte"] = created_at_query[0]
+            date_filter(filter=filter, date_term="created_at__date", queries=params.get("created_at", []))
     return filter
 
 
@@ -118,20 +165,10 @@ def filter_updated_at(params, filter, method):
     if method == "GET":
         updated_ats = params.get("updated_at").split(",")
         if len(updated_ats) and "" not in updated_ats:
-            for query in updated_ats:
-                updated_at_query = query.split(";")
-                if len(updated_at_query) == 2 and "after" in updated_at_query:
-                    filter["updated_at__date__gte"] = updated_at_query[0]
-                else:
-                    filter["updated_at__date__lte"] = updated_at_query[0]
+            date_filter(filter=filter, date_term="created_at__date", queries=updated_ats)
     else:
         if params.get("updated_at", None) and len(params.get("updated_at")):
-            for query in params.get("updated_at"):
-                updated_at_query = query.split(";")
-                if len(updated_at_query) == 2 and "after" in updated_at_query:
-                    filter["updated_at__date__gte"] = updated_at_query[0]
-                else:
-                    filter["updated_at__date__lte"] = updated_at_query[0]
+            date_filter(filter=filter, date_term="created_at__date", queries=params.get("updated_at", []))
     return filter
 
 
@@ -139,20 +176,10 @@ def filter_start_date(params, filter, method):
     if method == "GET":
         start_dates = params.get("start_date").split(",")
         if len(start_dates) and "" not in start_dates:
-            for query in start_dates:
-                start_date_query = query.split(";")
-                if len(start_date_query) == 2 and "after" in start_date_query:
-                    filter["start_date__gte"] = start_date_query[0]
-                else:
-                    filter["start_date__lte"] = start_date_query[0]
+            date_filter(filter=filter, date_term="start_date", queries=start_dates)
     else:
         if params.get("start_date", None) and len(params.get("start_date")):
-            for query in params.get("start_date"):
-                start_date_query = query.split(";")
-                if len(start_date_query) == 2 and "after" in start_date_query:
-                    filter["start_date__gte"] = start_date_query[0]
-                else:
-                    filter["start_date__lte"] = start_date_query[0]
+            date_filter(filter=filter, date_term="start_date", queries=params.get("start_date", []))
     return filter
 
 
@@ -160,21 +187,11 @@ def filter_target_date(params, filter, method):
     if method == "GET":
         target_dates = params.get("target_date").split(",")
         if len(target_dates) and "" not in target_dates:
-            for query in target_dates:
-                target_date_query = query.split(";")
-                if len(target_date_query) == 2 and "after" in target_date_query:
-                    filter["target_date__gte"] = target_date_query[0]
-                else:
-                    filter["target_date__lte"] = target_date_query[0]
+
+            date_filter(filter=filter, date_term="target_date", queries=target_dates)
     else:
         if params.get("target_date", None) and len(params.get("target_date")):
-            for query in params.get("target_date"):
-                target_date_query = query.split(";")
-                if len(target_date_query) == 2 and "after" in target_date_query:
-                    filter["target_date__gte"] = target_date_query[0]
-                else:
-                    filter["target_date__lte"] = target_date_query[0]
-
+            date_filter(filter=filter, date_term="target_date", queries=params.get("target_date", []))
     return filter
 
 
@@ -182,20 +199,10 @@ def filter_completed_at(params, filter, method):
     if method == "GET":
         completed_ats = params.get("completed_at").split(",")
         if len(completed_ats) and "" not in completed_ats:
-            for query in completed_ats:
-                completed_at_query = query.split(";")
-                if len(completed_at_query) == 2 and "after" in completed_at_query:
-                    filter["completed_at__date__gte"] = completed_at_query[0]
-                else:
-                    filter["completed_at__lte"] = completed_at_query[0]
+            date_filter(filter=filter, date_term="completed_at__date", queries=completed_ats)
     else:
         if params.get("completed_at", None) and len(params.get("completed_at")):
-            for query in params.get("completed_at"):
-                completed_at_query = query.split(";")
-                if len(completed_at_query) == 2 and "after" in completed_at_query:
-                    filter["completed_at__date__gte"] = completed_at_query[0]
-                else:
-                    filter["completed_at__lte"] = completed_at_query[0]
+            date_filter(filter=filter, date_term="completed_at__date", queries=params.get("completed_at", []))
     return filter
 
 

docker-compose-hub.yml

@@ -3,25 +3,22 @@ version: "3.8"
 services:
         web:
                 container_name: web
-                platform: linux/amd64
                 image: makeplane/plane-frontend:latest
                 restart: always
                 command: /usr/local/bin/start.sh web/server.js web
-                environment:
-                        - NEXT_PUBLIC_ENABLE_OAUTH=${NEXT_PUBLIC_ENABLE_OAUTH:-0}
-                        - NEXT_PUBLIC_DEPLOY_URL=${NEXT_PUBLIC_DEPLOY_URL:-http://localhost/spaces}
+                env_file:
+                        - ./web/.env
                 depends_on:
                         - api
                         - worker
 
         space:
                 container_name: space
-                platform: linux/amd64
                 image: makeplane/plane-space:latest
                 restart: always
                 command: /usr/local/bin/start.sh space/server.js space
-                environment:
-                        - NEXT_PUBLIC_ENABLE_OAUTH=${NEXT_PUBLIC_ENABLE_OAUTH:-0}
+                env_file:
+                        - ./space/.env
                 depends_on:
                         - api
                         - worker
@@ -29,94 +26,22 @@ services:
 
         api:
                 container_name: api
-                platform: linux/amd64
                 image: makeplane/plane-backend:latest
                 restart: always
                 command: ./bin/takeoff
-                environment:
-                        - DEBUG=${DEBUG:-0}
-                        - DJANGO_SETTINGS_MODULE=${DJANGO_SETTINGS_MODULE:-plane.settings.selfhosted}
-                        - SENTRY_DSN=${SENTRY_DSN:-""}
-                        - PGUSER=${PGUSER:-plane}
-                        - PGPASSWORD=${PGPASSWORD:-plane}
-                        - PGHOST=${PGHOST:-plane-db}
-                        - PGDATABASE=${PGDATABASE:-plane}
-                        - DATABASE_URL=${DATABASE_URL:-postgresql://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}}
-                        - REDIS_HOST=${REDIS_HOST:-plane-redis}
-                        - REDIS_PORT=${REDIS_PORT:-6379}
-                        - REDIS_URL=${REDIS_URL:-redis://${REDIS_HOST}:6379/}
-                        - EMAIL_HOST=${EMAIL_HOST:-""}
-                        - EMAIL_HOST_USER=${EMAIL_HOST_USER:-""}
-                        - EMAIL_HOST_PASSWORD=${EMAIL_HOST_PASSWORD:-""}
-                        - EMAIL_PORT=${EMAIL_PORT:-587}
-                        - EMAIL_FROM=${EMAIL_FROM:-Team Plane <team@mailer.plane.so>}
-                        - EMAIL_USE_TLS=${EMAIL_USE_TLS:-1}
-                        - EMAIL_USE_SSL=${EMAIL_USE_SSL:-0}
-                        - AWS_REGION=${AWS_REGION:-""}
-                        - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-access-key}
-                        - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-secret-key}
-                        - AWS_S3_ENDPOINT_URL=${AWS_S3_ENDPOINT_URL:-http://plane-minio:9000}
-                        - AWS_S3_BUCKET_NAME=${AWS_S3_BUCKET_NAME:-uploads}
-                        - FILE_SIZE_LIMIT=${FILE_SIZE_LIMIT:-5242880}
-                        - OPENAI_API_BASE=${OPENAI_API_BASE:-https://api.openai.com/v1}
-                        - OPENAI_API_KEY=${OPENAI_API_KEY:-sk-}
-                        - GPT_ENGINE=${GPT_ENGINE:-gpt-3.5-turbo}
-                        - GITHUB_CLIENT_SECRET=${GITHUB_CLIENT_SECRET:-""}
-                        - DOCKERIZED=${DOCKERIZED:-1}
-                        - USE_MINIO=${USE_MINIO:-1}
-                        - NGINX_PORT=${NGINX_PORT:-80}
-                        - DEFAULT_EMAIL=${DEFAULT_EMAIL:-captain@plane.so}
-                        - DEFAULT_PASSWORD=${DEFAULT_PASSWORD:-password123}
-                        - ENABLE_SIGNUP=${ENABLE_SIGNUP:-1}
-                        - ENABLE_EMAIL_PASSWORD=${ENABLE_EMAIL_PASSWORD:-1}
-                        - ENABLE_MAGIC_LINK_LOGIN=${ENABLE_MAGIC_LINK_LOGIN:-0}
-                        - SECRET_KEY=${SECRET_KEY:-60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5}
+                env_file:
+                        - ./apiserver/.env
                 depends_on:
                         - plane-db
                         - plane-redis
 
         worker:
                 container_name: bgworker
-                platform: linux/amd64
                 image: makeplane/plane-backend:latest
                 restart: always
                 command: ./bin/worker
-                environment:
-                        - DEBUG=${DEBUG:-0}
-                        - DJANGO_SETTINGS_MODULE=${DJANGO_SETTINGS_MODULE:-plane.settings.selfhosted}
-                        - SENTRY_DSN=${SENTRY_DSN:-""}
-                        - PGUSER=${PGUSER:-plane}
-                        - PGPASSWORD=${PGPASSWORD:-plane}
-                        - PGHOST=${PGHOST:-plane-db}
-                        - PGDATABASE=${PGDATABASE:-plane}
-                        - DATABASE_URL=${DATABASE_URL:-postgresql://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}}
-                        - REDIS_HOST=${REDIS_HOST:-plane-redis}
-                        - REDIS_PORT=${REDIS_PORT:-6379}
-                        - REDIS_URL=${REDIS_URL:-redis://${REDIS_HOST}:6379/}
-                        - EMAIL_HOST=${EMAIL_HOST:-""}
-                        - EMAIL_HOST_USER=${EMAIL_HOST_USER:-""}
-                        - EMAIL_HOST_PASSWORD=${EMAIL_HOST_PASSWORD:-""}
-                        - EMAIL_PORT=${EMAIL_PORT:-587}
-                        - EMAIL_FROM=${EMAIL_FROM:-Team Plane <team@mailer.plane.so>}
-                        - EMAIL_USE_TLS=${EMAIL_USE_TLS:-1}
-                        - EMAIL_USE_SSL=${EMAIL_USE_SSL:-0}
-                        - AWS_REGION=${AWS_REGION:-""}
-                        - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-access-key}
-                        - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-secret-key}
-                        - AWS_S3_ENDPOINT_URL=${AWS_S3_ENDPOINT_URL:-http://plane-minio:9000}
-                        - AWS_S3_BUCKET_NAME=${AWS_S3_BUCKET_NAME:-uploads}
-                        - FILE_SIZE_LIMIT=${FILE_SIZE_LIMIT:-5242880}
-                        - OPENAI_API_BASE=${OPENAI_API_BASE:-https://api.openai.com/v1}
-                        - OPENAI_API_KEY=${OPENAI_API_KEY:-sk-}
-                        - GPT_ENGINE=${GPT_ENGINE:-gpt-3.5-turbo}
-                        - GITHUB_CLIENT_SECRET=${GITHUB_CLIENT_SECRET:-""}
-                        - DOCKERIZED=${DOCKERIZED:-1}
-                        - USE_MINIO=${USE_MINIO:-1}
-                        - NGINX_PORT=${NGINX_PORT:-80}
-                        - DEFAULT_EMAIL=${DEFAULT_EMAIL:-captain@plane.so}
-                        - DEFAULT_PASSWORD=${DEFAULT_PASSWORD:-password123}
-                        - ENABLE_SIGNUP=${ENABLE_SIGNUP:-1}
-                        - SECRET_KEY=${SECRET_KEY:-60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5}
+                env_file:
+                        - ./apiserver/.env
                 depends_on:
                         - api
                         - plane-db
@@ -124,46 +49,11 @@ services:
 
         beat-worker:
                 container_name: beatworker
-                platform: linux/amd64
                 image: makeplane/plane-backend:latest
                 restart: always
                 command: ./bin/beat
-                environment:
-                        - DEBUG=${DEBUG:-0}
-                        - DJANGO_SETTINGS_MODULE=${DJANGO_SETTINGS_MODULE:-plane.settings.selfhosted}
-                        - SENTRY_DSN=${SENTRY_DSN:-""}
-                        - PGUSER=${PGUSER:-plane}
-                        - PGPASSWORD=${PGPASSWORD:-plane}
-                        - PGHOST=${PGHOST:-plane-db}
-                        - PGDATABASE=${PGDATABASE:-plane}
-                        - DATABASE_URL=${DATABASE_URL:-postgresql://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}}
-                        - REDIS_HOST=${REDIS_HOST:-plane-redis}
-                        - REDIS_PORT=${REDIS_PORT:-6379}
-                        - REDIS_URL=${REDIS_URL:-redis://${REDIS_HOST}:6379/}
-                        - EMAIL_HOST=${EMAIL_HOST:-""}
-                        - EMAIL_HOST_USER=${EMAIL_HOST_USER:-""}
-                        - EMAIL_HOST_PASSWORD=${EMAIL_HOST_PASSWORD:-""}
-                        - EMAIL_PORT=${EMAIL_PORT:-587}
-                        - EMAIL_FROM=${EMAIL_FROM:-Team Plane <team@mailer.plane.so>}
-                        - EMAIL_USE_TLS=${EMAIL_USE_TLS:-1}
-                        - EMAIL_USE_SSL=${EMAIL_USE_SSL:-0}
-                        - AWS_REGION=${AWS_REGION:-""}
-                        - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-access-key}
-                        - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-secret-key}
-                        - AWS_S3_ENDPOINT_URL=${AWS_S3_ENDPOINT_URL:-http://plane-minio:9000}
-                        - AWS_S3_BUCKET_NAME=${AWS_S3_BUCKET_NAME:-uploads}
-                        - FILE_SIZE_LIMIT=${FILE_SIZE_LIMIT:-5242880}
-                        - OPENAI_API_BASE=${OPENAI_API_BASE:-https://api.openai.com/v1}
-                        - OPENAI_API_KEY=${OPENAI_API_KEY:-sk-}
-                        - GPT_ENGINE=${GPT_ENGINE:-gpt-3.5-turbo}
-                        - GITHUB_CLIENT_SECRET=${GITHUB_CLIENT_SECRET:-""}
-                        - DOCKERIZED=${DOCKERIZED:-1}
-                        - USE_MINIO=${USE_MINIO:-1}
-                        - NGINX_PORT=${NGINX_PORT:-80}
-                        - DEFAULT_EMAIL=${DEFAULT_EMAIL:-captain@plane.so}
-                        - DEFAULT_PASSWORD=${DEFAULT_PASSWORD:-password123}
-                        - ENABLE_SIGNUP=${ENABLE_SIGNUP:-1}
-                        - SECRET_KEY=${SECRET_KEY:-60gp0byfz2dvffa45cxl20p1scy9xbpf6d8c5y0geejgkyp1b5}
+                env_file:
+                        - ./apiserver/.env
                 depends_on:
                         - api
                         - plane-db
@@ -177,11 +67,13 @@ services:
                 command: postgres -c 'max_connections=1000'
                 volumes:
                         - pgdata:/var/lib/postgresql/data
+                env_file:
+                        - .env
                 environment:
-                        - POSTGRES_USER=${POSTGRES_USER:-plane}
-                        - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-plane}
-                        - POSTGRES_DB=${POSTGRES_DB:-plane}
-                        - PGDATA=${PGDATA:-/var/lib/postgresql/data}
+                        POSTGRES_USER: ${PGUSER}
+                        POSTGRES_DB: ${PGDATABASE}
+                        POSTGRES_PASSWORD: ${PGPASSWORD}
+                        PGDATA: /var/lib/postgresql/data
 
         plane-redis:
                 container_name: plane-redis
@@ -197,32 +89,32 @@ services:
                 command: server /export --console-address ":9090"
                 volumes:
                         - uploads:/export
+                env_file:
+                        - .env
                 environment:
-                        - MINIO_ROOT_USER=${MINIO_ROOT_USER:-access-key}
-                        - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD:-secret-key}
+                        MINIO_ROOT_USER: ${AWS_ACCESS_KEY_ID}
+                        MINIO_ROOT_PASSWORD: ${AWS_SECRET_ACCESS_KEY}
 
         createbuckets:
                 image: minio/mc
                 entrypoint: >
                         /bin/sh -c " /usr/bin/mc config host add plane-minio http://plane-minio:9000 \$AWS_ACCESS_KEY_ID \$AWS_SECRET_ACCESS_KEY; /usr/bin/mc mb plane-minio/\$AWS_S3_BUCKET_NAME; /usr/bin/mc anonymous set download plane-minio/\$AWS_S3_BUCKET_NAME; exit 0; "
-                environment:
-                        - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-access-key}
-                        - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-secret-key}
-                        - AWS_S3_BUCKET_NAME=${AWS_S3_BUCKET_NAME:-uploads}
+                env_file:
+                        - .env
                 depends_on:
                         - plane-minio
 
         # Comment this if you already have a reverse proxy running
         proxy:
                 container_name: proxy
-                platform: linux/amd64
                 image: makeplane/plane-proxy:latest
                 ports:
                         - ${NGINX_PORT}:80
+                env_file:
+                        - .env
                 environment:
-                        - NGINX_PORT=${NGINX_PORT:-80}
-                        - FILE_SIZE_LIMIT=${FILE_SIZE_LIMIT:-5242880}
-                        - BUCKET_NAME=${AWS_S3_BUCKET_NAME:-uploads}
+                        FILE_SIZE_LIMIT: ${FILE_SIZE_LIMIT:-5242880}
+                        BUCKET_NAME: ${AWS_S3_BUCKET_NAME:-uploads}
                 depends_on:
                         - web
                         - api

web/components/pages/pages-list/recent-pages-list.tsx

@@ -43,7 +43,7 @@ export const RecentPagesList: React.FC<TPagesListProps> = ({ viewType }) => {
             if (pages[key].length === 0) return null;
 
             return (
-              <div key={key} className="h-full overflow-hidden pb-9">
+              <div key={key} className="h-full overflow-hidden">
                 <h2 className="text-xl font-semibold capitalize mb-2">
                   {replaceUnderscoreIfSnakeCase(key)}
                 </h2>