Merge pull request #288 from shancds/test/invitation-process

feat(assignee-selector): enhance member invitation functionality and …

.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)",
+      "Bash(npm run build:*)",
+      "Bash(npm run type-check:*)",
+      "Bash(npm run:*)",
+      "Bash(grep:*)",
+      "Bash(rm:*)"
+    ],
+    "deny": []
+  }
+}

.cursor/rules/antd-components.mdc

@@ -0,0 +1,237 @@
+---
+alwaysApply: true
+---
+# Ant Design Import Rules for Worklenz
+
+## 🚨 CRITICAL: Always Use Centralized Imports
+
+**NEVER import Ant Design components directly from 'antd' or '@ant-design/icons'**
+
+### ✅ Correct Import Pattern
+```typescript
+import { Button, Input, Select, EditOutlined, PlusOutlined } from '@antd-imports';
+// or
+import { Button, Input, Select, EditOutlined, PlusOutlined } from '@/shared/antd-imports';
+```
+
+### ❌ Forbidden Import Patterns
+```typescript
+// NEVER do this:
+import { Button, Input, Select } from 'antd';
+import { EditOutlined, PlusOutlined } from '@ant-design/icons';
+```
+
+## Why This Rule Exists
+
+### Benefits of Centralized Imports:
+- **Better Tree-Shaking**: Optimized bundle size through centralized management
+- **Consistent React Context**: Proper context sharing across components
+- **Type Safety**: Centralized TypeScript definitions
+- **Maintainability**: Single source of truth for all Ant Design imports
+- **Performance**: Reduced bundle size and improved loading times
+
+## What's Available in `@antd-imports`
+
+### Core Components
+- **Layout**: Layout, Row, Col, Flex, Divider, Space
+- **Navigation**: Menu, Tabs, Breadcrumb, Pagination
+- **Data Entry**: Input, Select, DatePicker, TimePicker, Form, Checkbox, InputNumber
+- **Data Display**: Table, List, Card, Tag, Avatar, Badge, Progress, Statistic
+- **Feedback**: Modal, Drawer, Alert, Message, Notification, Spin, Skeleton, Result
+- **Other**: Button, Typography, Tooltip, Popconfirm, Dropdown, ConfigProvider
+
+### Icons
+Common icons including: EditOutlined, DeleteOutlined, PlusOutlined, MoreOutlined, CheckOutlined, CloseOutlined, CalendarOutlined, UserOutlined, TeamOutlined, and many more.
+
+### Utilities
+- **appMessage**: Centralized message utility
+- **appNotification**: Centralized notification utility
+- **antdConfig**: Default Ant Design configuration
+- **taskManagementAntdConfig**: Task-specific configuration
+
+## Implementation Guidelines
+
+### When Creating New Components:
+1. **Always** import from `@/shared/antd-imports`
+2. Use `appMessage` and `appNotification` for user feedback
+3. Apply `antdConfig` for consistent styling
+4. Use `taskManagementAntdConfig` for task-related components
+
+### When Refactoring Existing Code:
+1. Replace direct 'antd' imports with `@/shared/antd-imports`
+2. Replace direct '@ant-design/icons' imports with `@/shared/antd-imports`
+3. Update any custom message/notification calls to use the utilities
+
+### File Location
+The centralized import file is located at: `worklenz-frontend/src/shared/antd-imports.ts`
+
+## Examples
+
+### Component Creation
+```typescript
+import React from 'react';
+import { Button, Input, Modal, EditOutlined, appMessage } from '@antd-imports';
+
+const MyComponent = () => {
+  const handleClick = () => {
+    appMessage.success('Operation completed!');
+  };
+
+  return (
+    <Button icon={<EditOutlined />} onClick={handleClick}>
+      Edit Item
+    </Button>
+  );
+};
+```
+
+### Form Implementation
+```typescript
+import { Form, Input, Select, Button, DatePicker } from '@antd-imports';
+
+const MyForm = () => {
+  return (
+    <Form layout="vertical">
+      <Form.Item label="Name" name="name">
+        <Input />
+      </Form.Item>
+      <Form.Item label="Type" name="type">
+        <Select options={options} />
+      </Form.Item>
+      <Form.Item label="Date" name="date">
+        <DatePicker />
+      </Form.Item>
+    </Form>
+  );
+};
+```
+
+## Enforcement
+
+This rule is **MANDATORY** and applies to:
+- All new component development
+- All code refactoring
+- All bug fixes
+- All feature implementations
+
+**Violations will result in code review rejection.**
+
+### File Path:
+The centralized file is located at: `worklenz-frontend/src/shared/antd-imports.ts`
+# Ant Design Import Rules for Worklenz
+
+## 🚨 CRITICAL: Always Use Centralized Imports
+
+**NEVER import Ant Design components directly from 'antd' or '@ant-design/icons'**
+
+### ✅ Correct Import Pattern
+```typescript
+import { Button, Input, Select, EditOutlined, PlusOutlined } from '@antd-imports';
+// or
+import { Button, Input, Select, EditOutlined, PlusOutlined } from '@/shared/antd-imports';
+```
+
+### ❌ Forbidden Import Patterns
+```typescript
+// NEVER do this:
+import { Button, Input, Select } from 'antd';
+import { EditOutlined, PlusOutlined } from '@ant-design/icons';
+```
+
+## Why This Rule Exists
+
+### Benefits of Centralized Imports:
+- **Better Tree-Shaking**: Optimized bundle size through centralized management
+- **Consistent React Context**: Proper context sharing across components
+- **Type Safety**: Centralized TypeScript definitions
+- **Maintainability**: Single source of truth for all Ant Design imports
+- **Performance**: Reduced bundle size and improved loading times
+
+## What's Available in `@antd-imports`
+
+### Core Components
+- **Layout**: Layout, Row, Col, Flex, Divider, Space
+- **Navigation**: Menu, Tabs, Breadcrumb, Pagination
+- **Data Entry**: Input, Select, DatePicker, TimePicker, Form, Checkbox, InputNumber
+- **Data Display**: Table, List, Card, Tag, Avatar, Badge, Progress, Statistic
+- **Feedback**: Modal, Drawer, Alert, Message, Notification, Spin, Skeleton, Result
+- **Other**: Button, Typography, Tooltip, Popconfirm, Dropdown, ConfigProvider
+
+### Icons
+Common icons including: EditOutlined, DeleteOutlined, PlusOutlined, MoreOutlined, CheckOutlined, CloseOutlined, CalendarOutlined, UserOutlined, TeamOutlined, and many more.
+
+### Utilities
+- **appMessage**: Centralized message utility
+- **appNotification**: Centralized notification utility
+- **antdConfig**: Default Ant Design configuration
+- **taskManagementAntdConfig**: Task-specific configuration
+
+## Implementation Guidelines
+
+### When Creating New Components:
+1. **Always** import from `@antd-imports` or `@/shared/antd-imports`
+2. Use `appMessage` and `appNotification` for user feedback
+3. Apply `antdConfig` for consistent styling
+4. Use `taskManagementAntdConfig` for task-related components
+
+### When Refactoring Existing Code:
+1. Replace direct 'antd' imports with `@antd-imports`
+2. Replace direct '@ant-design/icons' imports with `@antd-imports`
+3. Update any custom message/notification calls to use the utilities
+
+### File Location
+The centralized import file is located at: `worklenz-frontend/src/shared/antd-imports.ts`
+
+## Examples
+
+### Component Creation
+```typescript
+import React from 'react';
+import { Button, Input, Modal, EditOutlined, appMessage } from '@antd-imports';
+
+const MyComponent = () => {
+  const handleClick = () => {
+    appMessage.success('Operation completed!');
+  };
+
+  return (
+    <Button icon={<EditOutlined />} onClick={handleClick}>
+      Edit Item
+    </Button>
+  );
+};
+```
+
+### Form Implementation
+```typescript
+import { Form, Input, Select, Button, DatePicker } from '@antd-imports';
+
+const MyForm = () => {
+  return (
+    <Form layout="vertical">
+      <Form.Item label="Name" name="name">
+        <Input />
+      </Form.Item>
+      <Form.Item label="Type" name="type">
+        <Select options={options} />
+      </Form.Item>
+      <Form.Item label="Date" name="date">
+        <DatePicker />
+      </Form.Item>
+    </Form>
+  );
+};
+```
+
+## Enforcement
+
+This rule is **MANDATORY** and applies to:
+- All new component development
+- All code refactoring
+- All bug fixes
+- All feature implementations
+
+**Violations will result in code review rejection.**
+
+### File Path:
+The centralized file is located at: `worklenz-frontend/src/shared/antd-imports.ts`

README.md

@@ -1,11 +1,29 @@
 <h1 align="center">
     <a href="https://worklenz.com" target="_blank" rel="noopener noreferrer">
-        <img src="https://app.worklenz.com/assets/icons/icon-144x144.png" alt="Worklenz Logo" width="75">
+        <img src="https://s3.us-west-2.amazonaws.com/worklenz.com/assets/icon-144x144.png" alt="Worklenz Logo" width="75">
     </a>
     <br>
     Worklenz    
 </h1>
 
+<p align="center">
+    <a href="https://github.com/Worklenz/worklenz/blob/main/LICENSE">
+        <img src="https://img.shields.io/badge/license-AGPL--3.0-blue.svg" alt="License">
+    </a>
+    <a href="https://github.com/Worklenz/worklenz/releases">
+        <img src="https://img.shields.io/github/v/release/Worklenz/worklenz" alt="Release">
+    </a>
+    <a href="https://github.com/Worklenz/worklenz/stargazers">
+        <img src="https://img.shields.io/github/stars/Worklenz/worklenz" alt="Stars">
+    </a>
+    <a href="https://github.com/Worklenz/worklenz/network/members">
+        <img src="https://img.shields.io/github/forks/Worklenz/worklenz" alt="Forks">
+    </a>
+    <a href="https://github.com/Worklenz/worklenz/issues">
+        <img src="https://img.shields.io/github/issues/Worklenz/worklenz" alt="Issues">
+    </a>
+</p>
+
 <p align="center">
     <a href="https://worklenz.com/task-management/">Task Management</a> |
     <a href="https://worklenz.com/time-tracking/">Time Tracking</a> |
@@ -27,6 +45,24 @@
 Worklenz is a project management tool designed to help organizations improve their efficiency. It provides a
 comprehensive solution for managing projects, tasks, and collaboration within teams.
 
+## Table of Contents
+
+- [Features](#features)
+- [Tech Stack](#tech-stack)
+- [Getting Started](#getting-started)
+  - [Quick Start (Docker)](#-quick-start-docker---recommended)
+  - [Manual Installation](#️-manual-installation-for-development)
+- [Deployment](#deployment)
+  - [Local Development](#local-development-with-docker)
+  - [Remote Server Deployment](#remote-server-deployment)
+- [Configuration](#configuration)
+- [MinIO Integration](#minio-integration)
+- [Security](#security)
+- [Analytics](#analytics)
+- [Screenshots](#screenshots)
+- [Contributing](#contributing)
+- [License](#license)
+
 ## Features
 
 - **Project Planning**: Create and organize projects, assign tasks to team members.
@@ -50,42 +86,80 @@ This repository contains the frontend and backend code for Worklenz.
 
 ## Getting Started
 
-These instructions will help you set up and run the Worklenz project on your local machine for development and testing purposes.
+Choose your preferred setup method below. Docker is recommended for quick setup and testing.
 
-### Prerequisites
+### 🚀 Quick Start (Docker - Recommended)
 
-- Node.js (version 18 or higher)
-- PostgreSQL database
-- An S3-compatible storage service (like MinIO) or Azure Blob Storage
+The fastest way to get Worklenz running locally with all dependencies included.
 
-### Option 1: Manual Installation
+**Prerequisites:**
+- Docker and Docker Compose installed on your system
+- Git
 
-1. Clone the repository
+**Steps:**
+
+1. Clone the repository:
 ```bash
 git clone https://github.com/Worklenz/worklenz.git
 cd worklenz
 ```
 
-2. Set up environment variables
-   - Copy the example environment files
-   ```bash
-   cp .env.example .env
-   cp worklenz-backend/.env.example worklenz-backend/.env
-   ```
-   - Update the environment variables with your configuration
-
-3. Install dependencies
+2. Start the Docker containers:
 ```bash
-# Install backend dependencies
+docker-compose up -d
+```
+
+3. Access the application:
+   - **Frontend**: http://localhost:5000
+   - **Backend API**: http://localhost:3000
+   - **MinIO Console**: http://localhost:9001 (login: minioadmin/minioadmin)
+
+4. To stop the services:
+```bash
+docker-compose down
+```
+
+**Alternative startup methods:**
+- **Windows**: Run `start.bat`
+- **Linux/macOS**: Run `./start.sh`
+
+**Video Guide**: For a visual walkthrough of the local Docker deployment process, check out our [step-by-step video guide](https://www.youtube.com/watch?v=AfwAKxJbqLg).
+
+### 🛠️ Manual Installation (For Development)
+
+For developers who want to run the services individually or customize the setup.
+
+**Prerequisites:**
+- Node.js (version 18 or higher)
+- PostgreSQL (version 15 or higher)
+- An S3-compatible storage service (like MinIO) or Azure Blob Storage
+
+**Steps:**
+
+1. Clone the repository:
+```bash
+git clone https://github.com/Worklenz/worklenz.git
+cd worklenz
+```
+
+2. Set up environment variables:
+```bash
+cp worklenz-backend/.env.template worklenz-backend/.env
+# Update the environment variables with your configuration
+```
+
+3. Install dependencies:
+```bash
+# Backend dependencies
 cd worklenz-backend
 npm install
 
-# Install frontend dependencies
+# Frontend dependencies
 cd ../worklenz-frontend
 npm install
 ```
 
-4. Set up the database
+4. Set up the database:
 ```bash
 # Create a PostgreSQL database named worklenz_db
 cd worklenz-backend
@@ -101,49 +175,47 @@ psql -U your_username -d worklenz_db -f database/sql/2_dml.sql
 psql -U your_username -d worklenz_db -f database/sql/5_database_user.sql
 ```
 
-5. Start the development servers
+5. Start the development servers:
 ```bash
-# In one terminal, start the backend
+# Terminal 1: Start the backend
 cd worklenz-backend
 npm run dev
 
-# In another terminal, start the frontend
+# Terminal 2: Start the frontend
 cd worklenz-frontend
 npm run dev
 ```
 
 6. Access the application at http://localhost:5000
 
-### Option 2: Docker Setup
+## Deployment
 
-The project includes a fully configured Docker setup with:
-- Frontend React application
-- Backend server
-- PostgreSQL database
-- MinIO for S3-compatible storage
+For local development, follow the [Quick Start (Docker)](#-quick-start-docker---recommended) section above.
 
-1. Clone the repository:
-```bash
-git clone https://github.com/Worklenz/worklenz.git
-cd worklenz
-```
+### Remote Server Deployment
 
-2. Start the Docker containers (choose one option):
+When deploying to a remote server:
 
-**Using Docker Compose directly**
-```bash
-docker-compose up -d
-```
+1. Set up the environment files with your server's hostname:
+   ```bash
+   # For HTTP/WS
+   ./update-docker-env.sh your-server-hostname
+   
+   # For HTTPS/WSS
+   ./update-docker-env.sh your-server-hostname true
+   ```
 
-3. The application will be available at:
-   - Frontend: http://localhost:5000
-   - Backend API: http://localhost:3000
-   - MinIO Console: http://localhost:9001 (login with minioadmin/minioadmin)
+2. Pull and run the latest Docker images:
+   ```bash
+   docker-compose pull
+   docker-compose up -d
+   ```
 
-4. To stop the services:
-```bash
-docker-compose down
-```
+3. Access the application through your server's hostname:
+   - Frontend: http://your-server-hostname:5000
+   - Backend API: http://your-server-hostname:3000
+
+4. **Video Guide**: For a complete walkthrough of deploying Worklenz to a remote server, check out our [deployment video guide](https://www.youtube.com/watch?v=CAZGu2iOXQs&t=10s).
 
 ## Configuration
 
@@ -158,16 +230,46 @@ Worklenz requires several environment variables to be configured for proper oper
 
 Please refer to the `.env.example` files for a full list of required variables.
 
-### MinIO Integration
+The Docker setup uses environment variables to configure the services:
+
+- **Frontend:**
+  - `VITE_API_URL`: URL of the backend API (default: http://backend:3000 for container networking)
+  - `VITE_SOCKET_URL`: WebSocket URL for real-time communication (default: ws://backend:3000)
+
+- **Backend:**
+  - Database connection parameters
+  - Storage configuration
+  - Other backend settings
+
+For custom configuration, edit the `.env` file or the `update-docker-env.sh` script.
+
+## MinIO Integration
 
 The project uses MinIO as an S3-compatible object storage service, which provides an open-source alternative to AWS S3 for development and production.
 
+### Working with MinIO
+
+MinIO provides an S3-compatible API, so any code that works with S3 will work with MinIO by simply changing the endpoint URL. The backend has been configured to use MinIO by default, with no additional configuration required.
+
 - **MinIO Console**: http://localhost:9001
   - Username: minioadmin
   - Password: minioadmin
 
 - **Default Bucket**: worklenz-bucket (created automatically when the containers start)
 
+### Backend Storage Configuration
+
+The backend is pre-configured to use MinIO with the following settings:
+
+```javascript
+// S3 credentials with MinIO defaults
+export const REGION = process.env.AWS_REGION || "us-east-1";
+export const BUCKET = process.env.AWS_BUCKET || "worklenz-bucket";
+export const S3_URL = process.env.S3_URL || "http://minio:9000/worklenz-bucket";
+export const S3_ACCESS_KEY_ID = process.env.AWS_ACCESS_KEY_ID || "minioadmin";
+export const S3_SECRET_ACCESS_KEY = process.env.AWS_SECRET_ACCESS_KEY || "minioadmin";
+```
+
 ### Security Considerations
 
 For production deployments:
@@ -178,19 +280,32 @@ For production deployments:
 4. Enable HTTPS for all public endpoints
 5. Review and update dependencies regularly
 
-## Contributing
-
-We welcome contributions from the community! If you'd like to contribute, please follow our [contributing guidelines](CONTRIBUTING.md).
-
 ## Security
 
 If you believe you have found a security vulnerability in Worklenz, we encourage you to responsibly disclose this and not open a public issue. We will investigate all legitimate reports.
 
 Email [info@worklenz.com](mailto:info@worklenz.com) to disclose any security vulnerabilities.
 
-## License
+## Analytics
 
-This project is licensed under the [MIT License](LICENSE).
+Worklenz uses Google Analytics to understand how the application is being used. This helps us improve the application and make better decisions about future development.
+
+### What We Track
+- Anonymous usage statistics
+- Page views and navigation patterns
+- Feature usage
+- Browser and device information
+
+### Privacy
+- Analytics is opt-in only
+- No personal information is collected
+- Users can opt-out at any time
+- Data is stored according to Google's privacy policy
+
+### How to Opt-Out
+If you've previously opted in and want to opt-out:
+1. Clear your browser's local storage for the Worklenz domain
+2. Or click the "Decline" button in the analytics notice if it appears
 
 ## Screenshots
 
@@ -240,206 +355,13 @@ This project is licensed under the [MIT License](LICENSE).
   </a>
 </p>
 
-### Contributing
+## Contributing
 
-We welcome contributions from the community! If you'd like to contribute, please follow
-our [contributing guidelines](CONTRIBUTING.md).
+We welcome contributions from the community! If you'd like to contribute, please follow our [contributing guidelines](CONTRIBUTING.md).
 
-### License
+## License
 
 Worklenz is open source and released under the [GNU Affero General Public License Version 3 (AGPLv3)](LICENSE).
 
 By contributing to Worklenz, you agree that your contributions will be licensed under its AGPL.
 
-# Worklenz React
-
-This repository contains the React version of Worklenz with a Docker setup for easy development and deployment.
-
-## Getting Started with Docker
-
-The project includes a fully configured Docker setup with:
-- Frontend React application
-- Backend server
-- PostgreSQL database
-- MinIO for S3-compatible storage
-
-### Prerequisites
-
-- Docker and Docker Compose installed on your system
-- Git
-
-### Quick Start
-
-1. Clone the repository:
-```bash
-git clone https://github.com/Worklenz/worklenz.git
-cd worklenz
-```
-
-2. Start the Docker containers (choose one option):
-
-**Option 1: Using the provided scripts (easiest)**
-- On Windows:
-  ```
-  start.bat
-  ```
-- On Linux/macOS:
-  ```bash
-  ./start.sh
-  ```
-
-**Option 2: Using Docker Compose directly**
-```bash
-docker-compose up -d
-```
-
-3. The application will be available at:
-   - Frontend: http://localhost:5000
-   - Backend API: http://localhost:3000
-   - MinIO Console: http://localhost:9001 (login with minioadmin/minioadmin)
-
-4. To stop the services (choose one option):
-
-**Option 1: Using the provided scripts**
-- On Windows:
-  ```
-  stop.bat
-  ```
-- On Linux/macOS:
-  ```bash
-  ./stop.sh
-  ```
-
-**Option 2: Using Docker Compose directly**
-```bash
-docker-compose down
-```
-
-## MinIO Integration
-
-The project uses MinIO as an S3-compatible object storage service, which provides an open-source alternative to AWS S3 for development and production.
-
-### Working with MinIO
-
-MinIO provides an S3-compatible API, so any code that works with S3 will work with MinIO by simply changing the endpoint URL. The backend has been configured to use MinIO by default, with no additional configuration required.
-
-- **MinIO Console**: http://localhost:9001
-  - Username: minioadmin
-  - Password: minioadmin
-
-- **Default Bucket**: worklenz-bucket (created automatically when the containers start)
-
-### Backend Storage Configuration
-
-The backend is pre-configured to use MinIO with the following settings:
-
-```javascript
-// S3 credentials with MinIO defaults
-export const REGION = process.env.AWS_REGION || "us-east-1";
-export const BUCKET = process.env.AWS_BUCKET || "worklenz-bucket";
-export const S3_URL = process.env.S3_URL || "http://minio:9000/worklenz-bucket";
-export const S3_ACCESS_KEY_ID = process.env.AWS_ACCESS_KEY_ID || "minioadmin";
-export const S3_SECRET_ACCESS_KEY = process.env.AWS_SECRET_ACCESS_KEY || "minioadmin";
-```
-
-The S3 client is initialized with special MinIO configuration:
-
-```javascript
-const s3Client = new S3Client({
-  region: REGION,
-  credentials: {
-    accessKeyId: S3_ACCESS_KEY_ID || "",
-    secretAccessKey: S3_SECRET_ACCESS_KEY || "",
-  },
-  endpoint: getEndpointFromUrl(), // Extracts endpoint from S3_URL
-  forcePathStyle: true, // Required for MinIO
-});
-```
-
-### Environment Configuration
-
-The project uses the following environment file structure:
-
-- **Frontend**:
-  - `worklenz-frontend/.env.development` - Development environment variables
-  - `worklenz-frontend/.env.production` - Production build variables
-  
-- **Backend**:
-  - `worklenz-backend/.env` - Backend environment variables
-
-### Setting Up Environment Files
-
-The Docker environment script will create or overwrite all environment files:
-
-```bash
-# For HTTP/WS
-./update-docker-env.sh your-hostname
-
-# For HTTPS/WSS
-./update-docker-env.sh your-hostname true
-```
-
-This script generates properly configured environment files for both development and production environments.
-
-## Docker Deployment
-
-### Local Development with Docker
-
-1. Set up the environment files:
-   ```bash
-   # For HTTP/WS
-   ./update-docker-env.sh
-   
-   # For HTTPS/WSS
-   ./update-docker-env.sh localhost true
-   ```
-
-2. Run the application using Docker Compose:
-   ```bash
-   docker-compose up -d
-   ```
-
-3. Access the application:
-   - Frontend: http://localhost:5000
-   - Backend API: http://localhost:3000 (or https://localhost:3000 with SSL)
-
-### Remote Server Deployment
-
-When deploying to a remote server:
-
-1. Set up the environment files with your server's hostname:
-   ```bash
-   # For HTTP/WS
-   ./update-docker-env.sh your-server-hostname
-   
-   # For HTTPS/WSS
-   ./update-docker-env.sh your-server-hostname true
-   ```
-   
-   This ensures that the frontend correctly connects to the backend API.
-
-2. Pull and run the latest Docker images:
-   ```bash
-   docker-compose pull
-   docker-compose up -d
-   ```
-
-3. Access the application through your server's hostname:
-   - Frontend: http://your-server-hostname:5000
-   - Backend API: http://your-server-hostname:3000
-
-### Environment Configuration
-
-The Docker setup uses environment variables to configure the services:
-
-- Frontend:
-  - `VITE_API_URL`: URL of the backend API (default: http://backend:3000 for container networking)
-  - `VITE_SOCKET_URL`: WebSocket URL for real-time communication (default: ws://backend:3000)
-
-- Backend:
-  - Database connection parameters
-  - Storage configuration
-  - Other backend settings
-
-For custom configuration, edit the `.env` file or the `update-docker-env.sh` script.
-

SETUP_THE_PROJECT.md

@@ -4,7 +4,7 @@ Getting started with development is a breeze! Follow these steps and you'll be c
 
 ## Requirements
 
-- Node.js version v16 or newer - [Node.js](https://nodejs.org/en/download/)
+- Node.js version v20 or newer - [Node.js](https://nodejs.org/en/download/)
 - PostgreSQL version v15 or newer - [PostgreSQL](https://www.postgresql.org/download/)
 - S3-compatible storage (like MinIO) for file storage
 
@@ -38,7 +38,7 @@ Getting started with development is a breeze! Follow these steps and you'll be c
    npm start
    ```
    
-4. Navigate to [http://localhost:5173](http://localhost:5173)
+4. Navigate to [http://localhost:5173](http://localhost:5173) (development server)
 
 ### Backend installation
    
@@ -126,7 +126,7 @@ For an easier setup, you can use Docker and Docker Compose:
    ```
 
 3. Access the application:
-   - Frontend: http://localhost:5000
+   - Frontend: http://localhost:5000 (Docker production build)
    - Backend API: http://localhost:3000
    - MinIO Console: http://localhost:9001 (login with minioadmin/minioadmin)
 

backup.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -eu
+
+# Adjust these as needed:
+CONTAINER=worklenz_db
+DB_NAME=worklenz_db
+DB_USER=postgres
+BACKUP_DIR=./pg_backups
+mkdir -p "$BACKUP_DIR"
+
+timestamp=$(date +%Y-%m-%d_%H-%M-%S)
+outfile="${BACKUP_DIR}/${DB_NAME}_${timestamp}.sql"
+echo "Creating backup $outfile ..."
+
+docker exec -t "$CONTAINER" pg_dump -U "$DB_USER" -d "$DB_NAME" > "$outfile"
+echo "Backup saved to $outfile"

docker-compose.yml

@@ -7,8 +7,8 @@ services:
     ports:
       - "5000:5000"
     depends_on:
-      backend:
-        condition: service_started
+      - backend
+    restart: unless-stopped
     env_file:
       - ./worklenz-frontend/.env.production
     networks:
@@ -26,6 +26,7 @@ services:
         condition: service_healthy
       minio:
         condition: service_started
+    restart: unless-stopped
     env_file:
       - ./worklenz-backend/.env
     networks:
@@ -37,6 +38,7 @@ services:
     ports:
       - "9000:9000"
       - "9001:9001"
+    restart: unless-stopped
     environment:
       MINIO_ROOT_USER: ${S3_ACCESS_KEY_ID:-minioadmin}
       MINIO_ROOT_PASSWORD: ${S3_SECRET_ACCESS_KEY:-minioadmin}
@@ -52,13 +54,14 @@ services:
     container_name: worklenz_createbuckets
     depends_on:
       - minio
+    restart: on-failure
     entrypoint: >
       /bin/sh -c '
         echo "Waiting for MinIO to start...";
         sleep 15;
         for i in 1 2 3 4 5; do
           echo "Attempt $i to connect to MinIO...";
-          if /usr/bin/mc config host add myminio http://minio:9000 minioadmin minioadmin; then
+          if /usr/bin/mc alias set myminio http://minio:9000 minioadmin minioadmin; then
             echo "Successfully connected to MinIO!";
             /usr/bin/mc mb --ignore-existing myminio/worklenz-bucket;
             /usr/bin/mc policy set public myminio/worklenz-bucket;
@@ -80,32 +83,79 @@ services:
       POSTGRES_DB: ${DB_NAME:-worklenz_db}
       POSTGRES_PASSWORD: ${DB_PASSWORD:-password}
     healthcheck:
-      test: [ "CMD-SHELL", "pg_isready -d ${DB_NAME:-worklenz_db} -U ${DB_USER:-postgres}" ]
+      test:
+        [
+          "CMD-SHELL",
+          "pg_isready -d ${DB_NAME:-worklenz_db} -U ${DB_USER:-postgres}",
+        ]
       interval: 10s
       timeout: 5s
       retries: 5
+    restart: unless-stopped
     networks:
       - worklenz
     volumes:
       - worklenz_postgres_data:/var/lib/postgresql/data
       - type: bind
-        source: ./worklenz-backend/database
-        target: /docker-entrypoint-initdb.d
+        source: ./worklenz-backend/database/sql
+        target: /docker-entrypoint-initdb.d/sql
         consistency: cached
+      - type: bind
+        source: ./worklenz-backend/database/migrations
+        target: /docker-entrypoint-initdb.d/migrations
+        consistency: cached
+      - type: bind
+        source: ./worklenz-backend/database/00_init.sh
+        target: /docker-entrypoint-initdb.d/00_init.sh
+        consistency: cached
+      - type: bind
+        source: ./pg_backups
+        target: /docker-entrypoint-initdb.d/pg_backups
     command: >
-      bash -c ' if command -v apt-get >/dev/null 2>&1; then
-        apt-get update && apt-get install -y dos2unix
-      elif command -v apk >/dev/null 2>&1; then
-        apk add --no-cache dos2unix
-      fi && find /docker-entrypoint-initdb.d -type f -name "*.sh" -exec sh -c '\''
-        dos2unix "{}" 2>/dev/null || true
-        chmod +x "{}"
-      '\'' \; && exec docker-entrypoint.sh postgres '
+        bash -c '
+          if command -v apt-get >/dev/null 2>&1; then
+            apt-get update && apt-get install -y dos2unix
+          elif command -v apk >/dev/null 2>&1; then
+            apk add --no-cache dos2unix
+          fi
+
+          find /docker-entrypoint-initdb.d -type f -name "*.sh" -exec sh -c '"'"'
+            for f; do
+              dos2unix "$f" 2>/dev/null || true
+              chmod +x "$f"
+            done
+          '"'"' sh {} +
+
+          exec docker-entrypoint.sh postgres
+        '
+  db-backup:
+    image: postgres:15
+    container_name: worklenz_db_backup
+    environment:
+      POSTGRES_USER: ${DB_USER:-postgres}
+      POSTGRES_DB: ${DB_NAME:-worklenz_db}
+      POSTGRES_PASSWORD: ${DB_PASSWORD:-password}
+    depends_on:
+      db:
+        condition: service_healthy
+    volumes:
+      - ./pg_backups:/pg_backups #host dir for backups files
+    #setup bassh loop to backup data evey 24h
+    command: >
+           bash -c 'while true; do
+              sleep 86400;
+              PGPASSWORD=$$POSTGRES_PASSWORD pg_dump -h worklenz_db -U $$POSTGRES_USER -d $$POSTGRES_DB \
+              > /pg_backups/worklenz_db_$$(date +%Y-%m-%d_%H-%M-%S).sql;
+              find /pg_backups -type f -name "*.sql" -mtime +30 -delete;
+            done'
+    restart: unless-stopped
+    networks:
+      - worklenz
 
 volumes:
   worklenz_postgres_data:
   worklenz_minio_data:
-
+  pgdata:
 
 networks:
   worklenz:

docs/api/task-breakdown-api.md

@@ -1,195 +0,0 @@
-# Task Breakdown API
-
-## Get Task Financial Breakdown
-
-**Endpoint:** `GET /api/project-finance/task/:id/breakdown`
-
-**Description:** Retrieves detailed financial breakdown for a single task, including members grouped by job roles with labor hours and costs.
-
-### Parameters
-
-- `id` (path parameter): UUID of the task
-
-### Response
-
-```json
-{
-  "success": true,
-  "body": {
-    "task": {
-      "id": "uuid",
-      "name": "Task Name",
-      "project_id": "uuid",
-      "billable": true,
-      "estimated_hours": 10.5,
-      "logged_hours": 8.25,
-      "estimated_labor_cost": 525.0,
-      "actual_labor_cost": 412.5,
-      "fixed_cost": 100.0,
-      "total_estimated_cost": 625.0,
-      "total_actual_cost": 512.5
-    },
-    "grouped_members": [
-      {
-        "jobRole": "Frontend Developer",
-        "estimated_hours": 5.25,
-        "logged_hours": 4.0,
-        "estimated_cost": 262.5,
-        "actual_cost": 200.0,
-        "members": [
-          {
-            "team_member_id": "uuid",
-            "name": "John Doe",
-            "avatar_url": "https://...",
-            "hourly_rate": 50.0,
-            "estimated_hours": 5.25,
-            "logged_hours": 4.0,
-            "estimated_cost": 262.5,
-            "actual_cost": 200.0
-          }
-        ]
-      },
-      {
-        "jobRole": "Backend Developer",
-        "estimated_hours": 5.25,
-        "logged_hours": 4.25,
-        "estimated_cost": 262.5,
-        "actual_cost": 212.5,
-        "members": [
-          {
-            "team_member_id": "uuid",
-            "name": "Jane Smith",
-            "avatar_url": "https://...",
-            "hourly_rate": 50.0,
-            "estimated_hours": 5.25,
-            "logged_hours": 4.25,
-            "estimated_cost": 262.5,
-            "actual_cost": 212.5
-          }
-        ]
-      }
-    ],
-    "members": [
-      {
-        "team_member_id": "uuid",
-        "name": "John Doe",
-        "avatar_url": "https://...",
-        "hourly_rate": 50.0,
-        "job_title_name": "Frontend Developer",
-        "estimated_hours": 5.25,
-        "logged_hours": 4.0,
-        "estimated_cost": 262.5,
-        "actual_cost": 200.0
-      },
-      {
-        "team_member_id": "uuid",
-        "name": "Jane Smith",
-        "avatar_url": "https://...",
-        "hourly_rate": 50.0,
-        "job_title_name": "Backend Developer",
-        "estimated_hours": 5.25,
-        "logged_hours": 4.25,
-        "estimated_cost": 262.5,
-        "actual_cost": 212.5
-      }
-    ]
-  }
-}
-```
-
-### Error Responses
-
-- `404 Not Found`: Task not found
-- `400 Bad Request`: Invalid task ID
-
-### Usage
-
-This endpoint is designed to work with the finance drawer component (`@finance-drawer.tsx`) to provide detailed cost breakdown information for individual tasks. The response includes:
-
-1. **Task Summary**: Overall task financial information
-2. **Grouped Members**: Members organized by job role with aggregated costs
-3. **Individual Members**: Detailed breakdown for each team member
-
-The data structure matches what the finance drawer expects, with members grouped by job roles and individual labor hours and costs calculated based on:
-- Estimated hours divided equally among assignees
-- Actual logged time per member
-- Hourly rates from project rate cards
-- Fixed costs added to the totals
-
-### Frontend Usage Example
-
-```typescript
-import { projectFinanceApiService } from '@/api/project-finance-ratecard/project-finance.api.service';
-
-// Fetch task breakdown
-const fetchTaskBreakdown = async (taskId: string) => {
-  try {
-    const response = await projectFinanceApiService.getTaskBreakdown(taskId);
-    const breakdown = response.body;
-    
-    console.log('Task:', breakdown.task);
-    console.log('Grouped Members:', breakdown.grouped_members);
-    console.log('Individual Members:', breakdown.members);
-    
-    return breakdown;
-  } catch (error) {
-    console.error('Error fetching task breakdown:', error);
-    throw error;
-  }
-};
-
-// Usage in React component
-const TaskBreakdownComponent = ({ taskId }: { taskId: string }) => {
-  const [breakdown, setBreakdown] = useState(null);
-  const [loading, setLoading] = useState(false);
-
-  useEffect(() => {
-    const loadBreakdown = async () => {
-      setLoading(true);
-      try {
-        const data = await fetchTaskBreakdown(taskId);
-        setBreakdown(data);
-      } catch (error) {
-        // Handle error
-      } finally {
-        setLoading(false);
-      }
-    };
-
-    if (taskId) {
-      loadBreakdown();
-    }
-  }, [taskId]);
-
-  if (loading) return <Spin />;
-  if (!breakdown) return null;
-
-  return (
-    <div>
-      <h3>{breakdown.task.name}</h3>
-      <p>Total Estimated Cost: ${breakdown.task.total_estimated_cost}</p>
-      <p>Total Actual Cost: ${breakdown.task.total_actual_cost}</p>
-      
-      {breakdown.grouped_members.map(group => (
-        <div key={group.jobRole}>
-          <h4>{group.jobRole}</h4>
-          <p>Hours: {group.estimated_hours} | Cost: ${group.estimated_cost}</p>
-          {group.members.map(member => (
-            <div key={member.team_member_id}>
-              {member.name}: {member.estimated_hours}h @ ${member.hourly_rate}/h
-            </div>
-          ))}
-        </div>
-      ))}
-    </div>
-  );
-};
-```
-
-### Integration
-
-This API complements the existing finance endpoints:
-- `GET /api/project-finance/project/:project_id/tasks` - Get all tasks for a project
-- `PUT /api/project-finance/task/:task_id/fixed-cost` - Update task fixed cost
-
-The finance drawer component has been updated to automatically use this API when a task is selected, providing real-time financial breakdown data. 

docs/enhanced-task-management-technical-guide.md

@@ -0,0 +1,429 @@
+# Enhanced Task Management: Technical Guide
+
+## Overview
+The Enhanced Task Management system is a comprehensive React-based interface built on top of WorkLenz's existing task infrastructure. It provides a modern, grouped view with drag-and-drop functionality, bulk operations, and responsive design.
+
+## Architecture
+
+### Component Structure
+```
+src/components/task-management/
+├── TaskListBoard.tsx        # Main container with DnD context
+├── TaskGroup.tsx           # Individual group with collapse/expand
+├── TaskRow.tsx             # Task display with rich metadata
+├── GroupingSelector.tsx    # Grouping method switcher
+└── BulkActionBar.tsx      # Bulk operations toolbar
+```
+
+### Integration Points
+The system integrates with existing WorkLenz infrastructure:
+
+- **Redux Store:** Uses `tasks.slice.ts` for state management
+- **Types:** Leverages existing TypeScript interfaces
+- **API Services:** Works with existing task API endpoints
+- **WebSocket:** Supports real-time updates via existing socket system
+
+## Core Components
+
+### TaskListBoard.tsx
+Main orchestrator component that provides:
+
+- **DnD Context:** @dnd-kit drag-and-drop functionality
+- **State Management:** Redux integration for task data
+- **Event Handling:** Drag events and bulk operations
+- **Layout Structure:** Header controls and group container
+
+#### Key Props
+```typescript
+interface TaskListBoardProps {
+  projectId: string;           // Required: Project identifier
+  className?: string;          // Optional: Additional CSS classes
+}
+```
+
+#### Redux Selectors Used
+```typescript
+const {
+  taskGroups,      // ITaskListGroup[] - Grouped task data
+  loadingGroups,   // boolean - Loading state
+  error,           // string | null - Error state
+  groupBy,         // IGroupBy - Current grouping method
+  search,          // string | null - Search filter
+  archived,        // boolean - Show archived tasks
+} = useSelector((state: RootState) => state.taskReducer);
+```
+
+### TaskGroup.tsx
+Renders individual task groups with:
+
+- **Collapsible Headers:** Expand/collapse functionality
+- **Progress Indicators:** Visual completion progress
+- **Drop Zones:** Accept dropped tasks from other groups
+- **Group Statistics:** Task counts and completion rates
+
+#### Key Props
+```typescript
+interface TaskGroupProps {
+  group: ITaskListGroup;       // Group data with tasks
+  projectId: string;           // Project context
+  currentGrouping: IGroupBy;   // Current grouping mode
+  selectedTaskIds: string[];   // Selected task IDs
+  onAddTask?: (groupId: string) => void;
+  onToggleCollapse?: (groupId: string) => void;
+}
+```
+
+### TaskRow.tsx
+Individual task display featuring:
+
+- **Rich Metadata:** Progress, assignees, labels, due dates
+- **Drag Handles:** Sortable within and between groups
+- **Selection:** Multi-select with checkboxes
+- **Subtask Support:** Expandable hierarchy display
+
+#### Key Props
+```typescript
+interface TaskRowProps {
+  task: IProjectTask;          // Task data
+  projectId: string;           // Project context
+  groupId: string;             // Parent group ID
+  currentGrouping: IGroupBy;   // Current grouping mode
+  isSelected: boolean;         // Selection state
+  isDragOverlay?: boolean;     // Drag overlay rendering
+  index?: number;              // Position in group
+  onSelect?: (taskId: string, selected: boolean) => void;
+  onToggleSubtasks?: (taskId: string) => void;
+}
+```
+
+## State Management
+
+### Redux Integration
+The system uses existing WorkLenz Redux patterns:
+
+```typescript
+// Primary slice used
+import {
+  fetchTaskGroups,     // Async thunk for loading data
+  reorderTasks,        // Update task order/group
+  setGroup,           // Change grouping method
+  updateTaskStatus,   // Update individual task status
+  updateTaskPriority, // Update individual task priority
+  // ... other existing actions
+} from '@/features/tasks/tasks.slice';
+```
+
+### Data Flow
+1. **Component Mount:** `TaskListBoard` dispatches `fetchTaskGroups(projectId)`
+2. **Group Changes:** `setGroup(newGroupBy)` triggers data reorganization
+3. **Drag Operations:** `reorderTasks()` updates task positions and properties
+4. **Real-time Updates:** WebSocket events update Redux state automatically
+
+## Drag and Drop Implementation
+
+### DnD Kit Integration
+Uses @dnd-kit for modern, accessible drag-and-drop:
+
+```typescript
+// Sensors for different input methods
+const sensors = useSensors(
+  useSensor(PointerSensor, {
+    activationConstraint: { distance: 8 }
+  }),
+  useSensor(KeyboardSensor, {
+    coordinateGetter: sortableKeyboardCoordinates
+  })
+);
+```
+
+### Drag Event Handling
+```typescript
+const handleDragEnd = (event: DragEndEvent) => {
+  const { active, over } = event;
+  
+  // Determine source and target
+  const sourceGroup = findTaskGroup(active.id);
+  const targetGroup = findTargetGroup(over?.id);
+  
+  // Update task arrays and dispatch changes
+  dispatch(reorderTasks({
+    activeGroupId: sourceGroup.id,
+    overGroupId: targetGroup.id,
+    fromIndex: sourceIndex,
+    toIndex: targetIndex,
+    task: movedTask,
+    updatedSourceTasks,
+    updatedTargetTasks,
+  }));
+};
+```
+
+### Smart Property Updates
+When tasks are moved between groups, properties update automatically:
+
+- **Status Grouping:** Moving to "Done" group sets task status to "done"
+- **Priority Grouping:** Moving to "High" group sets task priority to "high"
+- **Phase Grouping:** Moving to "Testing" group sets task phase to "testing"
+
+## Bulk Operations
+
+### Selection State Management
+```typescript
+// Local state for task selection
+const [selectedTaskIds, setSelectedTaskIds] = useState<string[]>([]);
+
+// Selection handlers
+const handleTaskSelect = (taskId: string, selected: boolean) => {
+  if (selected) {
+    setSelectedTaskIds(prev => [...prev, taskId]);
+  } else {
+    setSelectedTaskIds(prev => prev.filter(id => id !== taskId));
+  }
+};
+```
+
+### Context-Aware Actions
+Bulk actions adapt to current grouping:
+
+```typescript
+// Only show status changes when not grouped by status
+{currentGrouping !== 'status' && (
+  <Dropdown overlay={statusMenu}>
+    <Button>Change Status</Button>
+  </Dropdown>
+)}
+```
+
+## Performance Optimizations
+
+### Memoized Selectors
+```typescript
+// Expensive group calculations are memoized
+const taskGroups = useMemo(() => {
+  return createGroupsFromTasks(tasks, currentGrouping);
+}, [tasks, currentGrouping]);
+```
+
+### Virtual Scrolling Ready
+For large datasets, the system is prepared for react-window integration:
+
+```typescript
+// Large group detection
+const shouldVirtualize = group.tasks.length > 100;
+
+return shouldVirtualize ? (
+  <VirtualizedTaskList tasks={group.tasks} />
+) : (
+  <StandardTaskList tasks={group.tasks} />
+);
+```
+
+### Optimistic Updates
+UI updates immediately while API calls process in background:
+
+```typescript
+// Immediate UI update
+dispatch(updateTaskStatusOptimistically(taskId, newStatus));
+
+// API call with rollback on error
+try {
+  await updateTaskStatus(taskId, newStatus);
+} catch (error) {
+  dispatch(rollbackTaskStatusUpdate(taskId));
+}
+```
+
+## Responsive Design
+
+### Breakpoint Strategy
+```css
+/* Mobile-first responsive design */
+.task-row {
+  padding: 12px;
+}
+
+@media (min-width: 768px) {
+  .task-row {
+    padding: 16px;
+  }
+}
+
+@media (min-width: 1024px) {
+  .task-row {
+    padding: 20px;
+  }
+}
+```
+
+### Progressive Enhancement
+- **Mobile:** Essential information only
+- **Tablet:** Additional metadata visible
+- **Desktop:** Full feature set with optimal layout
+
+## Accessibility
+
+### ARIA Implementation
+```typescript
+// Proper ARIA labels for screen readers
+<div
+  role="button"
+  aria-label={`Move task ${task.name}`}
+  tabIndex={0}
+  {...dragHandleProps}
+>
+  <DragOutlined />
+</div>
+```
+
+### Keyboard Navigation
+- **Tab:** Navigate between elements
+- **Space:** Select/deselect tasks
+- **Enter:** Activate buttons
+- **Arrows:** Navigate sortable lists with keyboard sensor
+
+### Focus Management
+```typescript
+// Maintain focus during dynamic updates
+useEffect(() => {
+  if (shouldFocusTask) {
+    taskRef.current?.focus();
+  }
+}, [taskGroups]);
+```
+
+## WebSocket Integration
+
+### Real-time Updates
+The system subscribes to existing WorkLenz WebSocket events:
+
+```typescript
+// Socket event handlers (existing WorkLenz patterns)
+socket.on('TASK_STATUS_CHANGED', (data) => {
+  dispatch(updateTaskStatus(data));
+});
+
+socket.on('TASK_PROGRESS_UPDATED', (data) => {
+  dispatch(updateTaskProgress(data));
+});
+```
+
+### Live Collaboration
+- Multiple users can work simultaneously
+- Changes appear in real-time
+- Conflict resolution through server-side validation
+
+## API Integration
+
+### Existing Endpoints Used
+```typescript
+// Uses existing WorkLenz API services
+import { tasksApiService } from '@/api/tasks/tasks.api.service';
+
+// Task data fetching
+tasksApiService.getTaskList(config);
+
+// Task updates
+tasksApiService.updateTask(taskId, changes);
+
+// Bulk operations
+tasksApiService.bulkUpdateTasks(taskIds, changes);
+```
+
+### Error Handling
+```typescript
+try {
+  await dispatch(fetchTaskGroups(projectId));
+} catch (error) {
+  // Display user-friendly error message
+  message.error('Failed to load tasks. Please try again.');
+  logger.error('Task loading error:', error);
+}
+```
+
+## Testing Strategy
+
+### Component Testing
+```typescript
+// Example test structure
+describe('TaskListBoard', () => {
+  it('should render task groups correctly', () => {
+    const mockTasks = generateMockTasks(10);
+    render(<TaskListBoard projectId="test-project" />);
+    
+    expect(screen.getByText('Tasks (10)')).toBeInTheDocument();
+  });
+  
+  it('should handle drag and drop operations', async () => {
+    // Test drag and drop functionality
+  });
+});
+```
+
+### Integration Testing
+- Redux state management
+- API service integration
+- WebSocket event handling
+- Drag and drop operations
+
+## Development Guidelines
+
+### Code Organization
+- Follow existing WorkLenz patterns
+- Use TypeScript strictly
+- Implement proper error boundaries
+- Maintain accessibility standards
+
+### Performance Considerations
+- Memoize expensive calculations
+- Implement virtual scrolling for large datasets
+- Debounce user input operations
+- Optimize re-render cycles
+
+### Styling Standards
+- Use existing Ant Design components
+- Follow WorkLenz design system
+- Implement responsive breakpoints
+- Maintain dark mode compatibility
+
+## Future Enhancements
+
+### Planned Features
+- Custom column integration
+- Advanced filtering capabilities
+- Kanban board view
+- Enhanced time tracking
+- Task templates
+
+### Extension Points
+The system is designed for easy extension:
+
+```typescript
+// Plugin architecture ready
+interface TaskViewPlugin {
+  name: string;
+  component: React.ComponentType;
+  supportedGroupings: IGroupBy[];
+}
+
+const plugins: TaskViewPlugin[] = [
+  { name: 'kanban', component: KanbanView, supportedGroupings: ['status'] },
+  { name: 'timeline', component: TimelineView, supportedGroupings: ['phase'] },
+];
+```
+
+## Deployment Considerations
+
+### Bundle Size
+- Tree-shake unused dependencies
+- Code-split large components
+- Optimize asset loading
+
+### Browser Compatibility
+- Modern browsers (ES2020+)
+- Graceful degradation for older browsers
+- Progressive enhancement approach
+
+### Performance Monitoring
+- Track component render times
+- Monitor API response times
+- Measure user interaction latency 

docs/enhanced-task-management-user-guide.md

@@ -0,0 +1,275 @@
+# Enhanced Task Management: User Guide
+
+## What Is Enhanced Task Management?
+The Enhanced Task Management system provides a modern, grouped view of your tasks with advanced features like drag-and-drop, bulk operations, and dynamic grouping. This system builds on WorkLenz's existing task infrastructure while offering improved productivity and organization tools.
+
+## Why Use Enhanced Task Management?
+- **Better Organization:** Group tasks by Status, Priority, or Phase for clearer project overview
+- **Increased Productivity:** Bulk operations let you update multiple tasks at once
+- **Intuitive Interface:** Drag-and-drop functionality makes task management feel natural
+- **Rich Task Display:** See progress, assignees, labels, and due dates at a glance
+- **Responsive Design:** Works seamlessly on desktop, tablet, and mobile devices
+
+## Getting Started
+
+### Accessing Enhanced Task Management
+1. Navigate to your project workspace
+2. Look for the enhanced task view option in your project interface
+3. The system will display your tasks grouped by the current grouping method (default: Status)
+
+### Understanding the Interface
+The enhanced task management interface consists of several key areas:
+
+- **Header Controls:** Task count, grouping selector, and action buttons
+- **Task Groups:** Collapsible sections containing related tasks
+- **Individual Tasks:** Rich task cards with metadata and actions
+- **Bulk Action Bar:** Appears when multiple tasks are selected (blue bar)
+
+## Task Grouping
+
+### Available Grouping Options
+You can organize your tasks using three different grouping methods:
+
+#### 1. Status Grouping (Default)
+Groups tasks by their current status:
+- **To Do:** Tasks not yet started
+- **Doing:** Tasks currently in progress  
+- **Done:** Completed tasks
+
+#### 2. Priority Grouping
+Groups tasks by their priority level:
+- **Critical:** Highest priority, urgent tasks
+- **High:** Important tasks requiring attention
+- **Medium:** Standard priority tasks
+- **Low:** Tasks that can be addressed later
+
+#### 3. Phase Grouping
+Groups tasks by project phases:
+- **Planning:** Tasks in the planning stage
+- **Development:** Implementation and development tasks
+- **Testing:** Quality assurance and testing tasks
+- **Deployment:** Release and deployment tasks
+
+### Switching Between Groupings
+1. Locate the "Group by" dropdown in the header controls
+2. Select your preferred grouping method (Status, Priority, or Phase)
+3. Tasks will automatically reorganize into the new groups
+4. Your grouping preference is saved for future sessions
+
+### Group Features
+Each task group includes:
+- **Color-coded headers** with visual indicators
+- **Task count badges** showing the number of tasks in each group
+- **Progress indicators** showing completion percentage
+- **Collapse/expand functionality** to hide or show group contents
+- **Add task buttons** to quickly create tasks in specific groups
+
+## Drag and Drop
+
+### Moving Tasks Within Groups
+1. Hover over a task to reveal the drag handle (⋮⋮ icon)
+2. Click and hold the drag handle
+3. Drag the task to your desired position within the same group
+4. Release to drop the task in its new position
+
+### Moving Tasks Between Groups
+1. Click and hold the drag handle on any task
+2. Drag the task over a different group
+3. The target group will highlight to show it can accept the task
+4. Release to drop the task into the new group
+5. The task's properties (status, priority, or phase) will automatically update
+
+### Drag and Drop Benefits
+- **Instant Updates:** Task properties change automatically when moved between groups
+- **Visual Feedback:** Clear indicators show where tasks can be dropped
+- **Keyboard Accessible:** Alternative keyboard controls for accessibility
+- **Mobile Friendly:** Touch-friendly drag operations on mobile devices
+
+## Multi-Select and Bulk Operations
+
+### Selecting Tasks
+You can select multiple tasks using several methods:
+
+#### Individual Selection
+- Click the checkbox next to any task to select it
+- Click again to deselect
+
+#### Range Selection  
+- Select the first task in your desired range
+- Hold Shift and click the last task in the range
+- All tasks between the first and last will be selected
+
+#### Multiple Selection
+- Hold Ctrl (or Cmd on Mac) while clicking tasks
+- This allows you to select non-consecutive tasks
+
+### Bulk Actions
+When you have tasks selected, a blue bulk action bar appears with these options:
+
+#### Change Status (when not grouped by Status)
+- Update the status of all selected tasks at once
+- Choose from available status options in your project
+
+#### Set Priority (when not grouped by Priority)  
+- Assign the same priority level to all selected tasks
+- Options include Critical, High, Medium, and Low
+
+#### More Actions
+Additional bulk operations include:
+- **Assign to Member:** Add team members to multiple tasks
+- **Add Labels:** Apply labels to selected tasks
+- **Archive Tasks:** Move multiple tasks to archive
+
+#### Delete Tasks
+- Permanently remove multiple tasks at once
+- Confirmation dialog prevents accidental deletions
+
+### Bulk Action Tips
+- The bulk action bar only shows relevant options based on your current grouping
+- You can clear your selection at any time using the "Clear" button
+- Bulk operations provide immediate feedback and can be undone if needed
+
+## Task Display Features
+
+### Rich Task Information
+Each task displays comprehensive information:
+
+#### Basic Information
+- **Task Key:** Unique identifier (e.g., PROJ-123)
+- **Task Name:** Clear, descriptive title
+- **Description:** Additional details when available
+
+#### Visual Indicators
+- **Progress Bar:** Shows completion percentage (0-100%)
+- **Priority Indicator:** Color-coded dot showing task importance
+- **Status Color:** Left border color indicates current status
+
+#### Team and Collaboration
+- **Assignee Avatars:** Profile pictures of assigned team members (up to 3 visible)
+- **Labels:** Color-coded tags for categorization
+- **Comment Count:** Number of comments and discussions
+- **Attachment Count:** Number of files attached to the task
+
+#### Timing Information
+- **Due Dates:** When tasks are scheduled to complete
+  - Red text: Overdue tasks
+  - Orange text: Due today or within 3 days
+  - Gray text: Future due dates
+- **Time Tracking:** Estimated vs. logged time when available
+
+### Subtask Support
+Tasks with subtasks include additional features:
+
+#### Expanding Subtasks
+- Click the "+X" button next to task names to expand subtasks
+- Subtasks appear indented below the parent task
+- Click "−X" to collapse subtasks
+
+#### Subtask Progress
+- Parent task progress reflects completion of all subtasks
+- Individual subtask progress is visible when expanded
+- Subtask counts show total number of child tasks
+
+## Advanced Features
+
+### Real-time Updates
+- Changes made by team members appear instantly
+- Live collaboration with multiple users
+- WebSocket connections ensure data synchronization
+
+### Search and Filtering
+- Use existing project search and filter capabilities
+- Enhanced task management respects current filter settings
+- Search results maintain grouping organization
+
+### Responsive Design
+The interface adapts to different screen sizes:
+
+#### Desktop (Large Screens)
+- Full feature set with all metadata visible
+- Optimal drag-and-drop experience
+- Multi-column layouts where appropriate
+
+#### Tablet (Medium Screens)  
+- Condensed but functional interface
+- Touch-friendly interactions
+- Simplified metadata display
+
+#### Mobile (Small Screens)
+- Stacked layout for easy navigation
+- Large touch targets for selections
+- Essential information prioritized
+
+## Best Practices
+
+### Organizing Your Tasks
+1. **Choose the Right Grouping:** Select the grouping method that best fits your workflow
+2. **Use Labels Consistently:** Apply meaningful labels for better categorization
+3. **Keep Groups Balanced:** Avoid having too many tasks in a single group
+4. **Regular Maintenance:** Review and update task organization periodically
+
+### Collaboration Tips
+1. **Clear Task Names:** Use descriptive titles that everyone understands
+2. **Proper Assignment:** Assign tasks to appropriate team members
+3. **Progress Updates:** Keep progress percentages current for accurate project tracking
+4. **Use Comments:** Communicate about tasks using the comment system
+
+### Productivity Techniques
+1. **Batch Similar Operations:** Use bulk actions for efficiency
+2. **Prioritize Effectively:** Use priority grouping during planning phases
+3. **Track Progress:** Monitor completion rates using group progress indicators
+4. **Plan Ahead:** Use due dates and time estimates for better scheduling
+
+## Keyboard Shortcuts
+
+### Navigation
+- **Tab:** Move focus between elements
+- **Enter:** Activate focused button or link
+- **Esc:** Close open dialogs or clear selections
+
+### Selection
+- **Space:** Select/deselect focused task
+- **Shift + Click:** Range selection
+- **Ctrl + Click:** Multi-selection (Cmd + Click on Mac)
+
+### Actions
+- **Delete:** Remove selected tasks (with confirmation)
+- **Ctrl + A:** Select all visible tasks (Cmd + A on Mac)
+
+## Troubleshooting
+
+### Common Issues
+
+#### Tasks Not Moving Between Groups
+- Ensure you have edit permissions for the tasks
+- Check that you're dragging from the drag handle (⋮⋮ icon)
+- Verify the target group allows the task type
+
+#### Bulk Actions Not Working
+- Confirm tasks are actually selected (checkboxes checked)
+- Ensure you have appropriate permissions
+- Check that the action is available for your current grouping
+
+#### Missing Task Information
+- Some metadata may be hidden on smaller screens
+- Try expanding to full screen or using desktop view
+- Check that task has the required information (assignees, labels, etc.)
+
+### Performance Tips
+- For projects with hundreds of tasks, consider using filters to reduce visible tasks
+- Collapse groups you're not actively working with
+- Clear selections when not performing bulk operations
+
+## Getting Help
+- Contact your workspace administrator for permission-related issues
+- Check the main WorkLenz documentation for general task management help
+- Report bugs or feature requests through your organization's support channels
+
+## What's New
+This enhanced task management system builds on WorkLenz's solid foundation while adding:
+- Modern drag-and-drop interfaces
+- Flexible grouping options
+- Powerful bulk operation capabilities
+- Rich visual task displays
+- Mobile-responsive design
+- Improved accessibility features 

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "worklenz",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

test_sort_fix.sql

@@ -0,0 +1,41 @@
+-- Test script to verify the sort order constraint fix
+
+-- Test the helper function
+SELECT get_sort_column_name('status');    -- Should return 'status_sort_order'
+SELECT get_sort_column_name('priority');  -- Should return 'priority_sort_order'
+SELECT get_sort_column_name('phase');     -- Should return 'phase_sort_order'
+SELECT get_sort_column_name('members');   -- Should return 'member_sort_order'
+SELECT get_sort_column_name('unknown');   -- Should return 'status_sort_order' (default)
+
+-- Test bulk update function (example - would need real project_id and task_ids)
+/*
+SELECT update_task_sort_orders_bulk(
+    '[
+        {"task_id": "example-uuid", "sort_order": 1, "status_id": "status-uuid"},
+        {"task_id": "example-uuid-2", "sort_order": 2, "status_id": "status-uuid"}
+    ]'::json,
+    'status'
+);
+*/
+
+-- Verify that sort_order constraint still exists and works
+SELECT 
+    tc.constraint_name,
+    tc.table_name,
+    kcu.column_name
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu 
+    ON tc.constraint_name = kcu.constraint_name
+WHERE tc.constraint_name = 'tasks_sort_order_unique';
+
+-- Check that new sort order columns don't have unique constraints (which is correct)
+SELECT 
+    tc.constraint_name,
+    tc.table_name,
+    kcu.column_name
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu 
+    ON tc.constraint_name = kcu.constraint_name
+WHERE kcu.table_name = 'tasks'
+  AND kcu.column_name IN ('status_sort_order', 'priority_sort_order', 'phase_sort_order', 'member_sort_order')
+  AND tc.constraint_type = 'UNIQUE';

test_sort_orders.sql

@@ -0,0 +1,30 @@
+-- Test script to validate the separate sort order implementation
+
+-- Check if new columns exist
+SELECT column_name, data_type, is_nullable, column_default
+FROM information_schema.columns 
+WHERE table_name = 'tasks' 
+  AND column_name IN ('status_sort_order', 'priority_sort_order', 'phase_sort_order', 'member_sort_order')
+ORDER BY column_name;
+
+-- Check if helper function exists
+SELECT routine_name, routine_type
+FROM information_schema.routines 
+WHERE routine_name IN ('get_sort_column_name', 'update_task_sort_orders_bulk', 'handle_task_list_sort_order_change');
+
+-- Sample test data to verify different sort orders work
+-- (This would be run after the migrations)
+/*
+-- Test: Tasks should have different orders for different groupings
+SELECT 
+  id, 
+  name, 
+  sort_order, 
+  status_sort_order, 
+  priority_sort_order, 
+  phase_sort_order, 
+  member_sort_order
+FROM tasks 
+WHERE project_id = '<test-project-id>'
+ORDER BY status_sort_order;
+*/

update-docker-env.sh

@@ -73,8 +73,8 @@ cat > worklenz-backend/.env << EOL
 NODE_ENV=production
 PORT=3000
 SESSION_NAME=worklenz.sid
-SESSION_SECRET=change_me_in_production
-COOKIE_SECRET=change_me_in_production
+SESSION_SECRET=$(openssl rand -base64 48)
+COOKIE_SECRET=$(openssl rand -base64 48)
 
 # CORS
 SOCKET_IO_CORS=${FRONTEND_URL}
@@ -123,7 +123,7 @@ SLACK_WEBHOOK=
 COMMIT_BUILD_IMMEDIATELY=true
 
 # JWT Secret
-JWT_SECRET=change_me_in_production
+JWT_SECRET=$(openssl rand -base64 48)
 EOL
 
 echo "Environment configuration updated for ${HOSTNAME} with" $([ "$USE_SSL" = "true" ] && echo "HTTPS/WSS" || echo "HTTP/WS")
@@ -138,4 +138,4 @@ echo "Frontend URL: ${FRONTEND_URL}"
 echo "API URL: ${HTTP_PREFIX}${HOSTNAME}:3000"
 echo "Socket URL: ${WS_PREFIX}${HOSTNAME}:3000"
 echo "MinIO Dashboard URL: ${MINIO_DASHBOARD_URL}"
-echo "CORS is configured to allow requests from: ${FRONTEND_URL}" 
+echo "CORS is configured to allow requests from: ${FRONTEND_URL}"

worklenz-backend/.dockerignore

@@ -1,5 +1,9 @@
 node_modules
 npm-debug.log
-build
 .scannerwork
 coverage
+.dockerignore
+.git
+*.md
+tests
+

worklenz-backend/.gitignore

@@ -20,9 +20,6 @@ coverage
 # nyc test coverage
 .nyc_output
 
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
 # Bower dependency directory (https://bower.io/)
 bower_components
 

worklenz-backend/Dockerfile

@@ -1,26 +1,39 @@
-# Use the official Node.js 20 image as a base
-FROM node:20
+# --- Stage 1: Build ---
+FROM node:20-slim AS builder
+
+ARG RELEASE_VERSION
+RUN apt-get update && apt-get install -y \
+    python3 \
+    make \
+    g++ \
+    curl \
+    postgresql-server-dev-all \
+    && rm -rf /var/lib/apt/lists/*
 
-# Create and set the working directory
 WORKDIR /usr/src/app
 
-# Install global dependencies
-RUN npm install -g ts-node typescript grunt grunt-cli
-
-# Copy package.json and package-lock.json (if available)
 COPY package*.json ./
-
-# Install app dependencies
 RUN npm ci
 
-# Copy the rest of the application code
 COPY . .
-
-# Run the build script to compile TypeScript to JavaScript
 RUN npm run build
 
-# Expose the port the app runs on
-EXPOSE 3000
+RUN echo "$RELEASE_VERSION" > release
+
+# --- Stage 2: Production Image ---
+FROM node:20-slim
+
+RUN apt-get update && apt-get install -y libpq5 && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY --from=builder /usr/src/app/package*.json ./
+COPY --from=builder /usr/src/app/build ./build
+COPY --from=builder /usr/src/app/node_modules ./node_modules
+COPY --from=builder /usr/src/app/release ./release
+COPY --from=builder /usr/src/app/worklenz-email-templates ./worklenz-email-templates
+
+
+EXPOSE 3000
+CMD ["node", "build/bin/www"]
 
-# Start the application
-CMD ["npm", "start"]

worklenz-backend/database/00-init-db.sh

@@ -1,55 +0,0 @@
-#!/bin/bash
-set -e
-
-# This script controls the order of SQL file execution during database initialization
-echo "Starting database initialization..."
-
-# Check if we have SQL files in expected locations
-if [ -f "/docker-entrypoint-initdb.d/sql/0_extensions.sql" ]; then
-  SQL_DIR="/docker-entrypoint-initdb.d/sql"
-  echo "Using SQL files from sql/ subdirectory"
-elif [ -f "/docker-entrypoint-initdb.d/0_extensions.sql" ]; then
-  # First time setup - move files to subdirectory
-  echo "Moving SQL files to sql/ subdirectory..."
-  mkdir -p /docker-entrypoint-initdb.d/sql
-  
-  # Move all SQL files (except this script) to the subdirectory
-  for f in /docker-entrypoint-initdb.d/*.sql; do
-    if [ -f "$f" ]; then
-      cp "$f" /docker-entrypoint-initdb.d/sql/
-      echo "Copied $f to sql/ subdirectory"
-    fi
-  done
-  
-  SQL_DIR="/docker-entrypoint-initdb.d/sql"
-else
-  echo "SQL files not found in expected locations!"
-  exit 1
-fi
-
-# Execute SQL files in the correct order
-echo "Executing 0_extensions.sql..."
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -f "$SQL_DIR/0_extensions.sql"
-
-echo "Executing 1_tables.sql..."
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -f "$SQL_DIR/1_tables.sql"
-
-echo "Executing indexes.sql..."
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -f "$SQL_DIR/indexes.sql"
-
-echo "Executing 4_functions.sql..."
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -f "$SQL_DIR/4_functions.sql"
-
-echo "Executing triggers.sql..."
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -f "$SQL_DIR/triggers.sql"
-
-echo "Executing 3_views.sql..."
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -f "$SQL_DIR/3_views.sql"
-
-echo "Executing 2_dml.sql..."
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -f "$SQL_DIR/2_dml.sql"
-
-echo "Executing 5_database_user.sql..."
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -f "$SQL_DIR/5_database_user.sql"
-
-echo "Database initialization completed successfully" 

worklenz-backend/database/00_init.sh

@@ -0,0 +1,88 @@
+#!/bin/bash
+set -e
+
+echo "Starting database initialization..."
+
+SQL_DIR="/docker-entrypoint-initdb.d/sql"
+MIGRATIONS_DIR="/docker-entrypoint-initdb.d/migrations"
+BACKUP_DIR="/docker-entrypoint-initdb.d/pg_backups"
+
+# --------------------------------------------
+# 🗄️ STEP 1: Attempt to restore latest backup
+# --------------------------------------------
+
+if [ -d "$BACKUP_DIR" ]; then
+  LATEST_BACKUP=$(ls -t "$BACKUP_DIR"/*.sql 2>/dev/null | head -n 1)
+else
+  LATEST_BACKUP=""
+fi
+
+if [ -f "$LATEST_BACKUP" ]; then
+  echo "🗄️ Found latest backup: $LATEST_BACKUP"
+  echo "⏳ Restoring from backup..."
+  psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" < "$LATEST_BACKUP"
+  echo "✅ Backup restoration complete. Skipping schema and migrations."
+  exit 0
+else
+  echo "ℹ️ No valid backup found. Proceeding with base schema and migrations."
+fi
+
+# --------------------------------------------
+# 🏗️ STEP 2: Continue with base schema setup
+# --------------------------------------------
+
+# Create migrations table if it doesn't exist
+psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -c "
+  CREATE TABLE IF NOT EXISTS schema_migrations (
+    version TEXT PRIMARY KEY,
+    applied_at TIMESTAMP DEFAULT now()
+  );
+"
+
+# List of base schema files to execute in order
+BASE_SQL_FILES=(
+  "0_extensions.sql"
+  "1_tables.sql"
+  "indexes.sql"
+  "4_functions.sql"
+  "triggers.sql"
+  "3_views.sql"
+  "2_dml.sql"
+  "5_database_user.sql"
+)
+
+echo "Running base schema SQL files in order..."
+
+for file in "${BASE_SQL_FILES[@]}"; do
+  full_path="$SQL_DIR/$file"
+  if [ -f "$full_path" ]; then
+    echo "Executing $file..."
+    psql -v ON_ERROR_STOP=1 -U "$POSTGRES_USER" -d "$POSTGRES_DB" -f "$full_path"
+  else
+    echo "WARNING: $file not found, skipping."
+  fi
+done
+
+echo "✅ Base schema SQL execution complete."
+
+# --------------------------------------------
+# 🚀 STEP 3: Apply SQL migrations
+# --------------------------------------------
+
+if [ -d "$MIGRATIONS_DIR" ] && compgen -G "$MIGRATIONS_DIR/*.sql" > /dev/null; then
+  echo "Applying migrations..."
+  for f in "$MIGRATIONS_DIR"/*.sql; do
+    version=$(basename "$f")
+    if ! psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -tAc "SELECT 1 FROM schema_migrations WHERE version = '$version'" | grep -q 1; then
+      echo "Applying migration: $version"
+      psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -f "$f"
+      psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -c "INSERT INTO schema_migrations (version) VALUES ('$version');"
+    else
+      echo "Skipping already applied migration: $version"
+    fi
+  done
+else
+  echo "No migration files found or directory is empty, skipping migrations."
+fi
+
+echo "🎉 Database initialization completed successfully."

worklenz-backend/database/migrations/20250115000000-add-recursive-task-estimation.sql

@@ -1,228 +0,0 @@
--- Migration: Add recursive task estimation functionality
--- This migration adds a function to calculate recursive task estimation including all subtasks
--- and modifies the get_task_form_view_model function to include this data
-
-BEGIN;
-
--- Function to calculate recursive task estimation (including all subtasks)
-CREATE OR REPLACE FUNCTION get_task_recursive_estimation(_task_id UUID) RETURNS JSON
-    LANGUAGE plpgsql
-AS
-$$
-DECLARE
-    _result JSON;
-    _has_subtasks BOOLEAN;
-BEGIN
-    -- First check if this task has any subtasks
-    SELECT EXISTS(
-        SELECT 1 FROM tasks 
-        WHERE parent_task_id = _task_id 
-        AND archived = false
-    ) INTO _has_subtasks;
-
-    -- If task has subtasks, calculate recursive estimation excluding parent's own estimation
-    IF _has_subtasks THEN
-        WITH RECURSIVE task_tree AS (
-            -- Start with direct subtasks only (exclude the parent task itself)
-            SELECT 
-                id,
-                parent_task_id,
-                COALESCE(total_minutes, 0) as total_minutes,
-                1 as level  -- Start at level 1 (subtasks)
-            FROM tasks
-            WHERE parent_task_id = _task_id
-            AND archived = false
-
-            UNION ALL
-
-            -- Recursive case: Get all descendant tasks
-            SELECT 
-                t.id,
-                t.parent_task_id,
-                COALESCE(t.total_minutes, 0) as total_minutes,
-                tt.level + 1 as level
-            FROM tasks t
-            INNER JOIN task_tree tt ON t.parent_task_id = tt.id
-            WHERE t.archived = false
-        ),
-        task_counts AS (
-            SELECT 
-                COUNT(*) as sub_tasks_count,
-                SUM(total_minutes) as subtasks_total_minutes  -- Sum all subtask estimations
-            FROM task_tree
-        )
-        SELECT JSON_BUILD_OBJECT(
-            'sub_tasks_count', COALESCE(tc.sub_tasks_count, 0),
-            'own_total_minutes', 0,  -- Always 0 for parent tasks
-            'subtasks_total_minutes', COALESCE(tc.subtasks_total_minutes, 0),
-            'recursive_total_minutes', COALESCE(tc.subtasks_total_minutes, 0),  -- Only subtasks total
-            'recursive_total_hours', FLOOR(COALESCE(tc.subtasks_total_minutes, 0) / 60),
-            'recursive_remaining_minutes', COALESCE(tc.subtasks_total_minutes, 0) % 60
-        )
-        INTO _result
-        FROM task_counts tc;
-    ELSE
-        -- If task has no subtasks, use its own estimation
-        SELECT JSON_BUILD_OBJECT(
-            'sub_tasks_count', 0,
-            'own_total_minutes', COALESCE(total_minutes, 0),
-            'subtasks_total_minutes', 0,
-            'recursive_total_minutes', COALESCE(total_minutes, 0),  -- Use own estimation
-            'recursive_total_hours', FLOOR(COALESCE(total_minutes, 0) / 60),
-            'recursive_remaining_minutes', COALESCE(total_minutes, 0) % 60
-        )
-        INTO _result
-        FROM tasks
-        WHERE id = _task_id;
-    END IF;
-
-    RETURN COALESCE(_result, JSON_BUILD_OBJECT(
-        'sub_tasks_count', 0,
-        'own_total_minutes', 0,
-        'subtasks_total_minutes', 0,
-        'recursive_total_minutes', 0,
-        'recursive_total_hours', 0,
-        'recursive_remaining_minutes', 0
-    ));
-END;
-$$;
-
--- Update the get_task_form_view_model function to include recursive estimation
-CREATE OR REPLACE FUNCTION public.get_task_form_view_model(_user_id UUID, _team_id UUID, _task_id UUID, _project_id UUID) RETURNS JSON
-    LANGUAGE plpgsql
-AS
-$$
-DECLARE
-    _task         JSON;
-    _priorities   JSON;
-    _projects     JSON;
-    _statuses     JSON;
-    _team_members JSON;
-    _assignees    JSON;
-    _phases       JSON;
-BEGIN
-
-    -- Select task info
-    SELECT COALESCE(ROW_TO_JSON(rec), '{}'::JSON)
-    INTO _task
-    FROM (WITH RECURSIVE task_hierarchy AS (
-        -- Base case: Start with the given task
-        SELECT id,
-               parent_task_id,
-               0 AS level
-        FROM tasks
-        WHERE id = _task_id
-
-        UNION ALL
-
-        -- Recursive case: Traverse up to parent tasks
-        SELECT t.id,
-               t.parent_task_id,
-               th.level + 1 AS level
-        FROM tasks t
-                 INNER JOIN task_hierarchy th ON t.id = th.parent_task_id
-        WHERE th.parent_task_id IS NOT NULL)
-          SELECT id,
-                 name,
-                 description,
-                 start_date,
-                 end_date,
-                 done,
-                 total_minutes,
-                 priority_id,
-                 project_id,
-                 created_at,
-                 updated_at,
-                 status_id,
-                 parent_task_id,
-                 sort_order,
-                 (SELECT phase_id FROM task_phase WHERE task_id = tasks.id)                      AS phase_id,
-                 CONCAT((SELECT key FROM projects WHERE id = tasks.project_id), '-', task_no)    AS task_key,
-                 (SELECT start_time
-                  FROM task_timers
-                  WHERE task_id = tasks.id
-                    AND user_id = _user_id)                                                      AS timer_start_time,
-                 parent_task_id IS NOT NULL                                                      AS is_sub_task,
-                 (SELECT COUNT('*')
-                  FROM tasks
-                  WHERE parent_task_id = tasks.id
-                    AND archived IS FALSE)                                                       AS sub_tasks_count,
-                 (SELECT COUNT(*)
-                  FROM tasks_with_status_view tt
-                  WHERE (tt.parent_task_id = tasks.id OR tt.task_id = tasks.id)
-                    AND tt.is_done IS TRUE)
-                                                                                                 AS completed_count,
-                 (SELECT COUNT(*) FROM task_attachments WHERE task_id = tasks.id)                AS attachments_count,
-                 (SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(r))), '[]'::JSON)
-                  FROM (SELECT task_labels.label_id AS id,
-                               (SELECT name FROM team_labels WHERE id = task_labels.label_id),
-                               (SELECT color_code FROM team_labels WHERE id = task_labels.label_id)
-                        FROM task_labels
-                        WHERE task_id = tasks.id
-                        ORDER BY name) r)                                                        AS labels,
-                 (SELECT color_code
-                  FROM sys_task_status_categories
-                  WHERE id = (SELECT category_id FROM task_statuses WHERE id = tasks.status_id)) AS status_color,
-                 (SELECT COUNT(*) FROM tasks WHERE parent_task_id = _task_id)                    AS sub_tasks_count,
-                 (SELECT name FROM users WHERE id = tasks.reporter_id)                           AS reporter,
-                 (SELECT get_task_assignees(tasks.id))                                           AS assignees,
-                 (SELECT id FROM team_members WHERE user_id = _user_id AND team_id = _team_id)   AS team_member_id,
-                 billable,
-                 schedule_id,
-                 progress_value,
-                 weight,
-                 (SELECT MAX(level) FROM task_hierarchy)                                         AS task_level,
-                 (SELECT get_task_recursive_estimation(tasks.id))                               AS recursive_estimation
-          FROM tasks
-          WHERE id = _task_id) rec;
-
-    SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(rec))), '[]'::JSON)
-    INTO _priorities
-    FROM (SELECT id, name FROM task_priorities ORDER BY value) rec;
-
-    SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(rec))), '[]'::JSON)
-    INTO _phases
-    FROM (SELECT id, name FROM project_phases WHERE project_id = _project_id ORDER BY name) rec;
-
-    SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(rec))), '[]'::JSON)
-    INTO _projects
-    FROM (SELECT id, name
-          FROM projects
-          WHERE team_id = _team_id
-            AND (CASE
-                     WHEN (is_owner(_user_id, _team_id) OR is_admin(_user_id, _team_id) IS TRUE) THEN TRUE
-                     ELSE is_member_of_project(projects.id, _user_id, _team_id) END)
-          ORDER BY name) rec;
-
-    SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(rec))), '[]'::JSON)
-    INTO _statuses
-    FROM (SELECT id, name FROM task_statuses WHERE project_id = _project_id) rec;
-
-    SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(rec))), '[]'::JSON)
-    INTO _team_members
-    FROM (SELECT team_members.id,
-                 (SELECT name FROM team_member_info_view WHERE team_member_info_view.team_member_id = team_members.id),
-                 (SELECT email FROM team_member_info_view WHERE team_member_info_view.team_member_id = team_members.id),
-                 (SELECT avatar_url
-                  FROM team_member_info_view
-                  WHERE team_member_info_view.team_member_id = team_members.id)
-          FROM team_members
-                   LEFT JOIN users u ON team_members.user_id = u.id
-          WHERE team_id = _team_id
-            AND team_members.active IS TRUE) rec;
-
-    SELECT get_task_assignees(_task_id) INTO _assignees;
-
-    RETURN JSON_BUILD_OBJECT(
-            'task', _task,
-            'priorities', _priorities,
-            'projects', _projects,
-            'statuses', _statuses,
-            'team_members', _team_members,
-            'assignees', _assignees,
-            'phases', _phases
-           );
-END;
-$$;
-
-COMMIT; 

worklenz-backend/database/migrations/20250115000000-performance-indexes.sql

@@ -0,0 +1,135 @@
+-- Performance indexes for optimized tasks queries
+-- Migration: 20250115000000-performance-indexes.sql
+
+-- Composite index for main task filtering
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_project_archived_parent 
+ON tasks(project_id, archived, parent_task_id) 
+WHERE archived = FALSE;
+
+-- Index for status joins
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_status_project 
+ON tasks(status_id, project_id) 
+WHERE archived = FALSE;
+
+-- Index for assignees lookup
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_assignees_task_member 
+ON tasks_assignees(task_id, team_member_id);
+
+-- Index for phase lookup
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_phase_task_phase 
+ON task_phase(task_id, phase_id);
+
+-- Index for subtask counting
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_parent_archived 
+ON tasks(parent_task_id, archived) 
+WHERE parent_task_id IS NOT NULL AND archived = FALSE;
+
+-- Index for labels
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_labels_task_label 
+ON task_labels(task_id, label_id);
+
+-- Index for comments count
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_comments_task 
+ON task_comments(task_id);
+
+-- Index for attachments count
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_attachments_task 
+ON task_attachments(task_id);
+
+-- Index for work log aggregation
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_work_log_task 
+ON task_work_log(task_id);
+
+-- Index for subscribers check
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_subscribers_task 
+ON task_subscribers(task_id);
+
+-- Index for dependencies check
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_dependencies_task 
+ON task_dependencies(task_id);
+
+-- Index for timers lookup
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_timers_task_user 
+ON task_timers(task_id, user_id);
+
+-- Index for custom columns
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_cc_column_values_task 
+ON cc_column_values(task_id);
+
+-- Index for team member info view optimization
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_team_members_team_user 
+ON team_members(team_id, user_id) 
+WHERE active = TRUE;
+
+-- Index for notification settings
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_notification_settings_user_team 
+ON notification_settings(user_id, team_id);
+
+-- Index for task status categories
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_statuses_category 
+ON task_statuses(category_id, project_id);
+
+-- Index for project phases
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_project_phases_project_sort 
+ON project_phases(project_id, sort_index);
+
+-- Index for task priorities
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_priorities_value 
+ON task_priorities(value);
+
+-- Index for team labels
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_team_labels_team 
+ON team_labels(team_id);
+
+-- NEW INDEXES FOR PERFORMANCE OPTIMIZATION --
+
+-- Composite index for task main query optimization (covers most WHERE conditions)
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_performance_main
+ON tasks(project_id, archived, parent_task_id, status_id, priority_id)
+WHERE archived = FALSE;
+
+-- Index for sorting by sort_order with project filter
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_project_sort_order
+ON tasks(project_id, sort_order)
+WHERE archived = FALSE;
+
+-- Index for email_invitations to optimize team_member_info_view
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_email_invitations_team_member
+ON email_invitations(team_member_id);
+
+-- Covering index for task status with category information
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_statuses_covering
+ON task_statuses(id, category_id, project_id);
+
+-- Index for task aggregation queries (parent task progress calculation)
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_parent_status_archived
+ON tasks(parent_task_id, status_id, archived)
+WHERE archived = FALSE;
+
+-- Index for project team member filtering
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_team_members_project_lookup
+ON team_members(team_id, active, user_id)
+WHERE active = TRUE;
+
+-- Covering index for tasks with frequently accessed columns
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_covering_main
+ON tasks(id, project_id, archived, parent_task_id, status_id, priority_id, sort_order, name)
+WHERE archived = FALSE;
+
+-- Index for task search functionality
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_name_search
+ON tasks USING gin(to_tsvector('english', name))
+WHERE archived = FALSE;
+
+-- Index for date-based filtering (if used)
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_dates
+ON tasks(project_id, start_date, end_date)
+WHERE archived = FALSE;
+
+-- Index for task timers with user filtering
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_timers_user_task
+ON task_timers(user_id, task_id);
+
+-- Index for sys_task_status_categories lookups
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_sys_task_status_categories_covering
+ON sys_task_status_categories(id, color_code, color_code_dark, is_done, is_doing, is_todo); 

worklenz-backend/database/migrations/20250117000000-add-project-currency.sql

@@ -1,20 +0,0 @@
--- Migration: Add currency column to projects table
--- Date: 2025-01-17
--- Description: Adds project-specific currency support to allow different projects to use different currencies
-
--- Add currency column to projects table
-ALTER TABLE projects
-    ADD COLUMN IF NOT EXISTS currency VARCHAR(3) DEFAULT 'USD';
-
--- Add comment for documentation
-COMMENT ON COLUMN projects.currency IS 'Project-specific currency code (e.g., USD, EUR, GBP, JPY, etc.)';
-
--- Add constraint to ensure currency codes are uppercase and 3 characters
-ALTER TABLE projects
-    ADD CONSTRAINT projects_currency_format_check 
-    CHECK (currency ~ '^[A-Z]{3}$');
-
--- Update existing projects to have a default currency if they don't have one
-UPDATE projects 
-SET currency = 'USD' 
-WHERE currency IS NULL; 

worklenz-backend/database/migrations/20250128000000-fix-window-function-error.sql

@@ -0,0 +1,143 @@
+-- Fix window function error in task sort optimized functions
+-- Error: window functions are not allowed in UPDATE
+
+-- Replace the optimized sort functions to avoid CTE usage in UPDATE statements
+CREATE OR REPLACE FUNCTION handle_task_list_sort_between_groups_optimized(_from_index integer, _to_index integer, _task_id uuid, _project_id uuid, _batch_size integer DEFAULT 100) RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _offset INT := 0;
+    _affected_rows INT;
+BEGIN
+    -- PERFORMANCE OPTIMIZATION: Use direct updates without CTE in UPDATE
+    IF (_to_index = -1)
+    THEN
+        _to_index = COALESCE((SELECT MAX(sort_order) + 1 FROM tasks WHERE project_id = _project_id), 0);
+    END IF;
+
+    -- PERFORMANCE OPTIMIZATION: Batch updates for large datasets
+    IF _to_index > _from_index
+    THEN
+        LOOP
+            UPDATE tasks
+            SET sort_order = sort_order - 1
+            WHERE project_id = _project_id
+              AND sort_order > _from_index
+              AND sort_order < _to_index
+              AND sort_order > _offset
+              AND sort_order <= _offset + _batch_size;
+            
+            GET DIAGNOSTICS _affected_rows = ROW_COUNT;
+            EXIT WHEN _affected_rows = 0;
+            _offset := _offset + _batch_size;
+        END LOOP;
+
+        UPDATE tasks SET sort_order = _to_index - 1 WHERE id = _task_id AND project_id = _project_id;
+    END IF;
+
+    IF _to_index < _from_index
+    THEN
+        _offset := 0;
+        LOOP
+            UPDATE tasks
+            SET sort_order = sort_order + 1
+            WHERE project_id = _project_id
+              AND sort_order > _to_index
+              AND sort_order < _from_index
+              AND sort_order > _offset
+              AND sort_order <= _offset + _batch_size;
+            
+            GET DIAGNOSTICS _affected_rows = ROW_COUNT;
+            EXIT WHEN _affected_rows = 0;
+            _offset := _offset + _batch_size;
+        END LOOP;
+
+        UPDATE tasks SET sort_order = _to_index + 1 WHERE id = _task_id AND project_id = _project_id;
+    END IF;
+END
+$$;
+
+-- Replace the second optimized sort function
+CREATE OR REPLACE FUNCTION handle_task_list_sort_inside_group_optimized(_from_index integer, _to_index integer, _task_id uuid, _project_id uuid, _batch_size integer DEFAULT 100) RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _offset INT := 0;
+    _affected_rows INT;
+BEGIN
+    -- PERFORMANCE OPTIMIZATION: Batch updates for large datasets without CTE in UPDATE
+    IF _to_index > _from_index
+    THEN
+        LOOP
+            UPDATE tasks
+            SET sort_order = sort_order - 1
+            WHERE project_id = _project_id
+              AND sort_order > _from_index
+              AND sort_order <= _to_index
+              AND sort_order > _offset
+              AND sort_order <= _offset + _batch_size;
+            
+            GET DIAGNOSTICS _affected_rows = ROW_COUNT;
+            EXIT WHEN _affected_rows = 0;
+            _offset := _offset + _batch_size;
+        END LOOP;
+    END IF;
+
+    IF _to_index < _from_index
+    THEN
+        _offset := 0;
+        LOOP
+            UPDATE tasks
+            SET sort_order = sort_order + 1
+            WHERE project_id = _project_id
+              AND sort_order >= _to_index
+              AND sort_order < _from_index
+              AND sort_order > _offset
+              AND sort_order <= _offset + _batch_size;
+            
+            GET DIAGNOSTICS _affected_rows = ROW_COUNT;
+            EXIT WHEN _affected_rows = 0;
+            _offset := _offset + _batch_size;
+        END LOOP;
+    END IF;
+
+    UPDATE tasks SET sort_order = _to_index WHERE id = _task_id AND project_id = _project_id;
+END
+$$;
+
+-- Add simple bulk update function as alternative
+CREATE OR REPLACE FUNCTION update_task_sort_orders_bulk(_updates json) RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _update_record RECORD;
+BEGIN
+    -- Simple approach: update each task's sort_order from the provided array
+    FOR _update_record IN 
+        SELECT 
+            (item->>'task_id')::uuid as task_id,
+            (item->>'sort_order')::int as sort_order,
+            (item->>'status_id')::uuid as status_id,
+            (item->>'priority_id')::uuid as priority_id,
+            (item->>'phase_id')::uuid as phase_id
+        FROM json_array_elements(_updates) as item
+    LOOP
+        UPDATE tasks 
+        SET 
+            sort_order = _update_record.sort_order,
+            status_id = COALESCE(_update_record.status_id, status_id),
+            priority_id = COALESCE(_update_record.priority_id, priority_id)
+        WHERE id = _update_record.task_id;
+        
+        -- Handle phase updates separately since it's in a different table
+        IF _update_record.phase_id IS NOT NULL THEN
+            INSERT INTO task_phase (task_id, phase_id)
+            VALUES (_update_record.task_id, _update_record.phase_id)
+            ON CONFLICT (task_id) DO UPDATE SET phase_id = _update_record.phase_id;
+        END IF;
+    END LOOP;
+END
+$$; 

worklenz-backend/database/migrations/20250423000000-subtask-manual-progress.sql

@@ -603,8 +603,7 @@ BEGIN
                  schedule_id,
                  progress_value,
                  weight,
-                 (SELECT MAX(level) FROM task_hierarchy)                                         AS task_level,
-                 (SELECT get_task_recursive_estimation(tasks.id))                               AS recursive_estimation
+                 (SELECT MAX(level) FROM task_hierarchy)                                         AS task_level
           FROM tasks
           WHERE id = _task_id) rec;
 
@@ -663,89 +662,6 @@ ADD COLUMN IF NOT EXISTS use_manual_progress BOOLEAN DEFAULT FALSE,
 ADD COLUMN IF NOT EXISTS use_weighted_progress BOOLEAN DEFAULT FALSE,
 ADD COLUMN IF NOT EXISTS use_time_progress BOOLEAN DEFAULT FALSE;
 
--- Function to calculate recursive task estimation (including all subtasks)
-CREATE OR REPLACE FUNCTION get_task_recursive_estimation(_task_id UUID) RETURNS JSON
-    LANGUAGE plpgsql
-AS
-$$
-DECLARE
-    _result JSON;
-    _has_subtasks BOOLEAN;
-BEGIN
-    -- First check if this task has any subtasks
-    SELECT EXISTS(
-        SELECT 1 FROM tasks 
-        WHERE parent_task_id = _task_id 
-        AND archived = false
-    ) INTO _has_subtasks;
-
-    -- If task has subtasks, calculate recursive estimation excluding parent's own estimation
-    IF _has_subtasks THEN
-        WITH RECURSIVE task_tree AS (
-            -- Start with direct subtasks only (exclude the parent task itself)
-            SELECT 
-                id,
-                parent_task_id,
-                COALESCE(total_minutes, 0) as total_minutes,
-                1 as level  -- Start at level 1 (subtasks)
-            FROM tasks
-            WHERE parent_task_id = _task_id
-            AND archived = false
-
-            UNION ALL
-
-            -- Recursive case: Get all descendant tasks
-            SELECT 
-                t.id,
-                t.parent_task_id,
-                COALESCE(t.total_minutes, 0) as total_minutes,
-                tt.level + 1 as level
-            FROM tasks t
-            INNER JOIN task_tree tt ON t.parent_task_id = tt.id
-            WHERE t.archived = false
-        ),
-        task_counts AS (
-            SELECT 
-                COUNT(*) as sub_tasks_count,
-                SUM(total_minutes) as subtasks_total_minutes  -- Sum all subtask estimations
-            FROM task_tree
-        )
-        SELECT JSON_BUILD_OBJECT(
-            'sub_tasks_count', COALESCE(tc.sub_tasks_count, 0),
-            'own_total_minutes', 0,  -- Always 0 for parent tasks
-            'subtasks_total_minutes', COALESCE(tc.subtasks_total_minutes, 0),
-            'recursive_total_minutes', COALESCE(tc.subtasks_total_minutes, 0),  -- Only subtasks total
-            'recursive_total_hours', FLOOR(COALESCE(tc.subtasks_total_minutes, 0) / 60),
-            'recursive_remaining_minutes', COALESCE(tc.subtasks_total_minutes, 0) % 60
-        )
-        INTO _result
-        FROM task_counts tc;
-    ELSE
-        -- If task has no subtasks, use its own estimation
-        SELECT JSON_BUILD_OBJECT(
-            'sub_tasks_count', 0,
-            'own_total_minutes', COALESCE(total_minutes, 0),
-            'subtasks_total_minutes', 0,
-            'recursive_total_minutes', COALESCE(total_minutes, 0),  -- Use own estimation
-            'recursive_total_hours', FLOOR(COALESCE(total_minutes, 0) / 60),
-            'recursive_remaining_minutes', COALESCE(total_minutes, 0) % 60
-        )
-        INTO _result
-        FROM tasks
-        WHERE id = _task_id;
-    END IF;
-
-    RETURN COALESCE(_result, JSON_BUILD_OBJECT(
-        'sub_tasks_count', 0,
-        'own_total_minutes', 0,
-        'subtasks_total_minutes', 0,
-        'recursive_total_minutes', 0,
-        'recursive_total_hours', 0,
-        'recursive_remaining_minutes', 0
-    ));
-END;
-$$;
-
 -- Add a trigger to reset manual progress when a task gets a new subtask
 CREATE OR REPLACE FUNCTION reset_parent_task_manual_progress() RETURNS TRIGGER AS
 $$
@@ -761,22 +677,6 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 
--- Add a trigger to reset parent task estimation when it gets subtasks
-CREATE OR REPLACE FUNCTION reset_parent_task_estimation() RETURNS TRIGGER AS
-$$
-BEGIN
-    -- When a task gets a new subtask (parent_task_id is set), reset the parent's total_minutes to 0
-    -- This ensures parent tasks don't have their own estimation when they have subtasks
-    IF NEW.parent_task_id IS NOT NULL THEN
-        UPDATE tasks 
-        SET total_minutes = 0
-        WHERE id = NEW.parent_task_id 
-        AND total_minutes > 0;
-    END IF;
-    RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
 -- Create the trigger on the tasks table
 DROP TRIGGER IF EXISTS reset_parent_manual_progress_trigger ON tasks;
 CREATE TRIGGER reset_parent_manual_progress_trigger
@@ -784,35 +684,4 @@ AFTER INSERT OR UPDATE OF parent_task_id ON tasks
 FOR EACH ROW
 EXECUTE FUNCTION reset_parent_task_manual_progress();
 
--- Create the trigger to reset parent task estimation
-DROP TRIGGER IF EXISTS reset_parent_estimation_trigger ON tasks;
-CREATE TRIGGER reset_parent_estimation_trigger
-AFTER INSERT OR UPDATE OF parent_task_id ON tasks
-FOR EACH ROW
-EXECUTE FUNCTION reset_parent_task_estimation();
-
--- Function to reset all existing parent tasks' estimations to 0
-CREATE OR REPLACE FUNCTION reset_all_parent_task_estimations() RETURNS INTEGER AS
-$$
-DECLARE
-    _updated_count INTEGER;
-BEGIN
-    -- Update all tasks that have subtasks to have 0 estimation
-    UPDATE tasks 
-    SET total_minutes = 0
-    WHERE id IN (
-        SELECT DISTINCT parent_task_id 
-        FROM tasks 
-        WHERE parent_task_id IS NOT NULL 
-        AND archived = false
-    )
-    AND total_minutes > 0
-    AND archived = false;
-    
-    GET DIAGNOSTICS _updated_count = ROW_COUNT;
-    
-    RETURN _updated_count;
-END;
-$$ LANGUAGE plpgsql;
-
 COMMIT; 

worklenz-backend/database/migrations/20250427000000-fix-progress-mode-type.sql

@@ -145,7 +145,7 @@ BEGIN
         SET progress_value = NULL,
             progress_mode = NULL
         WHERE project_id = _project_id
-        AND progress_mode = _old_mode;
+        AND progress_mode::text::progress_mode_type = _old_mode;
     END IF;
     
     RETURN NEW;

worklenz-backend/database/migrations/20250519000000-project-finance-module-tables.sql

@@ -1,48 +0,0 @@
--- Dropping existing finance_rate_cards table
-DROP TABLE IF EXISTS finance_rate_cards;
--- Creating table to store rate card details
-CREATE TABLE finance_rate_cards
-(
-    id         UUID PRIMARY KEY                  DEFAULT uuid_generate_v4(),
-    team_id    UUID                     NOT NULL REFERENCES teams (id) ON DELETE CASCADE,
-    name       VARCHAR                  NOT NULL,
-    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-
--- Dropping existing finance_project_rate_card_roles table
-DROP TABLE IF EXISTS finance_project_rate_card_roles CASCADE;
--- Creating table with single id primary key
-CREATE TABLE finance_project_rate_card_roles
-(
-    id         UUID PRIMARY KEY                  DEFAULT uuid_generate_v4(),
-    project_id UUID                     NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
-    job_title_id    UUID                     NOT NULL REFERENCES job_titles (id) ON DELETE CASCADE,
-    rate       DECIMAL(10, 2)           NOT NULL CHECK (rate >= 0),
-    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    CONSTRAINT unique_project_role UNIQUE (project_id, job_title_id)
-);
-
--- Dropping existing finance_rate_card_roles table
-DROP TABLE IF EXISTS finance_rate_card_roles;
--- Creating table to store role-specific rates for rate cards
-CREATE TABLE finance_rate_card_roles
-(
-    rate_card_id UUID                     NOT NULL REFERENCES finance_rate_cards (id) ON DELETE CASCADE,
-    job_title_id      UUID                     REFERENCES job_titles(id) ON DELETE SET NULL,
-    rate         DECIMAL(10, 2)           NOT NULL CHECK (rate >= 0),
-    created_at   TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at   TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-
--- Adding project_rate_card_role_id column to project_members
-ALTER TABLE project_members
-    ADD COLUMN project_rate_card_role_id UUID REFERENCES finance_project_rate_card_roles(id) ON DELETE SET NULL;
-
--- Adding rate_card column to projects
-ALTER TABLE projects
- ADD COLUMN rate_card UUID REFERENCES finance_rate_cards(id) ON DELETE SET NULL;
-
-ALTER TABLE finance_rate_cards
-    ADD COLUMN currency TEXT NOT NULL DEFAULT 'USD';

worklenz-backend/database/migrations/20250520000000-add-fixed-cost-to-tasks.sql

@@ -1,6 +0,0 @@
--- Add fixed_cost column to tasks table for project finance functionality
-ALTER TABLE tasks 
-ADD COLUMN fixed_cost DECIMAL(10, 2) DEFAULT 0 CHECK (fixed_cost >= 0);
-
--- Add comment to explain the column
-COMMENT ON COLUMN tasks.fixed_cost IS 'Fixed cost for the task in addition to hourly rate calculations'; 

worklenz-backend/database/migrations/consolidated-progress-migrations.sql

@@ -118,7 +118,7 @@ BEGIN
                         SELECT SUM(time_spent)
                         FROM task_work_log
                         WHERE task_id = t.id
-                    ), 0) / 60.0 as logged_minutes
+                    ), 0) as logged_minutes
                 FROM tasks t
                 WHERE t.id = _task_id
             )

worklenz-backend/database/migrations/fix_duplicate_sort_orders.sql

@@ -0,0 +1,300 @@
+-- Fix Duplicate Sort Orders Script
+-- This script detects and fixes duplicate sort order values that break task ordering
+
+-- 1. DETECTION QUERIES - Run these first to see the scope of the problem
+
+-- Check for duplicates in main sort_order column
+SELECT 
+    project_id,
+    sort_order,
+    COUNT(*) as duplicate_count,
+    STRING_AGG(id::text, ', ') as task_ids
+FROM tasks 
+WHERE project_id IS NOT NULL
+GROUP BY project_id, sort_order 
+HAVING COUNT(*) > 1
+ORDER BY project_id, sort_order;
+
+-- Check for duplicates in status_sort_order
+SELECT 
+    project_id,
+    status_sort_order,
+    COUNT(*) as duplicate_count,
+    STRING_AGG(id::text, ', ') as task_ids
+FROM tasks 
+WHERE project_id IS NOT NULL
+GROUP BY project_id, status_sort_order 
+HAVING COUNT(*) > 1
+ORDER BY project_id, status_sort_order;
+
+-- Check for duplicates in priority_sort_order
+SELECT 
+    project_id,
+    priority_sort_order,
+    COUNT(*) as duplicate_count,
+    STRING_AGG(id::text, ', ') as task_ids
+FROM tasks 
+WHERE project_id IS NOT NULL
+GROUP BY project_id, priority_sort_order 
+HAVING COUNT(*) > 1
+ORDER BY project_id, priority_sort_order;
+
+-- Check for duplicates in phase_sort_order
+SELECT 
+    project_id,
+    phase_sort_order,
+    COUNT(*) as duplicate_count,
+    STRING_AGG(id::text, ', ') as task_ids
+FROM tasks 
+WHERE project_id IS NOT NULL
+GROUP BY project_id, phase_sort_order 
+HAVING COUNT(*) > 1
+ORDER BY project_id, phase_sort_order;
+
+-- Note: member_sort_order removed - no longer used
+
+-- 2. CLEANUP FUNCTIONS
+
+-- Fix duplicates in main sort_order column
+CREATE OR REPLACE FUNCTION fix_sort_order_duplicates() RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _project RECORD;
+    _task RECORD;
+    _counter INTEGER;
+BEGIN
+    -- For each project, reassign sort_order values to ensure uniqueness
+    FOR _project IN 
+        SELECT DISTINCT project_id 
+        FROM tasks 
+        WHERE project_id IS NOT NULL
+    LOOP
+        _counter := 0;
+        
+        -- Reassign sort_order values sequentially for this project
+        FOR _task IN 
+            SELECT id 
+            FROM tasks 
+            WHERE project_id = _project.project_id 
+            ORDER BY sort_order, created_at
+        LOOP
+            UPDATE tasks 
+            SET sort_order = _counter 
+            WHERE id = _task.id;
+            
+            _counter := _counter + 1;
+        END LOOP;
+    END LOOP;
+    
+    RAISE NOTICE 'Fixed sort_order duplicates for all projects';
+END
+$$;
+
+-- Fix duplicates in status_sort_order column
+CREATE OR REPLACE FUNCTION fix_status_sort_order_duplicates() RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _project RECORD;
+    _task RECORD;
+    _counter INTEGER;
+BEGIN
+    FOR _project IN 
+        SELECT DISTINCT project_id 
+        FROM tasks 
+        WHERE project_id IS NOT NULL
+    LOOP
+        _counter := 0;
+        
+        FOR _task IN 
+            SELECT id 
+            FROM tasks 
+            WHERE project_id = _project.project_id 
+            ORDER BY status_sort_order, created_at
+        LOOP
+            UPDATE tasks 
+            SET status_sort_order = _counter 
+            WHERE id = _task.id;
+            
+            _counter := _counter + 1;
+        END LOOP;
+    END LOOP;
+    
+    RAISE NOTICE 'Fixed status_sort_order duplicates for all projects';
+END
+$$;
+
+-- Fix duplicates in priority_sort_order column
+CREATE OR REPLACE FUNCTION fix_priority_sort_order_duplicates() RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _project RECORD;
+    _task RECORD;
+    _counter INTEGER;
+BEGIN
+    FOR _project IN 
+        SELECT DISTINCT project_id 
+        FROM tasks 
+        WHERE project_id IS NOT NULL
+    LOOP
+        _counter := 0;
+        
+        FOR _task IN 
+            SELECT id 
+            FROM tasks 
+            WHERE project_id = _project.project_id 
+            ORDER BY priority_sort_order, created_at
+        LOOP
+            UPDATE tasks 
+            SET priority_sort_order = _counter 
+            WHERE id = _task.id;
+            
+            _counter := _counter + 1;
+        END LOOP;
+    END LOOP;
+    
+    RAISE NOTICE 'Fixed priority_sort_order duplicates for all projects';
+END
+$$;
+
+-- Fix duplicates in phase_sort_order column
+CREATE OR REPLACE FUNCTION fix_phase_sort_order_duplicates() RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _project RECORD;
+    _task RECORD;
+    _counter INTEGER;
+BEGIN
+    FOR _project IN 
+        SELECT DISTINCT project_id 
+        FROM tasks 
+        WHERE project_id IS NOT NULL
+    LOOP
+        _counter := 0;
+        
+        FOR _task IN 
+            SELECT id 
+            FROM tasks 
+            WHERE project_id = _project.project_id 
+            ORDER BY phase_sort_order, created_at
+        LOOP
+            UPDATE tasks 
+            SET phase_sort_order = _counter 
+            WHERE id = _task.id;
+            
+            _counter := _counter + 1;
+        END LOOP;
+    END LOOP;
+    
+    RAISE NOTICE 'Fixed phase_sort_order duplicates for all projects';
+END
+$$;
+
+-- Note: fix_member_sort_order_duplicates() removed - no longer needed
+
+-- Master function to fix all sort order duplicates
+CREATE OR REPLACE FUNCTION fix_all_duplicate_sort_orders() RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    RAISE NOTICE 'Starting sort order cleanup for all columns...';
+    
+    PERFORM fix_sort_order_duplicates();
+    PERFORM fix_status_sort_order_duplicates();
+    PERFORM fix_priority_sort_order_duplicates();
+    PERFORM fix_phase_sort_order_duplicates();
+    
+    RAISE NOTICE 'Completed sort order cleanup for all columns';
+END
+$$;
+
+-- 3. VERIFICATION FUNCTION
+
+-- Verify that duplicates have been fixed
+CREATE OR REPLACE FUNCTION verify_sort_order_integrity() RETURNS TABLE(
+    column_name text,
+    project_id uuid,
+    duplicate_count bigint,
+    status text
+)
+    LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    -- Check sort_order duplicates
+    RETURN QUERY
+    SELECT 
+        'sort_order'::text as column_name,
+        t.project_id,
+        COUNT(*) as duplicate_count,
+        CASE WHEN COUNT(*) > 1 THEN 'DUPLICATES FOUND' ELSE 'OK' END as status
+    FROM tasks t
+    WHERE t.project_id IS NOT NULL
+    GROUP BY t.project_id, t.sort_order
+    HAVING COUNT(*) > 1;
+    
+    -- Check status_sort_order duplicates
+    RETURN QUERY
+    SELECT 
+        'status_sort_order'::text as column_name,
+        t.project_id,
+        COUNT(*) as duplicate_count,
+        CASE WHEN COUNT(*) > 1 THEN 'DUPLICATES FOUND' ELSE 'OK' END as status
+    FROM tasks t
+    WHERE t.project_id IS NOT NULL
+    GROUP BY t.project_id, t.status_sort_order
+    HAVING COUNT(*) > 1;
+    
+    -- Check priority_sort_order duplicates
+    RETURN QUERY
+    SELECT 
+        'priority_sort_order'::text as column_name,
+        t.project_id,
+        COUNT(*) as duplicate_count,
+        CASE WHEN COUNT(*) > 1 THEN 'DUPLICATES FOUND' ELSE 'OK' END as status
+    FROM tasks t
+    WHERE t.project_id IS NOT NULL
+    GROUP BY t.project_id, t.priority_sort_order
+    HAVING COUNT(*) > 1;
+    
+    -- Check phase_sort_order duplicates
+    RETURN QUERY
+    SELECT 
+        'phase_sort_order'::text as column_name,
+        t.project_id,
+        COUNT(*) as duplicate_count,
+        CASE WHEN COUNT(*) > 1 THEN 'DUPLICATES FOUND' ELSE 'OK' END as status
+    FROM tasks t
+    WHERE t.project_id IS NOT NULL
+    GROUP BY t.project_id, t.phase_sort_order
+    HAVING COUNT(*) > 1;
+    
+    -- Note: member_sort_order verification removed - column no longer used
+    
+END
+$$;
+
+-- 4. USAGE INSTRUCTIONS
+
+/*
+USAGE:
+
+1. First, run the detection queries to see which projects have duplicates
+2. Then run this to fix all duplicates:
+   SELECT fix_all_duplicate_sort_orders();
+3. Finally, verify the fix worked:
+   SELECT * FROM verify_sort_order_integrity();
+   
+If verification returns no rows, all duplicates have been fixed successfully.
+
+WARNING: This will reassign sort order values based on current order + creation time.
+Make sure to backup your database before running these functions.
+*/

worklenz-backend/database/migrations/release-2.1.2/20250715000000-add-grouping-sort-orders.sql

@@ -0,0 +1,37 @@
+-- Migration: Add separate sort order columns for different grouping types
+-- This allows users to maintain different task orders when switching between grouping views
+
+-- Add new sort order columns
+ALTER TABLE tasks ADD COLUMN IF NOT EXISTS status_sort_order INTEGER DEFAULT 0;
+ALTER TABLE tasks ADD COLUMN IF NOT EXISTS priority_sort_order INTEGER DEFAULT 0;
+ALTER TABLE tasks ADD COLUMN IF NOT EXISTS phase_sort_order INTEGER DEFAULT 0;
+ALTER TABLE tasks ADD COLUMN IF NOT EXISTS member_sort_order INTEGER DEFAULT 0;
+
+-- Initialize new columns with current sort_order values
+UPDATE tasks SET 
+  status_sort_order = sort_order,
+  priority_sort_order = sort_order,
+  phase_sort_order = sort_order,
+  member_sort_order = sort_order
+WHERE status_sort_order = 0 
+   OR priority_sort_order = 0 
+   OR phase_sort_order = 0 
+   OR member_sort_order = 0;
+
+-- Add constraints to ensure non-negative values
+ALTER TABLE tasks ADD CONSTRAINT tasks_status_sort_order_check CHECK (status_sort_order >= 0);
+ALTER TABLE tasks ADD CONSTRAINT tasks_priority_sort_order_check CHECK (priority_sort_order >= 0);
+ALTER TABLE tasks ADD CONSTRAINT tasks_phase_sort_order_check CHECK (phase_sort_order >= 0);
+ALTER TABLE tasks ADD CONSTRAINT tasks_member_sort_order_check CHECK (member_sort_order >= 0);
+
+-- Add indexes for performance (since these will be used for ordering)
+CREATE INDEX IF NOT EXISTS idx_tasks_status_sort_order ON tasks(project_id, status_sort_order);
+CREATE INDEX IF NOT EXISTS idx_tasks_priority_sort_order ON tasks(project_id, priority_sort_order);
+CREATE INDEX IF NOT EXISTS idx_tasks_phase_sort_order ON tasks(project_id, phase_sort_order);
+CREATE INDEX IF NOT EXISTS idx_tasks_member_sort_order ON tasks(project_id, member_sort_order);
+
+-- Update comments for documentation
+COMMENT ON COLUMN tasks.status_sort_order IS 'Sort order when grouped by status';
+COMMENT ON COLUMN tasks.priority_sort_order IS 'Sort order when grouped by priority';
+COMMENT ON COLUMN tasks.phase_sort_order IS 'Sort order when grouped by phase';
+COMMENT ON COLUMN tasks.member_sort_order IS 'Sort order when grouped by members/assignees';

worklenz-backend/database/migrations/release-2.1.2/20250715000001-update-sort-functions.sql

@@ -0,0 +1,172 @@
+-- Migration: Update database functions to handle grouping-specific sort orders
+
+-- Function to get the appropriate sort column name based on grouping type
+CREATE OR REPLACE FUNCTION get_sort_column_name(_group_by TEXT) RETURNS TEXT
+    LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    CASE _group_by
+        WHEN 'status' THEN RETURN 'status_sort_order';
+        WHEN 'priority' THEN RETURN 'priority_sort_order';
+        WHEN 'phase' THEN RETURN 'phase_sort_order';
+        WHEN 'members' THEN RETURN 'member_sort_order';
+        ELSE RETURN 'sort_order'; -- fallback to general sort_order
+    END CASE;
+END;
+$$;
+
+-- Updated bulk sort order function to handle different sort columns
+CREATE OR REPLACE FUNCTION update_task_sort_orders_bulk(_updates json, _group_by text DEFAULT 'status') RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _update_record RECORD;
+    _sort_column TEXT;
+    _sql TEXT;
+BEGIN
+    -- Get the appropriate sort column based on grouping
+    _sort_column := get_sort_column_name(_group_by);
+    
+    -- Simple approach: update each task's sort_order from the provided array
+    FOR _update_record IN 
+        SELECT 
+            (item->>'task_id')::uuid as task_id,
+            (item->>'sort_order')::int as sort_order,
+            (item->>'status_id')::uuid as status_id,
+            (item->>'priority_id')::uuid as priority_id,
+            (item->>'phase_id')::uuid as phase_id
+        FROM json_array_elements(_updates) as item
+    LOOP
+        -- Update the appropriate sort column and other fields using dynamic SQL
+        -- Only update sort_order if we're using the default sorting
+        IF _sort_column = 'sort_order' THEN
+            UPDATE tasks SET 
+                sort_order = _update_record.sort_order,
+                status_id = COALESCE(_update_record.status_id, status_id),
+                priority_id = COALESCE(_update_record.priority_id, priority_id)
+            WHERE id = _update_record.task_id;
+        ELSE
+            -- Update only the grouping-specific sort column, not the main sort_order
+            _sql := 'UPDATE tasks SET ' || _sort_column || ' = $1, ' ||
+                    'status_id = COALESCE($2, status_id), ' ||
+                    'priority_id = COALESCE($3, priority_id) ' ||
+                    'WHERE id = $4';
+            
+            EXECUTE _sql USING 
+                _update_record.sort_order,
+                _update_record.status_id,
+                _update_record.priority_id,
+                _update_record.task_id;
+        END IF;
+        
+        -- Handle phase updates separately since it's in a different table
+        IF _update_record.phase_id IS NOT NULL THEN
+            INSERT INTO task_phase (task_id, phase_id)
+            VALUES (_update_record.task_id, _update_record.phase_id)
+            ON CONFLICT (task_id) DO UPDATE SET phase_id = _update_record.phase_id;
+        END IF;
+    END LOOP;
+END;
+$$;
+
+-- Updated main sort order change handler
+CREATE OR REPLACE FUNCTION handle_task_list_sort_order_change(_body json) RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _from_index INT;
+    _to_index   INT;
+    _task_id    UUID;
+    _project_id UUID;
+    _from_group UUID;
+    _to_group   UUID;
+    _group_by   TEXT;
+    _batch_size INT := 100;
+    _sort_column TEXT;
+    _sql TEXT;
+BEGIN
+    _project_id = (_body ->> 'project_id')::UUID;
+    _task_id = (_body ->> 'task_id')::UUID;
+    _from_index = (_body ->> 'from_index')::INT;
+    _to_index = (_body ->> 'to_index')::INT;
+    _from_group = (_body ->> 'from_group')::UUID;
+    _to_group = (_body ->> 'to_group')::UUID;
+    _group_by = (_body ->> 'group_by')::TEXT;
+    
+    -- Get the appropriate sort column
+    _sort_column := get_sort_column_name(_group_by);
+    
+    -- Handle group changes
+    IF (_from_group <> _to_group OR (_from_group <> _to_group) IS NULL) THEN
+        IF (_group_by = 'status') THEN
+            UPDATE tasks 
+            SET status_id = _to_group 
+            WHERE id = _task_id 
+              AND status_id = _from_group
+              AND project_id = _project_id;
+        END IF;
+        
+        IF (_group_by = 'priority') THEN
+            UPDATE tasks 
+            SET priority_id = _to_group 
+            WHERE id = _task_id 
+              AND priority_id = _from_group
+              AND project_id = _project_id;
+        END IF;
+        
+        IF (_group_by = 'phase') THEN
+            IF (is_null_or_empty(_to_group) IS FALSE) THEN
+                INSERT INTO task_phase (task_id, phase_id)
+                VALUES (_task_id, _to_group)
+                ON CONFLICT (task_id) DO UPDATE SET phase_id = _to_group;
+            ELSE
+                DELETE FROM task_phase WHERE task_id = _task_id;
+            END IF;
+        END IF;
+    END IF;
+
+    -- Handle sort order changes using dynamic SQL
+    IF (_from_index <> _to_index) THEN
+        -- For the main sort_order column, we need to be careful about unique constraints
+        IF _sort_column = 'sort_order' THEN
+            -- Use a transaction-safe approach for the main sort_order column
+            IF (_to_index > _from_index) THEN
+                -- Moving down: decrease sort_order for items between old and new position
+                UPDATE tasks SET sort_order = sort_order - 1 
+                WHERE project_id = _project_id 
+                  AND sort_order > _from_index 
+                  AND sort_order <= _to_index;
+            ELSE
+                -- Moving up: increase sort_order for items between new and old position  
+                UPDATE tasks SET sort_order = sort_order + 1 
+                WHERE project_id = _project_id 
+                  AND sort_order >= _to_index 
+                  AND sort_order < _from_index;
+            END IF;
+            
+            -- Set the new sort_order for the moved task
+            UPDATE tasks SET sort_order = _to_index WHERE id = _task_id;
+        ELSE
+            -- For grouping-specific columns, use dynamic SQL since there's no unique constraint
+            IF (_to_index > _from_index) THEN
+                -- Moving down: decrease sort_order for items between old and new position
+                _sql := 'UPDATE tasks SET ' || _sort_column || ' = ' || _sort_column || ' - 1 ' ||
+                       'WHERE project_id = $1 AND ' || _sort_column || ' > $2 AND ' || _sort_column || ' <= $3';
+                EXECUTE _sql USING _project_id, _from_index, _to_index;
+            ELSE
+                -- Moving up: increase sort_order for items between new and old position  
+                _sql := 'UPDATE tasks SET ' || _sort_column || ' = ' || _sort_column || ' + 1 ' ||
+                       'WHERE project_id = $1 AND ' || _sort_column || ' >= $2 AND ' || _sort_column || ' < $3';
+                EXECUTE _sql USING _project_id, _to_index, _from_index;
+            END IF;
+            
+            -- Set the new sort_order for the moved task
+            _sql := 'UPDATE tasks SET ' || _sort_column || ' = $1 WHERE id = $2';
+            EXECUTE _sql USING _to_index, _task_id;
+        END IF;
+    END IF;
+END;
+$$;

worklenz-backend/database/migrations/release-2.1.2/20250715000002-fix-sort-constraint.sql

@@ -0,0 +1,179 @@
+-- Migration: Fix sort order constraint violations
+
+-- First, let's ensure all existing tasks have unique sort_order values within each project
+-- This is a one-time fix to ensure data consistency
+
+DO $$
+DECLARE
+    _project RECORD;
+    _task RECORD;
+    _counter INTEGER;
+BEGIN
+    -- For each project, reassign sort_order values to ensure uniqueness
+    FOR _project IN 
+        SELECT DISTINCT project_id 
+        FROM tasks 
+        WHERE project_id IS NOT NULL
+    LOOP
+        _counter := 0;
+        
+        -- Reassign sort_order values sequentially for this project
+        FOR _task IN 
+            SELECT id 
+            FROM tasks 
+            WHERE project_id = _project.project_id 
+            ORDER BY sort_order, created_at
+        LOOP
+            UPDATE tasks 
+            SET sort_order = _counter 
+            WHERE id = _task.id;
+            
+            _counter := _counter + 1;
+        END LOOP;
+    END LOOP;
+END
+$$;
+
+-- Now create a better version of our functions that properly handles the constraints
+
+-- Updated bulk sort order function that avoids sort_order conflicts
+CREATE OR REPLACE FUNCTION update_task_sort_orders_bulk(_updates json, _group_by text DEFAULT 'status') RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _update_record RECORD;
+    _sort_column TEXT;
+    _sql TEXT;
+BEGIN
+    -- Get the appropriate sort column based on grouping
+    _sort_column := get_sort_column_name(_group_by);
+    
+    -- Process each update record
+    FOR _update_record IN 
+        SELECT 
+            (item->>'task_id')::uuid as task_id,
+            (item->>'sort_order')::int as sort_order,
+            (item->>'status_id')::uuid as status_id,
+            (item->>'priority_id')::uuid as priority_id,
+            (item->>'phase_id')::uuid as phase_id
+        FROM json_array_elements(_updates) as item
+    LOOP
+        -- Update the grouping-specific sort column and other fields
+        _sql := 'UPDATE tasks SET ' || _sort_column || ' = $1, ' ||
+                'status_id = COALESCE($2, status_id), ' ||
+                'priority_id = COALESCE($3, priority_id), ' ||
+                'updated_at = CURRENT_TIMESTAMP ' ||
+                'WHERE id = $4';
+        
+        EXECUTE _sql USING 
+            _update_record.sort_order,
+            _update_record.status_id,
+            _update_record.priority_id,
+            _update_record.task_id;
+        
+        -- Handle phase updates separately since it's in a different table
+        IF _update_record.phase_id IS NOT NULL THEN
+            INSERT INTO task_phase (task_id, phase_id)
+            VALUES (_update_record.task_id, _update_record.phase_id)
+            ON CONFLICT (task_id) DO UPDATE SET phase_id = _update_record.phase_id;
+        END IF;
+    END LOOP;
+END;
+$$;
+
+-- Also update the helper function to be more explicit
+CREATE OR REPLACE FUNCTION get_sort_column_name(_group_by TEXT) RETURNS TEXT
+    LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    CASE _group_by
+        WHEN 'status' THEN RETURN 'status_sort_order';
+        WHEN 'priority' THEN RETURN 'priority_sort_order';
+        WHEN 'phase' THEN RETURN 'phase_sort_order';
+        WHEN 'members' THEN RETURN 'member_sort_order';
+        -- For backward compatibility, still support general sort_order but be explicit
+        WHEN 'general' THEN RETURN 'sort_order';
+        ELSE RETURN 'status_sort_order'; -- Default to status sorting
+    END CASE;
+END;
+$$;
+
+-- Updated main sort order change handler that avoids conflicts
+CREATE OR REPLACE FUNCTION handle_task_list_sort_order_change(_body json) RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _from_index INT;
+    _to_index   INT;
+    _task_id    UUID;
+    _project_id UUID;
+    _from_group UUID;
+    _to_group   UUID;
+    _group_by   TEXT;
+    _sort_column TEXT;
+    _sql TEXT;
+BEGIN
+    _project_id = (_body ->> 'project_id')::UUID;
+    _task_id = (_body ->> 'task_id')::UUID;
+    _from_index = (_body ->> 'from_index')::INT;
+    _to_index = (_body ->> 'to_index')::INT;
+    _from_group = (_body ->> 'from_group')::UUID;
+    _to_group = (_body ->> 'to_group')::UUID;
+    _group_by = (_body ->> 'group_by')::TEXT;
+    
+    -- Get the appropriate sort column
+    _sort_column := get_sort_column_name(_group_by);
+    
+    -- Handle group changes first
+    IF (_from_group <> _to_group OR (_from_group <> _to_group) IS NULL) THEN
+        IF (_group_by = 'status') THEN
+            UPDATE tasks 
+            SET status_id = _to_group, updated_at = CURRENT_TIMESTAMP
+            WHERE id = _task_id 
+              AND project_id = _project_id;
+        END IF;
+        
+        IF (_group_by = 'priority') THEN
+            UPDATE tasks 
+            SET priority_id = _to_group, updated_at = CURRENT_TIMESTAMP
+            WHERE id = _task_id 
+              AND project_id = _project_id;
+        END IF;
+        
+        IF (_group_by = 'phase') THEN
+            IF (is_null_or_empty(_to_group) IS FALSE) THEN
+                INSERT INTO task_phase (task_id, phase_id)
+                VALUES (_task_id, _to_group)
+                ON CONFLICT (task_id) DO UPDATE SET phase_id = _to_group;
+            ELSE
+                DELETE FROM task_phase WHERE task_id = _task_id;
+            END IF;
+        END IF;
+    END IF;
+
+    -- Handle sort order changes for the grouping-specific column only
+    IF (_from_index <> _to_index) THEN
+        -- Update the grouping-specific sort order (no unique constraint issues)
+        IF (_to_index > _from_index) THEN
+            -- Moving down: decrease sort order for items between old and new position
+            _sql := 'UPDATE tasks SET ' || _sort_column || ' = ' || _sort_column || ' - 1, ' ||
+                   'updated_at = CURRENT_TIMESTAMP ' ||
+                   'WHERE project_id = $1 AND ' || _sort_column || ' > $2 AND ' || _sort_column || ' <= $3';
+            EXECUTE _sql USING _project_id, _from_index, _to_index;
+        ELSE
+            -- Moving up: increase sort order for items between new and old position  
+            _sql := 'UPDATE tasks SET ' || _sort_column || ' = ' || _sort_column || ' + 1, ' ||
+                   'updated_at = CURRENT_TIMESTAMP ' ||
+                   'WHERE project_id = $1 AND ' || _sort_column || ' >= $2 AND ' || _sort_column || ' < $3';
+            EXECUTE _sql USING _project_id, _to_index, _from_index;
+        END IF;
+        
+        -- Set the new sort order for the moved task
+        _sql := 'UPDATE tasks SET ' || _sort_column || ' = $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2';
+        EXECUTE _sql USING _to_index, _task_id;
+    END IF;
+END;
+$$;

worklenz-backend/database/pg-migrations/README.md

@@ -0,0 +1,72 @@
+# Node-pg-migrate Migrations
+
+This directory contains database migrations managed by node-pg-migrate.
+
+## Migration Commands
+
+- `npm run migrate:create -- migration-name` - Create a new migration file
+- `npm run migrate:up` - Run all pending migrations
+- `npm run migrate:down` - Rollback the last migration
+- `npm run migrate:redo` - Rollback and re-run the last migration
+
+## Migration File Format
+
+Migrations are JavaScript files with timestamp prefixes (e.g., `20250115000000_performance-indexes.js`).
+
+Each migration file exports two functions:
+- `exports.up` - Contains the forward migration logic
+- `exports.down` - Contains the rollback logic
+
+## Best Practices
+
+1. **Always use IF EXISTS/IF NOT EXISTS checks** to make migrations idempotent
+2. **Test migrations locally** before deploying to production
+3. **Include rollback logic** in the `down` function for all changes
+4. **Use descriptive names** for migration files
+5. **Keep migrations focused** - one logical change per migration
+
+## Example Migration
+
+```javascript
+exports.up = pgm => {
+  // Create table with IF NOT EXISTS
+  pgm.createTable('users', {
+    id: 'id',
+    name: { type: 'varchar(100)', notNull: true },
+    created_at: {
+      type: 'timestamp',
+      notNull: true,
+      default: pgm.func('current_timestamp')
+    }
+  }, { ifNotExists: true });
+
+  // Add index with IF NOT EXISTS
+  pgm.createIndex('users', 'name', {
+    name: 'idx_users_name',
+    ifNotExists: true
+  });
+};
+
+exports.down = pgm => {
+  // Drop in reverse order
+  pgm.dropIndex('users', 'name', { 
+    name: 'idx_users_name', 
+    ifExists: true 
+  });
+  
+  pgm.dropTable('users', { ifExists: true });
+};
+```
+
+## Migration History
+
+The `pgmigrations` table tracks which migrations have been run. Do not modify this table manually.
+
+## Converting from SQL Migrations
+
+When converting SQL migrations to node-pg-migrate format:
+
+1. Wrap SQL statements in `pgm.sql()` calls
+2. Use node-pg-migrate helper methods where possible (createTable, addColumns, etc.)
+3. Always include `IF EXISTS/IF NOT EXISTS` checks
+4. Ensure proper rollback logic in the `down` function

worklenz-backend/database/sql/1_tables.sql

@@ -12,10 +12,7 @@ CREATE TYPE DEPENDENCY_TYPE AS ENUM ('blocked_by');
 
 CREATE TYPE SCHEDULE_TYPE AS ENUM ('daily', 'weekly', 'yearly', 'monthly', 'every_x_days', 'every_x_weeks', 'every_x_months');
 
-CREATE TYPE LANGUAGE_TYPE AS ENUM ('en', 'es', 'pt');
-
--- Add progress mode type for tasks progress tracking
-CREATE TYPE PROGRESS_MODE_TYPE AS ENUM ('manual', 'weighted', 'time', 'default');
+CREATE TYPE LANGUAGE_TYPE AS ENUM ('en', 'es', 'pt', 'alb', 'de', 'zh_cn');
 
 -- START: Users
 CREATE SEQUENCE IF NOT EXISTS users_user_no_seq START 1;
@@ -780,15 +777,9 @@ CREATE TABLE IF NOT EXISTS projects (
     estimated_man_days     INTEGER                  DEFAULT 0,
     hours_per_day          INTEGER                  DEFAULT 8,
     health_id              UUID,
-    estimated_working_days INTEGER                  DEFAULT 0,
-    use_manual_progress    BOOLEAN                  DEFAULT FALSE,
-    use_weighted_progress  BOOLEAN                  DEFAULT FALSE,
-    use_time_progress      BOOLEAN                  DEFAULT FALSE,
-    currency               VARCHAR(3)               DEFAULT 'USD'
+    estimated_working_days INTEGER                  DEFAULT 0
 );
 
-COMMENT ON COLUMN projects.currency IS 'Project-specific currency code (e.g., USD, EUR, GBP, JPY, etc.)';
-
 ALTER TABLE projects
     ADD CONSTRAINT projects_pk
         PRIMARY KEY (id);
@@ -1400,36 +1391,32 @@ ALTER TABLE task_work_log
         CHECK (time_spent >= (0)::NUMERIC);
 
 CREATE TABLE IF NOT EXISTS tasks (
-    id                 UUID                     DEFAULT uuid_generate_v4() NOT NULL,
-    name               TEXT                                                NOT NULL,
-    description        TEXT,
-    done               BOOLEAN                  DEFAULT FALSE              NOT NULL,
-    total_minutes      NUMERIC                  DEFAULT 0                  NOT NULL,
-    archived           BOOLEAN                  DEFAULT FALSE              NOT NULL,
-    task_no            BIGINT                                              NOT NULL,
-    start_date         TIMESTAMP WITH TIME ZONE,
-    end_date           TIMESTAMP WITH TIME ZONE,
-    priority_id        UUID                                                NOT NULL,
-    project_id         UUID                                                NOT NULL,
-    reporter_id        UUID                                                NOT NULL,
-    parent_task_id     UUID,
-    status_id          UUID                                                NOT NULL,
-    completed_at       TIMESTAMP WITH TIME ZONE,
-    created_at         TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP  NOT NULL,
-    updated_at         TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP  NOT NULL,
-    sort_order         INTEGER                  DEFAULT 0                  NOT NULL,
-    roadmap_sort_order INTEGER                  DEFAULT 0                  NOT NULL,
-    billable           BOOLEAN                  DEFAULT TRUE,
-    schedule_id        UUID,
-    manual_progress    BOOLEAN                  DEFAULT FALSE,
-    progress_value     INTEGER                  DEFAULT NULL,
-    progress_mode      PROGRESS_MODE_TYPE      DEFAULT 'default',
-    weight             INTEGER                  DEFAULT NULL,
-    fixed_cost         DECIMAL(10, 2)           DEFAULT 0 CHECK (fixed_cost >= 0)
+    id                  UUID                     DEFAULT uuid_generate_v4() NOT NULL,
+    name                TEXT                                                NOT NULL,
+    description         TEXT,
+    done                BOOLEAN                  DEFAULT FALSE              NOT NULL,
+    total_minutes       NUMERIC                  DEFAULT 0                  NOT NULL,
+    archived            BOOLEAN                  DEFAULT FALSE              NOT NULL,
+    task_no             BIGINT                                              NOT NULL,
+    start_date          TIMESTAMP WITH TIME ZONE,
+    end_date            TIMESTAMP WITH TIME ZONE,
+    priority_id         UUID                                                NOT NULL,
+    project_id          UUID                                                NOT NULL,
+    reporter_id         UUID                                                NOT NULL,
+    parent_task_id      UUID,
+    status_id           UUID                                                NOT NULL,
+    completed_at        TIMESTAMP WITH TIME ZONE,
+    created_at          TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP  NOT NULL,
+    updated_at          TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP  NOT NULL,
+    sort_order          INTEGER                  DEFAULT 0                  NOT NULL,
+    roadmap_sort_order  INTEGER                  DEFAULT 0                  NOT NULL,
+    status_sort_order   INTEGER                  DEFAULT 0                  NOT NULL,
+    priority_sort_order INTEGER                  DEFAULT 0                  NOT NULL,
+    phase_sort_order    INTEGER                  DEFAULT 0                  NOT NULL,
+    billable            BOOLEAN                  DEFAULT TRUE,
+    schedule_id         UUID
 );
 
-COMMENT ON COLUMN tasks.fixed_cost IS 'Fixed cost for the task in addition to hourly rate calculations';
-
 ALTER TABLE tasks
     ADD CONSTRAINT tasks_pk
         PRIMARY KEY (id);
@@ -1515,6 +1502,21 @@ ALTER TABLE tasks
     ADD CONSTRAINT tasks_total_minutes_check
         CHECK ((total_minutes >= (0)::NUMERIC) AND (total_minutes <= (999999)::NUMERIC));
 
+-- Add constraints for new sort order columns
+ALTER TABLE tasks ADD CONSTRAINT tasks_status_sort_order_check CHECK (status_sort_order >= 0);
+ALTER TABLE tasks ADD CONSTRAINT tasks_priority_sort_order_check CHECK (priority_sort_order >= 0);
+ALTER TABLE tasks ADD CONSTRAINT tasks_phase_sort_order_check CHECK (phase_sort_order >= 0);
+
+-- Add indexes for performance on new sort order columns
+CREATE INDEX IF NOT EXISTS idx_tasks_status_sort_order ON tasks(project_id, status_sort_order);
+CREATE INDEX IF NOT EXISTS idx_tasks_priority_sort_order ON tasks(project_id, priority_sort_order);
+CREATE INDEX IF NOT EXISTS idx_tasks_phase_sort_order ON tasks(project_id, phase_sort_order);
+
+-- Add comments for documentation
+COMMENT ON COLUMN tasks.status_sort_order IS 'Sort order when grouped by status';
+COMMENT ON COLUMN tasks.priority_sort_order IS 'Sort order when grouped by priority';
+COMMENT ON COLUMN tasks.phase_sort_order IS 'Sort order when grouped by phase';
+
 CREATE TABLE IF NOT EXISTS tasks_assignees (
     task_id           UUID                                               NOT NULL,
     project_member_id UUID                                               NOT NULL,
@@ -2295,37 +2297,3 @@ ALTER TABLE organization_working_days
 ALTER TABLE organization_working_days
     ADD CONSTRAINT org_organization_id_fk
         FOREIGN KEY (organization_id) REFERENCES organizations;
-
--- Finance module tables
-CREATE TABLE IF NOT EXISTS finance_rate_cards (
-    id         UUID PRIMARY KEY                  DEFAULT uuid_generate_v4(),
-    team_id    UUID                     NOT NULL REFERENCES teams (id) ON DELETE CASCADE,
-    name       VARCHAR                  NOT NULL,
-    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    currency   TEXT NOT NULL DEFAULT 'USD'
-);
-
-CREATE TABLE IF NOT EXISTS finance_project_rate_card_roles (
-    id         UUID PRIMARY KEY                  DEFAULT uuid_generate_v4(),
-    project_id UUID                     NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
-    job_title_id    UUID                     NOT NULL REFERENCES job_titles (id) ON DELETE CASCADE,
-    rate       DECIMAL(10, 2)           NOT NULL CHECK (rate >= 0),
-    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    CONSTRAINT unique_project_role UNIQUE (project_id, job_title_id)
-);
-
-CREATE TABLE IF NOT EXISTS finance_rate_card_roles (
-    rate_card_id UUID                     NOT NULL REFERENCES finance_rate_cards (id) ON DELETE CASCADE,
-    job_title_id      UUID                     REFERENCES job_titles(id) ON DELETE SET NULL,
-    rate         DECIMAL(10, 2)           NOT NULL CHECK (rate >= 0),
-    created_at   TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at   TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-
-ALTER TABLE project_members
-    ADD COLUMN IF NOT EXISTS project_rate_card_role_id UUID REFERENCES finance_project_rate_card_roles(id) ON DELETE SET NULL;
-
-ALTER TABLE projects
-    ADD COLUMN IF NOT EXISTS rate_card UUID REFERENCES finance_rate_cards(id) ON DELETE SET NULL;

worklenz-backend/database/sql/3_views.sql

@@ -32,3 +32,37 @@ SELECT u.avatar_url,
 FROM team_members
          LEFT JOIN users u ON team_members.user_id = u.id;
 
+-- PERFORMANCE OPTIMIZATION: Create materialized view for team member info
+-- This pre-calculates the expensive joins and subqueries from team_member_info_view
+CREATE MATERIALIZED VIEW IF NOT EXISTS team_member_info_mv AS
+SELECT 
+    u.avatar_url,
+    COALESCE(u.email, ei.email) AS email,
+    COALESCE(u.name, ei.name) AS name,
+    u.id AS user_id,
+    tm.id AS team_member_id,
+    tm.team_id,
+    tm.active,
+    u.socket_id
+FROM team_members tm
+LEFT JOIN users u ON tm.user_id = u.id
+LEFT JOIN email_invitations ei ON ei.team_member_id = tm.id
+WHERE tm.active = TRUE;
+
+-- Create unique index on the materialized view for fast lookups
+CREATE UNIQUE INDEX IF NOT EXISTS idx_team_member_info_mv_team_member_id 
+ON team_member_info_mv(team_member_id);
+
+CREATE INDEX IF NOT EXISTS idx_team_member_info_mv_team_user 
+ON team_member_info_mv(team_id, user_id);
+
+-- Function to refresh the materialized view
+CREATE OR REPLACE FUNCTION refresh_team_member_info_mv()
+RETURNS void
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    REFRESH MATERIALIZED VIEW CONCURRENTLY team_member_info_mv;
+END;
+$$;
+

worklenz-backend/database/sql/4_functions.sql

@@ -4117,7 +4117,7 @@ BEGIN
             'color_code_dark', COALESCE((_task_info ->> 'color_code_dark')::TEXT, ''),
             'total_tasks', COALESCE((_task_info ->> 'total_tasks')::INT, 0),
             'total_completed', COALESCE((_task_info ->> 'total_completed')::INT, 0),
-            'members', COALESCE((_task_info -> 'members'), '[]'::JSON),
+            'members', COALESCE((_task_info ->> 'members')::JSON, '[]'::JSON),
             'completed_at', _task_completed_at,
             'status_category', COALESCE(_status_category, '{}'::JSON),
             'schedule_id', COALESCE(_schedule_id, 'null'::JSON)
@@ -4313,6 +4313,24 @@ BEGIN
 END
 $$;
 
+-- Helper function to get the appropriate sort column name based on grouping type
+CREATE OR REPLACE FUNCTION get_sort_column_name(_group_by TEXT) RETURNS TEXT
+    LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    CASE _group_by
+        WHEN 'status' THEN RETURN 'status_sort_order';
+        WHEN 'priority' THEN RETURN 'priority_sort_order';
+        WHEN 'phase' THEN RETURN 'phase_sort_order';
+        WHEN 'members' THEN RETURN 'member_sort_order';
+        -- For backward compatibility, still support general sort_order but be explicit
+        WHEN 'general' THEN RETURN 'sort_order';
+        ELSE RETURN 'status_sort_order'; -- Default to status sorting
+    END CASE;
+END;
+$$;
+
 CREATE OR REPLACE FUNCTION handle_task_list_sort_order_change(_body json) RETURNS void
     LANGUAGE plpgsql
 AS
@@ -4325,54 +4343,67 @@ DECLARE
     _from_group UUID;
     _to_group   UUID;
     _group_by   TEXT;
+    _sort_column TEXT;
+    _sql TEXT;
 BEGIN
     _project_id = (_body ->> 'project_id')::UUID;
     _task_id = (_body ->> 'task_id')::UUID;
-
-    _from_index = (_body ->> 'from_index')::INT; -- from sort_order
-    _to_index = (_body ->> 'to_index')::INT; -- to sort_order
-
+    _from_index = (_body ->> 'from_index')::INT;
+    _to_index = (_body ->> 'to_index')::INT;
     _from_group = (_body ->> 'from_group')::UUID;
     _to_group = (_body ->> 'to_group')::UUID;
-
     _group_by = (_body ->> 'group_by')::TEXT;
-
-    IF (_from_group <> _to_group OR (_from_group <> _to_group) IS NULL)
-    THEN
-        IF (_group_by = 'status')
-        THEN
-            UPDATE tasks SET status_id = _to_group WHERE id = _task_id AND status_id = _from_group;
+    
+    -- Get the appropriate sort column
+    _sort_column := get_sort_column_name(_group_by);
+    
+    -- Handle group changes first
+    IF (_from_group <> _to_group OR (_from_group <> _to_group) IS NULL) THEN
+        IF (_group_by = 'status') THEN
+            UPDATE tasks 
+            SET status_id = _to_group, updated_at = CURRENT_TIMESTAMP
+            WHERE id = _task_id 
+              AND project_id = _project_id;
         END IF;
-
-        IF (_group_by = 'priority')
-        THEN
-            UPDATE tasks SET priority_id = _to_group WHERE id = _task_id AND priority_id = _from_group;
+        
+        IF (_group_by = 'priority') THEN
+            UPDATE tasks 
+            SET priority_id = _to_group, updated_at = CURRENT_TIMESTAMP
+            WHERE id = _task_id 
+              AND project_id = _project_id;
         END IF;
-
-        IF (_group_by = 'phase')
-        THEN
-            IF (is_null_or_empty(_to_group) IS FALSE)
-            THEN
+        
+        IF (_group_by = 'phase') THEN
+            IF (is_null_or_empty(_to_group) IS FALSE) THEN
                 INSERT INTO task_phase (task_id, phase_id)
                 VALUES (_task_id, _to_group)
                 ON CONFLICT (task_id) DO UPDATE SET phase_id = _to_group;
-            END IF;
-            IF (is_null_or_empty(_to_group) IS TRUE)
-            THEN
-                DELETE
-                FROM task_phase
-                WHERE task_id = _task_id;
+            ELSE
+                DELETE FROM task_phase WHERE task_id = _task_id;
             END IF;
         END IF;
+    END IF;
 
-        IF ((_body ->> 'to_last_index')::BOOLEAN IS TRUE AND _from_index < _to_index)
-        THEN
-            PERFORM handle_task_list_sort_inside_group(_from_index, _to_index, _task_id, _project_id);
+    -- Handle sort order changes for the grouping-specific column only
+    IF (_from_index <> _to_index) THEN
+        -- Update the grouping-specific sort order (no unique constraint issues)
+        IF (_to_index > _from_index) THEN
+            -- Moving down: decrease sort order for items between old and new position
+            _sql := 'UPDATE tasks SET ' || _sort_column || ' = ' || _sort_column || ' - 1, ' ||
+                   'updated_at = CURRENT_TIMESTAMP ' ||
+                   'WHERE project_id = $1 AND ' || _sort_column || ' > $2 AND ' || _sort_column || ' <= $3';
+            EXECUTE _sql USING _project_id, _from_index, _to_index;
         ELSE
-            PERFORM handle_task_list_sort_between_groups(_from_index, _to_index, _task_id, _project_id);
+            -- Moving up: increase sort order for items between new and old position  
+            _sql := 'UPDATE tasks SET ' || _sort_column || ' = ' || _sort_column || ' + 1, ' ||
+                   'updated_at = CURRENT_TIMESTAMP ' ||
+                   'WHERE project_id = $1 AND ' || _sort_column || ' >= $2 AND ' || _sort_column || ' < $3';
+            EXECUTE _sql USING _project_id, _to_index, _from_index;
         END IF;
-    ELSE
-        PERFORM handle_task_list_sort_inside_group(_from_index, _to_index, _task_id, _project_id);
+        
+        -- Set the new sort order for the moved task
+        _sql := 'UPDATE tasks SET ' || _sort_column || ' = $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2';
+        EXECUTE _sql USING _to_index, _task_id;
     END IF;
 END
 $$;
@@ -4577,31 +4608,31 @@ BEGIN
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
     VALUES (_project_id, 'Progress', 'PROGRESS', 3, TRUE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Members', 'ASSIGNEES', 4, TRUE);
+    VALUES (_project_id, 'Status', 'STATUS', 4, TRUE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Labels', 'LABELS', 5, TRUE);
+    VALUES (_project_id, 'Members', 'ASSIGNEES', 5, TRUE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Status', 'STATUS', 6, TRUE);
+    VALUES (_project_id, 'Labels', 'LABELS', 6, TRUE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Priority', 'PRIORITY', 7, TRUE);
+    VALUES (_project_id, 'Phase', 'PHASE', 7, TRUE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Time Tracking', 'TIME_TRACKING', 8, TRUE);
+    VALUES (_project_id, 'Priority', 'PRIORITY', 8, TRUE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Estimation', 'ESTIMATION', 9, FALSE);
+    VALUES (_project_id, 'Time Tracking', 'TIME_TRACKING', 9, TRUE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Start Date', 'START_DATE', 10, FALSE);
+    VALUES (_project_id, 'Estimation', 'ESTIMATION', 10, FALSE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Due Date', 'DUE_DATE', 11, TRUE);
+    VALUES (_project_id, 'Start Date', 'START_DATE', 11, FALSE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Completed Date', 'COMPLETED_DATE', 12, FALSE);
+    VALUES (_project_id, 'Due Date', 'DUE_DATE', 12, TRUE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Created Date', 'CREATED_DATE', 13, FALSE);
+    VALUES (_project_id, 'Completed Date', 'COMPLETED_DATE', 13, FALSE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Last Updated', 'LAST_UPDATED', 14, FALSE);
+    VALUES (_project_id, 'Created Date', 'CREATED_DATE', 14, FALSE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Reporter', 'REPORTER', 15, FALSE);
+    VALUES (_project_id, 'Last Updated', 'LAST_UPDATED', 15, FALSE);
     INSERT INTO project_task_list_cols (project_id, name, key, index, pinned)
-    VALUES (_project_id, 'Phase', 'PHASE', 16, FALSE);
+    VALUES (_project_id, 'Reporter', 'REPORTER', 16, FALSE);
 END
 $$;
 
@@ -5401,8 +5432,7 @@ BEGIN
         updated_at             = CURRENT_TIMESTAMP,
         estimated_working_days = (_body ->> 'working_days')::INTEGER,
         estimated_man_days     = (_body ->> 'man_days')::INTEGER,
-        hours_per_day          = (_body ->> 'hours_per_day')::INTEGER,
-        currency               = COALESCE(UPPER((_body ->> 'currency')::TEXT), currency)
+        hours_per_day          = (_body ->> 'hours_per_day')::INTEGER
     WHERE id = (_body ->> 'id')::UUID
       AND team_id = _team_id
     RETURNING id INTO _project_id;
@@ -5486,8 +5516,15 @@ $$
 DECLARE
     _iterator  NUMERIC := 0;
     _status_id TEXT;
+    _project_id UUID;
+    _base_sort_order NUMERIC;
 BEGIN
+    -- Get the project_id from the first status to ensure we update all statuses in the same project
+    SELECT project_id INTO _project_id
+    FROM task_statuses 
+    WHERE id = (SELECT TRIM(BOTH '"' FROM JSON_ARRAY_ELEMENTS(_status_ids)::TEXT) LIMIT 1)::UUID;
 
+    -- Update the sort_order for statuses in the provided order
     FOR _status_id IN SELECT * FROM JSON_ARRAY_ELEMENTS((_status_ids)::JSON)
         LOOP
             UPDATE task_statuses
@@ -5496,6 +5533,29 @@ BEGIN
             _iterator := _iterator + 1;
         END LOOP;
 
+    -- Get the base sort order for remaining statuses (simple count approach)
+    SELECT COUNT(*) INTO _base_sort_order
+    FROM task_statuses ts2 
+    WHERE ts2.project_id = _project_id 
+    AND ts2.id = ANY(SELECT (TRIM(BOTH '"' FROM JSON_ARRAY_ELEMENTS(_status_ids)::TEXT))::UUID);
+
+    -- Update remaining statuses with simple sequential numbering
+    -- Reset iterator to start from base_sort_order
+    _iterator := _base_sort_order;
+    
+    -- Use a cursor approach to avoid window functions
+    FOR _status_id IN 
+        SELECT id::TEXT FROM task_statuses 
+        WHERE project_id = _project_id 
+        AND id NOT IN (SELECT (TRIM(BOTH '"' FROM JSON_ARRAY_ELEMENTS(_status_ids)::TEXT))::UUID)
+        ORDER BY sort_order
+    LOOP
+        UPDATE task_statuses 
+        SET sort_order = _iterator
+        WHERE id = _status_id::UUID;
+        _iterator := _iterator + 1;
+    END LOOP;
+
     RETURN;
 END
 $$;
@@ -6374,43 +6434,217 @@ BEGIN
 END;
 $$;
 
-CREATE OR REPLACE VIEW project_finance_view AS
-SELECT 
-    t.id,
-    t.name,
-    t.total_minutes / 3600.0 as estimated_hours,
-    COALESCE((SELECT SUM(time_spent) FROM task_work_log WHERE task_id = t.id), 0) / 3600.0 as total_time_logged,
-    COALESCE((SELECT SUM(rate * (time_spent / 3600.0)) 
-              FROM task_work_log twl 
-              LEFT JOIN users u ON twl.user_id = u.id
-              LEFT JOIN team_members tm ON u.id = tm.user_id
-              LEFT JOIN project_members pm ON tm.id = pm.team_member_id
-              LEFT JOIN finance_project_rate_card_roles pmr ON pm.project_rate_card_role_id = pmr.id
-              WHERE twl.task_id = t.id), 0) as estimated_cost,
-    0 as fixed_cost, -- Default to 0 since the column doesn't exist
-    COALESCE(t.total_minutes / 3600.0 * 
-        (SELECT rate FROM finance_project_rate_card_roles 
-         WHERE project_id = t.project_id 
-         AND id = (SELECT project_rate_card_role_id FROM project_members WHERE team_member_id = t.reporter_id LIMIT 1)
-         LIMIT 1), 0) as total_budgeted_cost,
-    COALESCE((SELECT SUM(rate * (time_spent / 3600.0)) 
-              FROM task_work_log twl 
-              LEFT JOIN users u ON twl.user_id = u.id
-              LEFT JOIN team_members tm ON u.id = tm.user_id
-              LEFT JOIN project_members pm ON tm.id = pm.team_member_id
-              LEFT JOIN finance_project_rate_card_roles pmr ON pm.project_rate_card_role_id = pmr.id
-              WHERE twl.task_id = t.id), 0) as total_actual_cost,
-    COALESCE((SELECT SUM(rate * (time_spent / 3600.0)) 
-              FROM task_work_log twl 
-              LEFT JOIN users u ON twl.user_id = u.id
-              LEFT JOIN team_members tm ON u.id = tm.user_id
-              LEFT JOIN project_members pm ON tm.id = pm.team_member_id
-              LEFT JOIN finance_project_rate_card_roles pmr ON pm.project_rate_card_role_id = pmr.id
-              WHERE twl.task_id = t.id), 0) - 
-    COALESCE(t.total_minutes / 3600.0 * 
-        (SELECT rate FROM finance_project_rate_card_roles 
-         WHERE project_id = t.project_id 
-         AND id = (SELECT project_rate_card_role_id FROM project_members WHERE team_member_id = t.reporter_id LIMIT 1)
-         LIMIT 1), 0) as variance,
-    t.project_id
-FROM tasks t;
+-- PERFORMANCE OPTIMIZATION: Optimized version with batching for large datasets
+CREATE OR REPLACE FUNCTION handle_task_list_sort_between_groups_optimized(_from_index integer, _to_index integer, _task_id uuid, _project_id uuid, _batch_size integer DEFAULT 100) RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _offset INT := 0;
+    _affected_rows INT;
+BEGIN
+    -- PERFORMANCE OPTIMIZATION: Use direct updates without CTE in UPDATE
+    IF (_to_index = -1)
+    THEN
+        _to_index = COALESCE((SELECT MAX(sort_order) + 1 FROM tasks WHERE project_id = _project_id), 0);
+    END IF;
+
+    -- PERFORMANCE OPTIMIZATION: Batch updates for large datasets
+    IF _to_index > _from_index
+    THEN
+        LOOP
+            UPDATE tasks
+            SET sort_order = sort_order - 1
+            WHERE project_id = _project_id
+              AND sort_order > _from_index
+              AND sort_order < _to_index
+              AND sort_order > _offset
+              AND sort_order <= _offset + _batch_size;
+            
+            GET DIAGNOSTICS _affected_rows = ROW_COUNT;
+            EXIT WHEN _affected_rows = 0;
+            _offset := _offset + _batch_size;
+        END LOOP;
+
+        UPDATE tasks SET sort_order = _to_index - 1 WHERE id = _task_id AND project_id = _project_id;
+    END IF;
+
+    IF _to_index < _from_index
+    THEN
+        _offset := 0;
+        LOOP
+            UPDATE tasks
+            SET sort_order = sort_order + 1
+            WHERE project_id = _project_id
+              AND sort_order > _to_index
+              AND sort_order < _from_index
+              AND sort_order > _offset
+              AND sort_order <= _offset + _batch_size;
+            
+            GET DIAGNOSTICS _affected_rows = ROW_COUNT;
+            EXIT WHEN _affected_rows = 0;
+            _offset := _offset + _batch_size;
+        END LOOP;
+
+        UPDATE tasks SET sort_order = _to_index + 1 WHERE id = _task_id AND project_id = _project_id;
+    END IF;
+END
+$$;
+
+-- PERFORMANCE OPTIMIZATION: Optimized version with batching for large datasets
+CREATE OR REPLACE FUNCTION handle_task_list_sort_inside_group_optimized(_from_index integer, _to_index integer, _task_id uuid, _project_id uuid, _batch_size integer DEFAULT 100) RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _offset INT := 0;
+    _affected_rows INT;
+BEGIN
+    -- PERFORMANCE OPTIMIZATION: Batch updates for large datasets without CTE in UPDATE
+    IF _to_index > _from_index
+    THEN
+        LOOP
+            UPDATE tasks
+            SET sort_order = sort_order - 1
+            WHERE project_id = _project_id
+              AND sort_order > _from_index
+              AND sort_order <= _to_index
+              AND sort_order > _offset
+              AND sort_order <= _offset + _batch_size;
+            
+            GET DIAGNOSTICS _affected_rows = ROW_COUNT;
+            EXIT WHEN _affected_rows = 0;
+            _offset := _offset + _batch_size;
+        END LOOP;
+    END IF;
+
+    IF _to_index < _from_index
+    THEN
+        _offset := 0;
+        LOOP
+            UPDATE tasks
+            SET sort_order = sort_order + 1
+            WHERE project_id = _project_id
+              AND sort_order >= _to_index
+              AND sort_order < _from_index
+              AND sort_order > _offset
+              AND sort_order <= _offset + _batch_size;
+            
+            GET DIAGNOSTICS _affected_rows = ROW_COUNT;
+            EXIT WHEN _affected_rows = 0;
+            _offset := _offset + _batch_size;
+        END LOOP;
+    END IF;
+
+    UPDATE tasks SET sort_order = _to_index WHERE id = _task_id AND project_id = _project_id;
+END
+$$;
+
+-- Updated bulk sort order function that avoids sort_order conflicts
+CREATE OR REPLACE FUNCTION update_task_sort_orders_bulk(_updates json, _group_by text DEFAULT 'status') RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _update_record RECORD;
+    _sort_column TEXT;
+    _sql TEXT;
+BEGIN
+    -- Get the appropriate sort column based on grouping
+    _sort_column := get_sort_column_name(_group_by);
+    
+    -- Process each update record
+    FOR _update_record IN 
+        SELECT 
+            (item->>'task_id')::uuid as task_id,
+            (item->>'sort_order')::int as sort_order,
+            (item->>'status_id')::uuid as status_id,
+            (item->>'priority_id')::uuid as priority_id,
+            (item->>'phase_id')::uuid as phase_id
+        FROM json_array_elements(_updates) as item
+    LOOP
+        -- Update the grouping-specific sort column and other fields
+        _sql := 'UPDATE tasks SET ' || _sort_column || ' = $1, ' ||
+                'status_id = COALESCE($2, status_id), ' ||
+                'priority_id = COALESCE($3, priority_id), ' ||
+                'updated_at = CURRENT_TIMESTAMP ' ||
+                'WHERE id = $4';
+        
+        EXECUTE _sql USING 
+            _update_record.sort_order,
+            _update_record.status_id,
+            _update_record.priority_id,
+            _update_record.task_id;
+        
+        -- Handle phase updates separately since it's in a different table
+        IF _update_record.phase_id IS NOT NULL THEN
+            INSERT INTO task_phase (task_id, phase_id)
+            VALUES (_update_record.task_id, _update_record.phase_id)
+            ON CONFLICT (task_id) DO UPDATE SET phase_id = _update_record.phase_id;
+        END IF;
+    END LOOP;
+END
+$$;
+
+-- Function to get the appropriate sort column name based on grouping type
+CREATE OR REPLACE FUNCTION get_sort_column_name(_group_by TEXT) RETURNS TEXT
+    LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    CASE _group_by
+        WHEN 'status' THEN RETURN 'status_sort_order';
+        WHEN 'priority' THEN RETURN 'priority_sort_order';
+        WHEN 'phase' THEN RETURN 'phase_sort_order';
+        -- For backward compatibility, still support general sort_order but be explicit
+        WHEN 'general' THEN RETURN 'sort_order';
+        ELSE RETURN 'status_sort_order'; -- Default to status sorting
+    END CASE;
+END;
+$$;
+
+-- Updated bulk sort order function to handle different sort columns
+CREATE OR REPLACE FUNCTION update_task_sort_orders_bulk(_updates json, _group_by text DEFAULT 'status') RETURNS void
+    LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    _update_record RECORD;
+    _sort_column TEXT;
+    _sql TEXT;
+BEGIN
+    -- Get the appropriate sort column based on grouping
+    _sort_column := get_sort_column_name(_group_by);
+    
+    -- Process each update record
+    FOR _update_record IN 
+        SELECT 
+            (item->>'task_id')::uuid as task_id,
+            (item->>'sort_order')::int as sort_order,
+            (item->>'status_id')::uuid as status_id,
+            (item->>'priority_id')::uuid as priority_id,
+            (item->>'phase_id')::uuid as phase_id
+        FROM json_array_elements(_updates) as item
+    LOOP
+        -- Update the grouping-specific sort column and other fields
+        _sql := 'UPDATE tasks SET ' || _sort_column || ' = $1, ' ||
+                'status_id = COALESCE($2, status_id), ' ||
+                'priority_id = COALESCE($3, priority_id), ' ||
+                'updated_at = CURRENT_TIMESTAMP ' ||
+                'WHERE id = $4';
+        
+        EXECUTE _sql USING 
+            _update_record.sort_order,
+            _update_record.status_id,
+            _update_record.priority_id,
+            _update_record.task_id;
+        
+        -- Handle phase updates separately since it's in a different table
+        IF _update_record.phase_id IS NOT NULL THEN
+            INSERT INTO task_phase (task_id, phase_id)
+            VALUES (_update_record.task_id, _update_record.phase_id)
+            ON CONFLICT (task_id) DO UPDATE SET phase_id = _update_record.phase_id;
+        END IF;
+    END LOOP;
+END;
+$$;

worklenz-backend/database/sql/indexes.sql

@@ -132,3 +132,139 @@ CREATE INDEX IF NOT EXISTS projects_team_id_index
 CREATE INDEX IF NOT EXISTS projects_team_id_name_index
     ON projects (team_id, name);
 
+-- Performance indexes for optimized tasks queries
+-- From migration: 20250115000000-performance-indexes.sql
+
+-- Composite index for main task filtering
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_project_archived_parent 
+ON tasks(project_id, archived, parent_task_id) 
+WHERE archived = FALSE;
+
+-- Index for status joins
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_status_project 
+ON tasks(status_id, project_id) 
+WHERE archived = FALSE;
+
+-- Index for assignees lookup
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_assignees_task_member 
+ON tasks_assignees(task_id, team_member_id);
+
+-- Index for phase lookup
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_phase_task_phase 
+ON task_phase(task_id, phase_id);
+
+-- Index for subtask counting
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_parent_archived 
+ON tasks(parent_task_id, archived) 
+WHERE parent_task_id IS NOT NULL AND archived = FALSE;
+
+-- Index for labels
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_labels_task_label 
+ON task_labels(task_id, label_id);
+
+-- Index for comments count
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_comments_task 
+ON task_comments(task_id);
+
+-- Index for attachments count
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_attachments_task 
+ON task_attachments(task_id);
+
+-- Index for work log aggregation
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_work_log_task 
+ON task_work_log(task_id);
+
+-- Index for subscribers check
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_subscribers_task 
+ON task_subscribers(task_id);
+
+-- Index for dependencies check
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_dependencies_task 
+ON task_dependencies(task_id);
+
+-- Index for timers lookup
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_timers_task_user 
+ON task_timers(task_id, user_id);
+
+-- Index for custom columns
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_cc_column_values_task 
+ON cc_column_values(task_id);
+
+-- Index for team member info view optimization
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_team_members_team_user 
+ON team_members(team_id, user_id) 
+WHERE active = TRUE;
+
+-- Index for notification settings
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_notification_settings_user_team 
+ON notification_settings(user_id, team_id);
+
+-- Index for task status categories
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_statuses_category 
+ON task_statuses(category_id, project_id);
+
+-- Index for project phases
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_project_phases_project_sort 
+ON project_phases(project_id, sort_index);
+
+-- Index for task priorities
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_priorities_value 
+ON task_priorities(value);
+
+-- Index for team labels
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_team_labels_team 
+ON team_labels(team_id);
+
+-- Advanced performance indexes for task optimization
+
+-- Composite index for task main query optimization (covers most WHERE conditions)
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_performance_main
+ON tasks(project_id, archived, parent_task_id, status_id, priority_id)
+WHERE archived = FALSE;
+
+-- Index for sorting by sort_order with project filter
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_project_sort_order
+ON tasks(project_id, sort_order)
+WHERE archived = FALSE;
+
+-- Index for email_invitations to optimize team_member_info_view
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_email_invitations_team_member
+ON email_invitations(team_member_id);
+
+-- Covering index for task status with category information
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_statuses_covering
+ON task_statuses(id, category_id, project_id);
+
+-- Index for task aggregation queries (parent task progress calculation)
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_parent_status_archived
+ON tasks(parent_task_id, status_id, archived)
+WHERE archived = FALSE;
+
+-- Index for project team member filtering
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_team_members_project_lookup
+ON team_members(team_id, active, user_id)
+WHERE active = TRUE;
+
+-- Covering index for tasks with frequently accessed columns
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_covering_main
+ON tasks(id, project_id, archived, parent_task_id, status_id, priority_id, sort_order, name)
+WHERE archived = FALSE;
+
+-- Index for task search functionality
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_name_search
+ON tasks USING gin(to_tsvector('english', name))
+WHERE archived = FALSE;
+
+-- Index for date-based filtering (if used)
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_dates
+ON tasks(project_id, start_date, end_date)
+WHERE archived = FALSE;
+
+-- Index for task timers with user filtering
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_timers_user_task
+ON task_timers(user_id, task_id);
+
+-- Index for sys_task_status_categories lookups
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_sys_task_status_categories_covering
+ON sys_task_status_categories(id, color_code, color_code_dark, is_done, is_doing, is_todo);
+

worklenz-backend/fix-task-hierarchy.sql

@@ -1,77 +0,0 @@
--- Fix task hierarchy and reset parent estimations
--- This script ensures proper parent-child relationships and resets parent estimations
-
--- First, let's see the current task hierarchy
-SELECT 
-    t.id,
-    t.name,
-    t.parent_task_id,
-    t.total_minutes,
-    (SELECT name FROM tasks WHERE id = t.parent_task_id) as parent_name,
-    (SELECT COUNT(*) FROM tasks WHERE parent_task_id = t.id AND archived = false) as actual_subtask_count,
-    t.archived
-FROM tasks t
-WHERE (t.name LIKE '%sub%' OR t.name LIKE '%test task%')
-ORDER BY t.name, t.created_at;
-
--- Reset all parent task estimations to 0
--- This ensures parent tasks don't have their own estimation when they have subtasks
-UPDATE tasks 
-SET total_minutes = 0
-WHERE id IN (
-    SELECT DISTINCT parent_task_id 
-    FROM tasks 
-    WHERE parent_task_id IS NOT NULL 
-    AND archived = false
-)
-AND archived = false;
-
--- Verify the results after the update
-SELECT 
-    t.id,
-    t.name,
-    t.parent_task_id,
-    t.total_minutes as current_estimation,
-    (SELECT name FROM tasks WHERE id = t.parent_task_id) as parent_name,
-    (SELECT COUNT(*) FROM tasks WHERE parent_task_id = t.id AND archived = false) as subtask_count,
-    get_task_recursive_estimation(t.id) as recursive_estimation
-FROM tasks t
-WHERE (t.name LIKE '%sub%' OR t.name LIKE '%test task%')
-AND t.archived = false
-ORDER BY t.name;
-
--- Show the hierarchy in tree format
-WITH RECURSIVE task_hierarchy AS (
-    -- Top level tasks (no parent)
-    SELECT 
-        id,
-        name,
-        parent_task_id,
-        total_minutes,
-        0 as level,
-        name as path
-    FROM tasks
-    WHERE parent_task_id IS NULL
-    AND (name LIKE '%sub%' OR name LIKE '%test task%')
-    AND archived = false
-    
-    UNION ALL
-    
-    -- Child tasks
-    SELECT 
-        t.id,
-        t.name,
-        t.parent_task_id,
-        t.total_minutes,
-        th.level + 1,
-        th.path || ' > ' || t.name
-    FROM tasks t
-    INNER JOIN task_hierarchy th ON t.parent_task_id = th.id
-    WHERE t.archived = false
-)
-SELECT 
-    REPEAT('  ', level) || name as indented_name,
-    total_minutes,
-    get_task_recursive_estimation(id) as recursive_estimation
-FROM task_hierarchy
-ORDER BY path; 

worklenz-backend/grunt/grunt-compress.js

@@ -1,28 +0,0 @@
-module.exports = {
-  brotli_js: {
-    options: {
-      mode: "brotli",
-      brotli: {
-        mode: 1
-      }
-    },
-    expand: true,
-    cwd: "build/public",
-    src: ["**/*.js"],
-    dest: "build/public",
-    extDot: "last",
-    ext: ".js.br"
-  },
-  gzip_js: {
-    options: {
-      mode: "gzip"
-    },
-    files: [{
-      expand: true,
-      cwd: "build/public",
-      src: ["**/*.js"],
-      dest: "build/public",
-      ext: ".js.gz"
-    }]
-  }
-};

worklenz-backend/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "engines": {
     "npm": ">=8.11.0",
-    "node": ">=16.13.0",
+    "node": ">=20.0.0",
     "yarn": "WARNING: Please use npm package manager instead of yarn"
   },
   "main": "build/bin/www",
@@ -42,9 +42,6 @@
     "reportFile": "test-reporter.xml",
     "indent": 4
   },
-  "overrides": {
-    "rimraf": "^6.0.1"
-  },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.378.0",
     "@aws-sdk/client-ses": "^3.378.0",
@@ -88,7 +85,6 @@
     "passport-local": "^1.0.0",
     "path": "^0.12.7",
     "pg": "^8.14.1",
-    "pg-native": "^3.3.0",
     "pug": "^3.0.2",
     "redis": "^4.6.7",
     "sanitize-html": "^2.11.0",
@@ -96,8 +92,10 @@
     "sharp": "^0.32.6",
     "slugify": "^1.6.6",
     "socket.io": "^4.7.1",
+    "tinymce": "^7.8.0",
     "uglify-js": "^3.17.4",
     "winston": "^3.10.0",
+    "worklenz-backend": "file:",
     "xss-filters": "^1.2.7"
   },
   "devDependencies": {
@@ -105,15 +103,17 @@
     "@babel/preset-typescript": "^7.22.5",
     "@types/bcrypt": "^5.0.0",
     "@types/bluebird": "^3.5.38",
+    "@types/body-parser": "^1.19.2",
     "@types/compression": "^1.7.2",
     "@types/connect-flash": "^0.0.37",
     "@types/cookie-parser": "^1.4.3",
     "@types/cron": "^2.0.1",
     "@types/crypto-js": "^4.2.2",
     "@types/csurf": "^1.11.2",
-    "@types/express": "^4.17.17",
+    "@types/express": "^4.17.21",
     "@types/express-brute": "^1.0.2",
     "@types/express-brute-redis": "^0.0.4",
+    "@types/express-serve-static-core": "^4.17.34",
     "@types/express-session": "^1.17.7",
     "@types/fs-extra": "^9.0.13",
     "@types/hpp": "^0.2.2",

worklenz-backend/reset-existing-parent-estimations.sql

@@ -1,29 +0,0 @@
--- Reset all existing parent task estimations to 0
--- This script updates all tasks that have subtasks to have 0 estimation
-
-UPDATE tasks 
-SET total_minutes = 0
-WHERE id IN (
-    SELECT DISTINCT parent_task_id 
-    FROM tasks 
-    WHERE parent_task_id IS NOT NULL 
-    AND archived = false
-)
-AND total_minutes > 0
-AND archived = false;
-
--- Show the results
-SELECT 
-    t.id,
-    t.name,
-    t.total_minutes as current_estimation,
-    (SELECT COUNT(*) FROM tasks WHERE parent_task_id = t.id AND archived = false) as subtask_count
-FROM tasks t
-WHERE id IN (
-    SELECT DISTINCT parent_task_id 
-    FROM tasks 
-    WHERE parent_task_id IS NOT NULL 
-    AND archived = false
-)
-AND archived = false
-ORDER BY t.name; 

worklenz-backend/src/controllers/auth-controller.ts

@@ -31,7 +31,6 @@ export default class AuthController extends WorklenzControllerBase {
     // Flash messages sent from passport-local-signup.ts and passport-local-login.ts
     const errors = req.flash()["error"] || [];
     const messages = req.flash()["success"] || [];
-    
     // If there are multiple messages, we will send one at a time.
     const auth_error = errors.length > 0 ? errors[0] : null;
     const message = messages.length > 0 ? messages[0] : null;

worklenz-backend/src/controllers/home-page-controller.ts

@@ -137,6 +137,10 @@ export default class HomePageController extends WorklenzControllerBase {
                                 WHERE category_id NOT IN (SELECT id
                                                           FROM sys_task_status_categories
                                                           WHERE is_done IS FALSE))
+        AND NOT EXISTS(SELECT project_id
+                       FROM archived_projects
+                       WHERE project_id = p.id
+                         AND user_id = $2)
         ${groupByClosure}
       ORDER BY t.end_date ASC`;
 
@@ -158,9 +162,13 @@ export default class HomePageController extends WorklenzControllerBase {
                                          WHERE category_id NOT IN (SELECT id
                                                                    FROM sys_task_status_categories
                                                                    WHERE is_done IS FALSE))
+                 AND NOT EXISTS(SELECT project_id
+                                FROM archived_projects
+                                WHERE project_id = p.id
+                                  AND user_id = $3)
                  ${groupByClosure}`;
 
-    const result = await db.query(q, [teamId, userId]);
+    const result = await db.query(q, [teamId, userId, userId]);
     const [row] = result.rows;
     return row;
   }

worklenz-backend/src/controllers/project-ratecard-controller.ts

@@ -1,262 +0,0 @@
-import db from "../config/db";
-import { IWorkLenzRequest } from "../interfaces/worklenz-request";
-import { IWorkLenzResponse } from "../interfaces/worklenz-response";
-import { ServerResponse } from "../models/server-response";
-import HandleExceptions from "../decorators/handle-exceptions";
-import WorklenzControllerBase from "./worklenz-controller-base";
-
-export default class ProjectRateCardController extends WorklenzControllerBase {
-
-  // Insert a single role for a project
-  @HandleExceptions()
-  public static async createOne(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const { project_id, job_title_id, rate } = req.body;
-    if (!project_id || !job_title_id || typeof rate !== "number") {
-      return res.status(400).send(new ServerResponse(false, null, "Invalid input"));
-    }
-    const q = `
-    INSERT INTO finance_project_rate_card_roles (project_id, job_title_id, rate)
-    VALUES ($1, $2, $3)
-    ON CONFLICT (project_id, job_title_id) DO UPDATE SET rate = EXCLUDED.rate
-    RETURNING *,
-      (SELECT name FROM job_titles jt WHERE jt.id = finance_project_rate_card_roles.job_title_id) AS jobtitle;
-  `;
-    const result = await db.query(q, [project_id, job_title_id, rate]);
-    return res.status(200).send(new ServerResponse(true, result.rows[0]));
-  }
-  // Insert multiple roles for a project
-  @HandleExceptions()
-  public static async createMany(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const { project_id, roles } = req.body;
-    if (!Array.isArray(roles) || !project_id) {
-      return res.status(400).send(new ServerResponse(false, null, "Invalid input"));
-    }
-    const values = roles.map((role: any) => [
-      project_id,
-      role.job_title_id,
-      role.rate
-    ]);
-    const q = `
-      INSERT INTO finance_project_rate_card_roles (project_id, job_title_id, rate)
-      VALUES ${values.map((_, i) => `($${i * 3 + 1}, $${i * 3 + 2}, $${i * 3 + 3})`).join(",")}
-      ON CONFLICT (project_id, job_title_id) DO UPDATE SET rate = EXCLUDED.rate
-      RETURNING *,
-      (SELECT name FROM job_titles jt WHERE jt.id = finance_project_rate_card_roles.job_title_id) AS Jobtitle;
-    `;
-    const flatValues = values.flat();
-    const result = await db.query(q, flatValues);
-    return res.status(200).send(new ServerResponse(true, result.rows));
-  }
-
-  // Get all roles for a project
-  @HandleExceptions()
-  public static async getByProjectId(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const { project_id } = req.params;
-    const q = `
-      SELECT
-      fprr.*,
-      jt.name as jobtitle,
-      (
-      SELECT COALESCE(json_agg(pm.id), '[]'::json)
-      FROM project_members pm
-      WHERE pm.project_rate_card_role_id = fprr.id
-      ) AS members
-      FROM finance_project_rate_card_roles fprr
-      LEFT JOIN job_titles jt ON fprr.job_title_id = jt.id
-      WHERE fprr.project_id = $1
-      ORDER BY fprr.created_at;
-    `;
-    const result = await db.query(q, [project_id]);
-    return res.status(200).send(new ServerResponse(true, result.rows));
-  }
-
-  // Get a single role by id
-  @HandleExceptions()
-  public static async getById(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const { id } = req.params;
-    const q = `
-      SELECT
-      fprr.*,
-      jt.name as jobtitle,
-      (
-        SELECT COALESCE(json_agg(pm.id), '[]'::json)
-        FROM project_members pm
-        WHERE pm.project_rate_card_role_id = fprr.id
-      ) AS members
-      FROM finance_project_rate_card_roles fprr
-      LEFT JOIN job_titles jt ON fprr.job_title_id = jt.id
-      WHERE fprr.id = $1;
-    `;
-    const result = await db.query(q, [id]);
-    return res.status(200).send(new ServerResponse(true, result.rows[0]));
-  }
-
-  // Update a single role by id
-  @HandleExceptions()
-  public static async updateById(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const { id } = req.params;
-    const { job_title_id, rate } = req.body;
-    const q = `
-      WITH updated AS (
-      UPDATE finance_project_rate_card_roles
-      SET job_title_id = $1, rate = $2, updated_at = NOW()
-      WHERE id = $3
-      RETURNING *
-      ),
-      jobtitles AS (
-      SELECT u.*, jt.name AS jobtitle
-      FROM updated u
-      JOIN job_titles jt ON jt.id = u.job_title_id
-      ),
-      members AS (
-      SELECT json_agg(pm.id) AS members, pm.project_rate_card_role_id
-      FROM project_members pm
-      WHERE pm.project_rate_card_role_id IN (SELECT id FROM jobtitles)
-      GROUP BY pm.project_rate_card_role_id
-      )
-      SELECT jt.*, m.members
-      FROM jobtitles jt
-      LEFT JOIN members m ON m.project_rate_card_role_id = jt.id;
-    `;
-    const result = await db.query(q, [job_title_id, rate, id]);
-    return res.status(200).send(new ServerResponse(true, result.rows[0]));
-  }
-
-  // update project member rate for a project with members
-  @HandleExceptions()
-  public static async updateProjectMemberByProjectIdAndMemberId(
-    req: IWorkLenzRequest,
-    res: IWorkLenzResponse
-  ): Promise<IWorkLenzResponse> {
-    const { project_id, id } = req.params;
-    const { project_rate_card_role_id } = req.body;
-
-    if (!project_id || !id || !project_rate_card_role_id) {
-      return res.status(400).send(new ServerResponse(false, null, "Missing values"));
-    }
-
-    try {
-      // Step 1: Check current role assignment
-      const checkQuery = `
-        SELECT project_rate_card_role_id
-        FROM project_members
-        WHERE id = $1 AND project_id = $2;
-        `;
-      const { rows: checkRows } = await db.query(checkQuery, [id, project_id]);
-
-      const currentRoleId = checkRows[0]?.project_rate_card_role_id;
-
-      if (currentRoleId !== null && currentRoleId !== project_rate_card_role_id) {
-        // Step 2: Fetch members with the requested role
-        const membersQuery = `
-            SELECT COALESCE(json_agg(id), '[]'::json) AS members
-            FROM project_members
-            WHERE project_id = $1 AND project_rate_card_role_id = $2;
-            `;
-        const { rows: memberRows } = await db.query(membersQuery, [project_id, project_rate_card_role_id]);
-
-        return res.status(200).send(
-          new ServerResponse(false, memberRows[0], "Already Assigned !")
-        );
-      }
-
-      // Step 3: Perform the update
-      const updateQuery = `
-          UPDATE project_members
-          SET project_rate_card_role_id = CASE
-          WHEN project_rate_card_role_id = $1 THEN NULL
-          ELSE $1
-          END
-          WHERE id = $2
-          AND project_id = $3
-          AND EXISTS (
-          SELECT 1
-          FROM finance_project_rate_card_roles
-          WHERE id = $1 AND project_id = $3
-          )
-          RETURNING project_rate_card_role_id;
-          `;
-      const { rows: updateRows } = await db.query(updateQuery, [project_rate_card_role_id, id, project_id]);
-
-      if (updateRows.length === 0) {
-        return res.status(200).send(new ServerResponse(true, [], "Project member not found or invalid project_rate_card_role_id"));
-      }
-
-      const updatedRoleId = updateRows[0].project_rate_card_role_id || project_rate_card_role_id;
-
-      // Step 4: Fetch updated members list
-      const membersQuery = `
-        SELECT COALESCE(json_agg(id), '[]'::json) AS members
-        FROM project_members
-        WHERE project_id = $1 AND project_rate_card_role_id = $2;
-        `;
-      const { rows: finalMembers } = await db.query(membersQuery, [project_id, updatedRoleId]);
-
-      return res.status(200).send(new ServerResponse(true, finalMembers[0]));
-    } catch (error) {
-      return res.status(500).send(new ServerResponse(false, null, "Internal server error"));
-    }
-  }
-  // Update all roles for a project (delete then insert)
-  @HandleExceptions()
-  public static async updateByProjectId(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const { project_id, roles } = req.body;
-    if (!Array.isArray(roles) || !project_id) {
-      return res.status(400).send(new ServerResponse(false, null, "Invalid input"));
-    }
-    if (roles.length === 0) {
-      // If no roles provided, do nothing and return empty array
-      return res.status(200).send(new ServerResponse(true, []));
-    }
-    // Build upsert query for all roles
-    const values = roles.map((role: any) => [
-      project_id,
-      role.job_title_id,
-      role.rate
-    ]);
-    const q = `
-        WITH upserted AS (
-        INSERT INTO finance_project_rate_card_roles (project_id, job_title_id, rate)
-        VALUES ${values.map((_, i) => `($${i * 3 + 1}, $${i * 3 + 2}, $${i * 3 + 3})`).join(",")}
-        ON CONFLICT (project_id, job_title_id)
-        DO UPDATE SET rate = EXCLUDED.rate, updated_at = NOW()
-        RETURNING *
-        ),
-        jobtitles AS (
-        SELECT upr.*, jt.name AS jobtitle
-        FROM upserted upr
-        JOIN job_titles jt ON jt.id = upr.job_title_id
-        ),
-        members AS (
-        SELECT json_agg(pm.id) AS members, pm.project_rate_card_role_id
-        FROM project_members pm
-        WHERE pm.project_rate_card_role_id IN (SELECT id FROM jobtitles)
-        GROUP BY pm.project_rate_card_role_id
-        )
-        SELECT jt.*, m.members
-        FROM jobtitles jt
-        LEFT JOIN members m ON m.project_rate_card_role_id = jt.id;
-    `;
-    const flatValues = values.flat();
-    const result = await db.query(q, flatValues);
-    return res.status(200).send(new ServerResponse(true, result.rows));
-  }
-
-  // Delete a single role by id
-  @HandleExceptions()
-  public static async deleteById(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const { id } = req.params;
-    const q = `DELETE FROM finance_project_rate_card_roles WHERE id = $1 RETURNING *;`;
-    const result = await db.query(q, [id]);
-    return res.status(200).send(new ServerResponse(true, result.rows[0]));
-  }
-
-  // Delete all roles for a project
-  @HandleExceptions()
-  public static async deleteByProjectId(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const { project_id } = req.params;
-    const q = `DELETE FROM finance_project_rate_card_roles WHERE project_id = $1 RETURNING *;`;
-    const result = await db.query(q, [project_id]);
-    return res.status(200).send(new ServerResponse(true, result.rows));
-  }
-}

worklenz-backend/src/controllers/projects-controller.ts

@@ -71,7 +71,7 @@ export default class ProjectsController extends WorklenzControllerBase {
         return res.status(200).send(new ServerResponse(false, [], `Sorry, the free plan cannot have more than ${projectsLimit} projects.`));
       }
     }
-    
+
     const q = `SELECT create_project($1) AS project`;
 
     req.body.team_id = req.user?.team_id || null;
@@ -317,65 +317,58 @@ export default class ProjectsController extends WorklenzControllerBase {
   @HandleExceptions()
   public static async getMembersByProjectId(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
     const {sortField, sortOrder, size, offset} = this.toPaginationOptions(req.query, "name");
+    const search = (req.query.search || "").toString().trim();
+
+    let searchFilter = "";
+    const params = [req.params.id, req.user?.team_id ?? null, size, offset];
+    if (search) {
+      searchFilter = `
+        AND (
+          (SELECT name FROM team_member_info_view WHERE team_member_info_view.team_member_id = tm.id) ILIKE '%' || $5 || '%'
+          OR (SELECT email FROM team_member_info_view WHERE team_member_info_view.team_member_id = tm.id) ILIKE '%' || $5 || '%'
+        )
+      `;
+      params.push(search);
+    }
 
     const q = `
-      SELECT ROW_TO_JSON(rec) AS members
-      FROM (SELECT COUNT(*) AS total,
-                   (SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(t))), '[]'::JSON)
-                    FROM (SELECT project_members.id,
-                                 team_member_id,
-                                 (SELECT name
-                                  FROM team_member_info_view
-                                  WHERE team_member_info_view.team_member_id = tm.id),
-                                 (SELECT email
-                                  FROM team_member_info_view
-                                  WHERE team_member_info_view.team_member_id = tm.id) AS email,
-                                 u.avatar_url,
-                                 (SELECT COUNT(*)
-                                  FROM tasks
-                                  WHERE archived IS FALSE
-                                    AND project_id = project_members.project_id
-                                    AND id IN (SELECT task_id
-                                               FROM tasks_assignees
-                                               WHERE tasks_assignees.project_member_id = project_members.id)) AS all_tasks_count,
-                                 (SELECT COUNT(*)
-                                  FROM tasks
-                                  WHERE archived IS FALSE
-                                    AND project_id = project_members.project_id
-                                    AND id IN (SELECT task_id
-                                               FROM tasks_assignees
-                                               WHERE tasks_assignees.project_member_id = project_members.id)
-                                    AND status_id IN (SELECT id
-                                                      FROM task_statuses
-                                                      WHERE category_id = (SELECT id
-                                                                           FROM sys_task_status_categories
-                                                                           WHERE is_done IS TRUE))) AS completed_tasks_count,
-                                 EXISTS(SELECT email
-                                        FROM email_invitations
-                                        WHERE team_member_id = project_members.team_member_id
-                                          AND email_invitations.team_id = $2) AS pending_invitation,
-                                 (SELECT project_access_levels.name
-                                  FROM project_access_levels
-                                  WHERE project_access_levels.id = project_members.project_access_level_id) AS access,
-                                 (SELECT name FROM job_titles WHERE id = tm.job_title_id) AS job_title
-                          FROM project_members
-                                 INNER JOIN team_members tm ON project_members.team_member_id = tm.id
-                                 LEFT JOIN users u ON tm.user_id = u.id
-                          WHERE project_id = $1
-                          ORDER BY ${sortField} ${sortOrder}
-                          LIMIT $3 OFFSET $4) t) AS data
-            FROM project_members
-            WHERE project_id = $1) rec;
+      WITH filtered_members AS (
+        SELECT project_members.id,
+               team_member_id,
+               (SELECT name FROM team_member_info_view WHERE team_member_info_view.team_member_id = tm.id) AS name,
+               (SELECT email FROM team_member_info_view WHERE team_member_info_view.team_member_id = tm.id) AS email,
+               u.avatar_url,
+               (SELECT COUNT(*) FROM tasks WHERE archived IS FALSE AND project_id = project_members.project_id AND id IN (SELECT task_id FROM tasks_assignees WHERE tasks_assignees.project_member_id = project_members.id)) AS all_tasks_count,
+               (SELECT COUNT(*) FROM tasks WHERE archived IS FALSE AND project_id = project_members.project_id AND id IN (SELECT task_id FROM tasks_assignees WHERE tasks_assignees.project_member_id = project_members.id) AND status_id IN (SELECT id FROM task_statuses WHERE category_id = (SELECT id FROM sys_task_status_categories WHERE is_done IS TRUE))) AS completed_tasks_count,
+               EXISTS(SELECT email FROM email_invitations WHERE team_member_id = project_members.team_member_id AND email_invitations.team_id = $2) AS pending_invitation,
+               (SELECT project_access_levels.name FROM project_access_levels WHERE project_access_levels.id = project_members.project_access_level_id) AS access,
+               (SELECT name FROM job_titles WHERE id = tm.job_title_id) AS job_title
+        FROM project_members
+        INNER JOIN team_members tm ON project_members.team_member_id = tm.id
+        LEFT JOIN users u ON tm.user_id = u.id
+        WHERE project_id = $1
+        ${search ? searchFilter : ""}
+      )
+      SELECT
+        (SELECT COUNT(*) FROM filtered_members) AS total,
+        (SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(t))), '[]'::JSON)
+           FROM (
+             SELECT * FROM filtered_members
+             ORDER BY ${sortField} ${sortOrder}
+             LIMIT $3 OFFSET $4
+           ) t
+        ) AS data
     `;
-    const result = await db.query(q, [req.params.id, req.user?.team_id ?? null, size, offset]);
+
+    const result = await db.query(q, params);
     const [data] = result.rows;
 
-    for (const member of data?.members.data || []) {
+    for (const member of data?.data || []) {
       member.progress = member.all_tasks_count > 0
         ? ((member.completed_tasks_count / member.all_tasks_count) * 100).toFixed(0) : 0;
     }
 
-    return res.status(200).send(new ServerResponse(true, data?.members || this.paginatedDatasetDefaultStruct));
+    return res.status(200).send(new ServerResponse(true, data || this.paginatedDatasetDefaultStruct));
   }
 
   @HandleExceptions()
@@ -395,7 +388,6 @@ export default class ProjectsController extends WorklenzControllerBase {
              projects.folder_id,
              projects.phase_label,
              projects.category_id,
-             projects.currency,
              (projects.estimated_man_days) AS man_days,
              (projects.estimated_working_days) AS working_days,
              (projects.hours_per_day) AS hours_per_day,
@@ -757,4 +749,186 @@ export default class ProjectsController extends WorklenzControllerBase {
 
   }
 
+  @HandleExceptions()
+  public static async getGrouped(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    // Use qualified field name for projects to avoid ambiguity
+    const {searchQuery, sortField, sortOrder, size, offset} = this.toPaginationOptions(req.query, ["projects.name"]);
+    const groupBy = req.query.groupBy as string || "category";
+
+    const filterByMember = !req.user?.owner && !req.user?.is_admin ?
+      ` AND is_member_of_project(projects.id, '${req.user?.id}', $1) ` : "";
+
+    const isFavorites = req.query.filter === "1" ? ` AND EXISTS(SELECT user_id FROM favorite_projects WHERE user_id = '${req.user?.id}' AND project_id = projects.id)` : "";
+    const isArchived = req.query.filter === "2"
+      ? ` AND EXISTS(SELECT user_id FROM archived_projects WHERE user_id = '${req.user?.id}' AND project_id = projects.id)`
+      : ` AND NOT EXISTS(SELECT user_id FROM archived_projects WHERE user_id = '${req.user?.id}' AND project_id = projects.id)`;
+    const categories = this.getFilterByCategoryWhereClosure(req.query.categories as string);
+    const statuses = this.getFilterByStatusWhereClosure(req.query.statuses as string);
+
+    // Determine grouping field and join based on groupBy parameter
+    let groupField = "";
+    let groupName = "";
+    let groupColor = "";
+    let groupJoin = "";
+    let groupByFields = "";
+    let groupOrderBy = "";
+
+    switch (groupBy) {
+      case "client":
+        groupField = "COALESCE(projects.client_id::text, 'no-client')";
+        groupName = "COALESCE(clients.name, 'No Client')";
+        groupColor = "'#688'";
+        groupJoin = "LEFT JOIN clients ON projects.client_id = clients.id";
+        groupByFields = "projects.client_id, clients.name";
+        groupOrderBy = "COALESCE(clients.name, 'No Client')";
+        break;
+      case "status":
+        groupField = "COALESCE(projects.status_id::text, 'no-status')";
+        groupName = "COALESCE(sys_project_statuses.name, 'No Status')";
+        groupColor = "COALESCE(sys_project_statuses.color_code, '#888')";
+        groupJoin = "LEFT JOIN sys_project_statuses ON projects.status_id = sys_project_statuses.id";
+        groupByFields = "projects.status_id, sys_project_statuses.name, sys_project_statuses.color_code";
+        groupOrderBy = "COALESCE(sys_project_statuses.name, 'No Status')";
+        break;
+      case "category":
+      default:
+        groupField = "COALESCE(projects.category_id::text, 'uncategorized')";
+        groupName = "COALESCE(project_categories.name, 'Uncategorized')";
+        groupColor = "COALESCE(project_categories.color_code, '#888')";
+        groupJoin = "LEFT JOIN project_categories ON projects.category_id = project_categories.id";
+        groupByFields = "projects.category_id, project_categories.name, project_categories.color_code";
+        groupOrderBy = "COALESCE(project_categories.name, 'Uncategorized')";
+    }
+
+    // Ensure sortField is properly qualified for the inner project query
+    let qualifiedSortField = sortField;
+    if (Array.isArray(sortField)) {
+      qualifiedSortField = sortField[0]; // Take the first field if it's an array
+    }
+    // Replace "projects." with "p2." for the inner query
+    const innerSortField = qualifiedSortField.replace("projects.", "p2.");
+
+    const q = `
+      SELECT ROW_TO_JSON(rec) AS groups
+      FROM (
+        SELECT COUNT(DISTINCT ${groupField}) AS total_groups,
+               (SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(group_data))), '[]'::JSON)
+                FROM (
+                  SELECT ${groupField} AS group_key,
+                         ${groupName} AS group_name,
+                         ${groupColor} AS group_color,
+                         COUNT(*) AS project_count,
+                         (SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(project_data))), '[]'::JSON)
+                          FROM (
+                            SELECT p2.id,
+                                   p2.name,
+                                   (SELECT sys_project_statuses.name FROM sys_project_statuses WHERE sys_project_statuses.id = p2.status_id) AS status,
+                                   (SELECT sys_project_statuses.color_code FROM sys_project_statuses WHERE sys_project_statuses.id = p2.status_id) AS status_color,
+                                   (SELECT sys_project_statuses.icon FROM sys_project_statuses WHERE sys_project_statuses.id = p2.status_id) AS status_icon,
+                                   EXISTS(SELECT user_id
+                                          FROM favorite_projects
+                                          WHERE user_id = '${req.user?.id}'
+                                            AND project_id = p2.id) AS favorite,
+                                   EXISTS(SELECT user_id
+                                          FROM archived_projects
+                                          WHERE user_id = '${req.user?.id}'
+                                            AND project_id = p2.id) AS archived,
+                                   p2.color_code,
+                                   p2.start_date,
+                                   p2.end_date,
+                                   p2.category_id,
+                                   (SELECT COUNT(*)
+                                    FROM tasks
+                                    WHERE archived IS FALSE
+                                      AND project_id = p2.id) AS all_tasks_count,
+                                   (SELECT COUNT(*)
+                                    FROM tasks
+                                    WHERE archived IS FALSE
+                                      AND project_id = p2.id
+                                      AND status_id IN (SELECT task_statuses.id
+                                                        FROM task_statuses
+                                                        WHERE task_statuses.project_id = p2.id
+                                                          AND task_statuses.category_id IN
+                                                              (SELECT sys_task_status_categories.id FROM sys_task_status_categories WHERE sys_task_status_categories.is_done IS TRUE))) AS completed_tasks_count,
+                                   (SELECT COUNT(*)
+                                    FROM project_members
+                                    WHERE project_members.project_id = p2.id) AS members_count,
+                                   (SELECT get_project_members(p2.id)) AS names,
+                                   (SELECT clients.name FROM clients WHERE clients.id = p2.client_id) AS client_name,
+                                   (SELECT users.name FROM users WHERE users.id = p2.owner_id) AS project_owner,
+                                   (SELECT project_categories.name FROM project_categories WHERE project_categories.id = p2.category_id) AS category_name,
+                                   (SELECT project_categories.color_code
+                                    FROM project_categories
+                                    WHERE project_categories.id = p2.category_id) AS category_color,
+                                   ((SELECT project_members.team_member_id as team_member_id
+                                      FROM project_members
+                                      WHERE project_members.project_id = p2.id
+                                        AND project_members.project_access_level_id = (SELECT project_access_levels.id FROM project_access_levels WHERE project_access_levels.key = 'PROJECT_MANAGER'))) AS project_manager_team_member_id,
+                                   (SELECT project_members.default_view
+                                      FROM project_members
+                                      WHERE project_members.project_id = p2.id
+                                        AND project_members.team_member_id = '${req.user?.team_member_id}') AS team_member_default_view,
+                                   (SELECT CASE
+                                             WHEN ((SELECT MAX(tasks.updated_at)
+                                                    FROM tasks
+                                                    WHERE tasks.archived IS FALSE
+                                                      AND tasks.project_id = p2.id) >
+                                                   p2.updated_at)
+                                               THEN (SELECT MAX(tasks.updated_at)
+                                                     FROM tasks
+                                                     WHERE tasks.archived IS FALSE
+                                                       AND tasks.project_id = p2.id)
+                                             ELSE p2.updated_at END) AS updated_at
+                            FROM projects p2
+                            ${groupJoin.replace("projects.", "p2.")}
+                            WHERE p2.team_id = $1
+                              AND ${groupField.replace("projects.", "p2.")} = ${groupField}
+                              ${categories.replace("projects.", "p2.")}
+                              ${statuses.replace("projects.", "p2.")}
+                              ${isArchived.replace("projects.", "p2.")}
+                              ${isFavorites.replace("projects.", "p2.")}
+                              ${filterByMember.replace("projects.", "p2.")}
+                              ${searchQuery.replace("projects.", "p2.")}
+                            ORDER BY ${innerSortField} ${sortOrder}
+                          ) project_data
+                         ) AS projects
+                  FROM projects
+                  ${groupJoin}
+                  WHERE projects.team_id = $1 ${categories} ${statuses} ${isArchived} ${isFavorites} ${filterByMember} ${searchQuery}
+                  GROUP BY ${groupByFields}
+                  ORDER BY ${groupOrderBy}
+                  LIMIT $2 OFFSET $3
+                ) group_data
+               ) AS data
+        FROM projects
+        ${groupJoin}
+        WHERE projects.team_id = $1 ${categories} ${statuses} ${isArchived} ${isFavorites} ${filterByMember} ${searchQuery}
+      ) rec;
+    `;
+
+    const result = await db.query(q, [req.user?.team_id || null, size, offset]);
+    const [data] = result.rows;
+
+    // Process the grouped data
+    for (const group of data?.groups.data || []) {
+      for (const project of group.projects || []) {
+        project.progress = project.all_tasks_count > 0
+          ? ((project.completed_tasks_count / project.all_tasks_count) * 100).toFixed(0) : 0;
+
+        project.updated_at_string = moment(project.updated_at).fromNow();
+
+        project.names = this.createTagList(project?.names);
+        project.names.map((a: any) => a.color_code = getColor(a.name));
+
+        if (project.project_manager_team_member_id) {
+          project.project_manager = {
+            id: project.project_manager_team_member_id
+          };
+        }
+      }
+    }
+
+    return res.status(200).send(new ServerResponse(true, data?.groups || { total_groups: 0, data: [] }));
+  }
+
 }

worklenz-backend/src/controllers/ratecard-controller.ts

@@ -1,157 +0,0 @@
-import { IWorkLenzRequest } from "../interfaces/worklenz-request";
-import { IWorkLenzResponse } from "../interfaces/worklenz-response";
-import db from "../config/db";
-import { ServerResponse } from "../models/server-response";
-import WorklenzControllerBase from "./worklenz-controller-base";
-import HandleExceptions from "../decorators/handle-exceptions";
-
-export default class RateCardController extends WorklenzControllerBase {
-  @HandleExceptions()
-  public static async create(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const q = `
-      INSERT INTO finance_rate_cards (team_id, name)
-      VALUES ($1, $2)
-      RETURNING id, name, team_id, created_at, updated_at;
-    `;
-    const result = await db.query(q, [req.user?.team_id || null, req.body.name]);
-    const [data] = result.rows;
-    return res.status(200).send(new ServerResponse(true, data));
-  }
-
-  @HandleExceptions()
-  public static async get(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const { searchQuery, sortField, sortOrder, size, offset } = this.toPaginationOptions(req.query, "name");
-
-    const q = `
-    SELECT ROW_TO_JSON(rec) AS rate_cards
-    FROM (
-      SELECT COUNT(*) AS total,
-        (
-          SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(t))), '[]'::JSON)
-          FROM (
-            SELECT id, name, team_id, currency, created_at, updated_at
-            FROM finance_rate_cards
-            WHERE team_id = $1 ${searchQuery}
-            ORDER BY ${sortField} ${sortOrder}
-            LIMIT $2 OFFSET $3
-          ) t
-        ) AS data
-      FROM finance_rate_cards
-      WHERE team_id = $1 ${searchQuery}
-    ) rec;
-  `;
-    const result = await db.query(q, [req.user?.team_id || null, size, offset]);
-    const [data] = result.rows;
-
-    return res.status(200).send(new ServerResponse(true, data.rate_cards || this.paginatedDatasetDefaultStruct));
-  }
-
-  @HandleExceptions()
-  public static async getById(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    // 1. Fetch the rate card
-    const q = `
-    SELECT id, name, team_id, currency, created_at, updated_at
-    FROM finance_rate_cards
-    WHERE id = $1 AND team_id = $2;
-  `;
-    const result = await db.query(q, [req.params.id, req.user?.team_id || null]);
-    const [data] = result.rows;
-
-    if (!data) {
-      return res.status(404).send(new ServerResponse(false, null, "Rate card not found"));
-    }
-
-    // 2. Fetch job roles with job title names
-    const jobRolesQ = `
-    SELECT
-      rcr.job_title_id,
-      jt.name AS jobTitle,
-      rcr.rate,
-      rcr.rate_card_id
-    FROM finance_rate_card_roles rcr
-    LEFT JOIN job_titles jt ON rcr.job_title_id = jt.id
-    WHERE rcr.rate_card_id = $1
-  `;
-    const jobRolesResult = await db.query(jobRolesQ, [req.params.id]);
-    const jobRolesList = jobRolesResult.rows;
-
-    // 3. Return the rate card with jobRolesList
-    return res.status(200).send(
-      new ServerResponse(true, {
-        ...data,
-        jobRolesList,
-      })
-    );
-  }
-
-  @HandleExceptions()
-  public static async update(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    // 1. Update the rate card
-    const updateRateCardQ = `
-    UPDATE finance_rate_cards
-    SET name = $3, currency = $4, updated_at = NOW()
-    WHERE id = $1 AND team_id = $2
-    RETURNING id, name, team_id, currency, created_at, updated_at;
-  `;
-    const result = await db.query(updateRateCardQ, [
-      req.params.id,
-      req.user?.team_id || null,
-      req.body.name,
-      req.body.currency,
-    ]);
-    const [rateCardData] = result.rows;
-
-    // 2. Update job roles (delete old, insert new)
-    if (Array.isArray(req.body.jobRolesList)) {
-      // Delete existing roles for this rate card
-      await db.query(
-        `DELETE FROM finance_rate_card_roles WHERE rate_card_id = $1;`,
-        [req.params.id]
-      );
-
-      // Insert new roles
-      for (const role of req.body.jobRolesList) {
-        if (role.job_title_id) {
-          await db.query(
-            `INSERT INTO finance_rate_card_roles (rate_card_id, job_title_id, rate)
-           VALUES ($1, $2, $3);`,
-            [req.params.id, role.job_title_id, role.rate ?? 0]
-          );
-        }
-      }
-    }
-
-    // 3. Get jobRolesList with job title names
-    const jobRolesQ = `
-    SELECT
-      rcr.job_title_id,
-      jt.name AS jobTitle,
-      rcr.rate
-    FROM finance_rate_card_roles rcr
-    LEFT JOIN job_titles jt ON rcr.job_title_id = jt.id
-    WHERE rcr.rate_card_id = $1
-  `;
-    const jobRolesResult = await db.query(jobRolesQ, [req.params.id]);
-    const jobRolesList = jobRolesResult.rows;
-
-    // 4. Return the updated rate card with jobRolesList
-    return res.status(200).send(
-      new ServerResponse(true, {
-        ...rateCardData,
-        jobRolesList,
-      })
-    );
-  }
-
-  @HandleExceptions()
-  public static async deleteById(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const q = `
-      DELETE FROM finance_rate_cards
-      WHERE id = $1 AND team_id = $2
-      RETURNING id;
-    `;
-    const result = await db.query(q, [req.params.id, req.user?.team_id || null]);
-    return res.status(200).send(new ServerResponse(true, result.rows.length > 0));
-  }
-}
-

worklenz-backend/src/controllers/reporting-controller.ts

@@ -415,20 +415,15 @@ export default class ReportingController extends WorklenzControllerBase {
 
   @HandleExceptions()
   public static async getMyTeams(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const selectedTeamId = req.user?.team_id;
-    if (!selectedTeamId) {
-      return res.status(400).send(new ServerResponse(false, "No selected team"));
-    }
     const q = `SELECT team_id AS id, name
                FROM team_members tm
                       LEFT JOIN teams ON teams.id = tm.team_id
                WHERE tm.user_id = $1
-                 AND tm.team_id = $2
                  AND role_id IN (SELECT id
                                  FROM roles
                                  WHERE (admin_role IS TRUE OR owner IS TRUE))
                ORDER BY name;`;
-    const result = await db.query(q, [req.user?.id, selectedTeamId]);
+    const result = await db.query(q, [req.user?.id]);
     result.rows.forEach((team: any) => team.selected = true);
     return res.status(200).send(new ServerResponse(true, result.rows));
   }

worklenz-backend/src/controllers/reporting/reporting-allocation-controller-updated.ts

@@ -0,0 +1,179 @@
+// Example of updated getMemberTimeSheets method with timezone support
+// This shows the key changes needed to handle timezones properly
+
+import moment from "moment-timezone";
+import db from "../../config/db";
+import { IWorkLenzRequest } from "../../interfaces/worklenz-request";
+import { IWorkLenzResponse } from "../../interfaces/worklenz-response";
+import { ServerResponse } from "../../models/server-response";
+import { DATE_RANGES } from "../../shared/constants";
+
+export async function getMemberTimeSheets(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+  const archived = req.query.archived === "true";
+  const teams = (req.body.teams || []) as string[];
+  const teamIds = teams.map(id => `'${id}'`).join(",");
+  const projects = (req.body.projects || []) as string[];
+  const projectIds = projects.map(p => `'${p}'`).join(",");
+  const {billable} = req.body;
+  
+  // Get user timezone from request or database
+  const userTimezone = req.body.timezone || await getUserTimezone(req.user?.id || "");
+  
+  if (!teamIds || !projectIds.length)
+    return res.status(200).send(new ServerResponse(true, { users: [], projects: [] }));
+    
+  const { duration, date_range } = req.body;
+  
+  // Calculate date range with timezone support
+  let startDate: moment.Moment;
+  let endDate: moment.Moment;
+  
+  if (date_range && date_range.length === 2) {
+    // Convert user's local dates to their timezone's start/end of day
+    startDate = moment.tz(date_range[0], userTimezone).startOf("day");
+    endDate = moment.tz(date_range[1], userTimezone).endOf("day");
+  } else if (duration === DATE_RANGES.ALL_TIME) {
+    const minDateQuery = `SELECT MIN(COALESCE(start_date, created_at)) as min_date FROM projects WHERE id IN (${projectIds})`;
+    const minDateResult = await db.query(minDateQuery, []);
+    const minDate = minDateResult.rows[0]?.min_date;
+    startDate = minDate ? moment.tz(minDate, userTimezone) : moment.tz("2000-01-01", userTimezone);
+    endDate = moment.tz(userTimezone);
+  } else {
+    // Calculate ranges based on user's timezone
+    const now = moment.tz(userTimezone);
+    
+    switch (duration) {
+      case DATE_RANGES.YESTERDAY:
+        startDate = now.clone().subtract(1, "day").startOf("day");
+        endDate = now.clone().subtract(1, "day").endOf("day");
+        break;
+      case DATE_RANGES.LAST_WEEK:
+        startDate = now.clone().subtract(1, "week").startOf("isoWeek");
+        endDate = now.clone().subtract(1, "week").endOf("isoWeek");
+        break;
+      case DATE_RANGES.LAST_MONTH:
+        startDate = now.clone().subtract(1, "month").startOf("month");
+        endDate = now.clone().subtract(1, "month").endOf("month");
+        break;
+      case DATE_RANGES.LAST_QUARTER:
+        startDate = now.clone().subtract(3, "months").startOf("day");
+        endDate = now.clone().endOf("day");
+        break;
+      default:
+        startDate = now.clone().startOf("day");
+        endDate = now.clone().endOf("day");
+    }
+  }
+  
+  // Convert to UTC for database queries
+  const startUtc = startDate.utc().format("YYYY-MM-DD HH:mm:ss");
+  const endUtc = endDate.utc().format("YYYY-MM-DD HH:mm:ss");
+  
+  // Calculate working days in user's timezone
+  const totalDays = endDate.diff(startDate, "days") + 1;
+  let workingDays = 0;
+  
+  const current = startDate.clone();
+  while (current.isSameOrBefore(endDate, "day")) {
+    if (current.isoWeekday() >= 1 && current.isoWeekday() <= 5) {
+      workingDays++;
+    }
+    current.add(1, "day");
+  }
+  
+  // Updated SQL query with proper timezone handling
+  const billableQuery = buildBillableQuery(billable);
+  const archivedClause = archived ? "" : `AND projects.id NOT IN (SELECT project_id FROM archived_projects WHERE project_id = projects.id AND user_id = '${req.user?.id}')`;
+  
+  const q = `
+    WITH project_hours AS (
+      SELECT 
+        id,
+        COALESCE(hours_per_day, 8) as hours_per_day
+      FROM projects
+      WHERE id IN (${projectIds})
+    ),
+    total_working_hours AS (
+      SELECT 
+        SUM(hours_per_day) * ${workingDays} as total_hours
+      FROM project_hours
+    )
+    SELECT 
+      u.id,
+      u.email,
+      tm.name,
+      tm.color_code,
+      COALESCE(SUM(twl.time_spent), 0) as logged_time,
+      COALESCE(SUM(twl.time_spent), 0) / 3600.0 as value,
+      (SELECT total_hours FROM total_working_hours) as total_working_hours,
+      CASE 
+        WHEN (SELECT total_hours FROM total_working_hours) > 0 
+        THEN ROUND((COALESCE(SUM(twl.time_spent), 0) / 3600.0) / (SELECT total_hours FROM total_working_hours) * 100, 2)
+        ELSE 0 
+      END as utilization_percent,
+      ROUND(COALESCE(SUM(twl.time_spent), 0) / 3600.0, 2) as utilized_hours,
+      ROUND(COALESCE(SUM(twl.time_spent), 0) / 3600.0 - (SELECT total_hours FROM total_working_hours), 2) as over_under_utilized_hours,
+      '${userTimezone}' as user_timezone,
+      '${startDate.format("YYYY-MM-DD")}' as report_start_date,
+      '${endDate.format("YYYY-MM-DD")}' as report_end_date
+    FROM team_members tm
+      LEFT JOIN users u ON tm.user_id = u.id
+      LEFT JOIN task_work_log twl ON twl.user_id = u.id
+      LEFT JOIN tasks t ON twl.task_id = t.id ${billableQuery}
+      LEFT JOIN projects p ON t.project_id = p.id
+    WHERE tm.team_id IN (${teamIds})
+      AND (
+        twl.id IS NULL 
+        OR (
+          p.id IN (${projectIds})
+          AND twl.created_at >= '${startUtc}'::TIMESTAMP 
+          AND twl.created_at <= '${endUtc}'::TIMESTAMP
+          ${archivedClause}
+        )
+      )
+    GROUP BY u.id, u.email, tm.name, tm.color_code
+    ORDER BY logged_time DESC`;
+    
+  const result = await db.query(q, []);
+  
+  // Add timezone context to response
+  const response = {
+    data: result.rows,
+    timezone_info: {
+      user_timezone: userTimezone,
+      report_period: {
+        start: startDate.format("YYYY-MM-DD HH:mm:ss z"),
+        end: endDate.format("YYYY-MM-DD HH:mm:ss z"),
+        working_days: workingDays,
+        total_days: totalDays
+      }
+    }
+  };
+  
+  return res.status(200).send(new ServerResponse(true, response));
+}
+
+async function getUserTimezone(userId: string): Promise<string> {
+  const q = `SELECT tz.name as timezone 
+             FROM users u 
+             JOIN timezones tz ON u.timezone_id = tz.id 
+             WHERE u.id = $1`;
+  const result = await db.query(q, [userId]);
+  return result.rows[0]?.timezone || "UTC";
+}
+
+function buildBillableQuery(billable: { billable: boolean; nonBillable: boolean }): string {
+  if (!billable) return "";
+  
+  const { billable: isBillable, nonBillable } = billable;
+  
+  if (isBillable && nonBillable) {
+    return "";
+  } else if (isBillable) {
+    return " AND tasks.billable IS TRUE";
+  } else if (nonBillable) {
+    return " AND tasks.billable IS FALSE";
+  }
+  
+  return "";
+}

worklenz-backend/src/controllers/reporting/reporting-allocation-controller.ts

@@ -15,25 +15,6 @@ enum IToggleOptions {
 }
 
 export default class ReportingAllocationController extends ReportingControllerBase {
-  // Helper method to build billable query with custom table alias
-  private static buildBillableQueryWithAlias(selectedStatuses: { billable: boolean; nonBillable: boolean }, tableAlias: string = 'tasks'): string {
-    const { billable, nonBillable } = selectedStatuses;
-  
-    if (billable && nonBillable) {
-      // Both are enabled, no need to filter
-      return "";
-    } else if (billable && !nonBillable) {
-      // Only billable is enabled - show only billable tasks
-      return ` AND ${tableAlias}.billable IS TRUE`;
-    } else if (!billable && nonBillable) {
-      // Only non-billable is enabled - show only non-billable tasks
-      return ` AND ${tableAlias}.billable IS FALSE`;
-    } else {
-      // Neither selected - this shouldn't happen in normal UI flow
-      return "";
-    }
-  }
-
   private static async getTimeLoggedByProjects(projects: string[], users: string[], key: string, dateRange: string[], archived = false, user_id = "", billable: { billable: boolean; nonBillable: boolean }): Promise<any> {
     try {
       const projectIds = projects.map(p => `'${p}'`).join(",");
@@ -96,8 +77,8 @@ export default class ReportingAllocationController extends ReportingControllerBa
                sps.icon AS status_icon,
                (SELECT COUNT(*)
                 FROM tasks
-                WHERE CASE WHEN ($1 IS TRUE) THEN project_id IS NOT NULL ELSE archived = FALSE END
-                  AND project_id = projects.id ${billableQuery}) AS all_tasks_count,
+                WHERE CASE WHEN ($1 IS TRUE) THEN project_id IS NOT NULL ELSE archived = FALSE END ${billableQuery}
+                  AND project_id = projects.id) AS all_tasks_count,
                (SELECT COUNT(*)
                 FROM tasks
                 WHERE CASE WHEN ($1 IS TRUE) THEN project_id IS NOT NULL ELSE archived = FALSE END
@@ -113,11 +94,10 @@ export default class ReportingAllocationController extends ReportingControllerBa
                         SELECT name,
                                (SELECT COALESCE(SUM(time_spent), 0)
                                 FROM task_work_log
-                                       LEFT JOIN tasks ON task_work_log.task_id = tasks.id
-                                WHERE user_id = users.id
+                                       LEFT JOIN tasks ON task_work_log.task_id = tasks.id 
+                                WHERE user_id = users.id ${billableQuery}
                                   AND CASE WHEN ($1 IS TRUE) THEN tasks.project_id IS NOT NULL ELSE tasks.archived = FALSE END
                                   AND tasks.project_id = projects.id
-                                  ${billableQuery}
                                   ${duration}) AS time_logged
                         FROM users
                         WHERE id IN (${userIds})
@@ -141,11 +121,10 @@ export default class ReportingAllocationController extends ReportingControllerBa
       const q = `(SELECT id,
                     (SELECT COALESCE(SUM(time_spent), 0)
                     FROM task_work_log
-                            LEFT JOIN tasks ON task_work_log.task_id = tasks.id
+                            LEFT JOIN tasks ON task_work_log.task_id = tasks.id ${billableQuery}
                     WHERE user_id = users.id
                     AND CASE WHEN ($1 IS TRUE) THEN tasks.project_id IS NOT NULL ELSE tasks.archived = FALSE END
                     AND tasks.project_id IN (${projectIds})
-                    ${billableQuery}
                     ${duration}) AS time_logged
                     FROM users
                     WHERE id IN (${userIds})
@@ -367,8 +346,6 @@ export default class ReportingAllocationController extends ReportingControllerBa
     const projects = (req.body.projects || []) as string[];
     const projectIds = projects.map(p => `'${p}'`).join(",");
 
-    const categories = (req.body.categories || []) as string[];
-    const noCategory = req.body.noCategory || false;
     const billable = req.body.billable;
 
     if (!teamIds || !projectIds.length)
@@ -384,33 +361,6 @@ export default class ReportingAllocationController extends ReportingControllerBa
 
     const billableQuery = this.buildBillableQuery(billable);
 
-    // Prepare projects filter
-    let projectsFilter = "";
-    if (projectIds.length > 0) {
-      projectsFilter = `AND p.id IN (${projectIds})`;
-    } else {
-      // If no projects are selected, don't show any data
-      projectsFilter = `AND 1=0`; // This will match no rows
-    }
-
-    // Prepare categories filter - updated logic
-    let categoriesFilter = "";
-    if (categories.length > 0 && noCategory) {
-      // Both specific categories and "No Category" are selected
-      const categoryIds = categories.map(id => `'${id}'`).join(",");
-      categoriesFilter = `AND (p.category_id IS NULL OR p.category_id IN (${categoryIds}))`;
-    } else if (categories.length === 0 && noCategory) {
-      // Only "No Category" is selected
-      categoriesFilter = `AND p.category_id IS NULL`;
-    } else if (categories.length > 0 && !noCategory) {
-      // Only specific categories are selected
-      const categoryIds = categories.map(id => `'${id}'`).join(",");
-      categoriesFilter = `AND p.category_id IN (${categoryIds})`;
-    } else {
-      // categories.length === 0 && !noCategory - no categories selected, show nothing
-      categoriesFilter = `AND 1=0`; // This will match no rows
-    }
-
     const q = `
         SELECT p.id,
             p.name,
@@ -418,15 +368,13 @@ export default class ReportingAllocationController extends ReportingControllerBa
             SUM(total_minutes) AS estimated,
             color_code
         FROM projects p
-                LEFT JOIN tasks ON tasks.project_id = p.id
+                LEFT JOIN tasks ON tasks.project_id = p.id ${billableQuery}
                 LEFT JOIN task_work_log ON task_work_log.task_id = tasks.id
-        WHERE p.id IN (${projectIds}) ${durationClause} ${archivedClause} ${categoriesFilter} ${billableQuery}
+        WHERE p.id IN (${projectIds}) ${durationClause} ${archivedClause}
         GROUP BY p.id, p.name
         ORDER BY logged_time DESC;`;
     const result = await db.query(q, []);
 
-    const utilization = (req.body.utilization || []) as string[];
-
     const data = [];
 
     for (const project of result.rows) {
@@ -453,12 +401,10 @@ export default class ReportingAllocationController extends ReportingControllerBa
     const projects = (req.body.projects || []) as string[];
     const projectIds = projects.map(p => `'${p}'`).join(",");
 
-    const categories = (req.body.categories || []) as string[];
-    const noCategory = req.body.noCategory || false;
     const billable = req.body.billable;
 
-    if (!teamIds)
-      return res.status(200).send(new ServerResponse(true, { filteredRows: [], totals: { total_time_logs: "0", total_estimated_hours: "0", total_utilization: "0" } }));
+    if (!teamIds || !projectIds.length)
+      return res.status(200).send(new ServerResponse(true, { users: [], projects: [] }));
 
     const { duration, date_range } = req.body;
 
@@ -470,9 +416,7 @@ export default class ReportingAllocationController extends ReportingControllerBa
       endDate = moment(date_range[1]);
     } else if (duration === DATE_RANGES.ALL_TIME) {
       // Fetch the earliest start_date (or created_at if null) from selected projects
-      const minDateQuery = projectIds.length > 0 
-        ? `SELECT MIN(COALESCE(start_date, created_at)) as min_date FROM projects WHERE id IN (${projectIds})`
-        : `SELECT MIN(COALESCE(start_date, created_at)) as min_date FROM projects WHERE team_id IN (${teamIds})`;
+      const minDateQuery = `SELECT MIN(COALESCE(start_date, created_at)) as min_date FROM projects WHERE id IN (${projectIds})`;
       const minDateResult = await db.query(minDateQuery, []);
       const minDate = minDateResult.rows[0]?.min_date;
       startDate = minDate ? moment(minDate) : moment('2000-01-01');
@@ -501,223 +445,59 @@ export default class ReportingAllocationController extends ReportingControllerBa
       }
     }
 
-    // Get organization working days
-    const orgWorkingDaysQuery = `
-      SELECT monday, tuesday, wednesday, thursday, friday, saturday, sunday
-      FROM organization_working_days
-      WHERE organization_id IN (
-        SELECT t.organization_id 
-        FROM teams t 
-        WHERE t.id IN (${teamIds})
-        LIMIT 1
-      );
-    `;
-    const orgWorkingDaysResult = await db.query(orgWorkingDaysQuery, []);
-    const workingDaysConfig = orgWorkingDaysResult.rows[0] || {
-      monday: true,
-      tuesday: true,
-      wednesday: true,
-      thursday: true,
-      friday: true,
-      saturday: false,
-      sunday: false
-    };
-
-    // Count working days based on organization settings
+    // Count only weekdays (Mon-Fri) in the period
     let workingDays = 0;
     let current = startDate.clone();
     while (current.isSameOrBefore(endDate, 'day')) {
       const day = current.isoWeekday();
-      if (
-        (day === 1 && workingDaysConfig.monday) ||
-        (day === 2 && workingDaysConfig.tuesday) ||
-        (day === 3 && workingDaysConfig.wednesday) ||
-        (day === 4 && workingDaysConfig.thursday) ||
-        (day === 5 && workingDaysConfig.friday) ||
-        (day === 6 && workingDaysConfig.saturday) ||
-        (day === 7 && workingDaysConfig.sunday)
-      ) {
-        workingDays++;
-      }
+      if (day >= 1 && day <= 5) workingDays++;
       current.add(1, 'day');
     }
 
-    // Get organization working hours
-    const orgWorkingHoursQuery = `SELECT working_hours FROM organizations WHERE id = (SELECT t.organization_id FROM teams t WHERE t.id IN (${teamIds}) LIMIT 1)`;
-    const orgWorkingHoursResult = await db.query(orgWorkingHoursQuery, []);
-    const orgWorkingHours = orgWorkingHoursResult.rows[0]?.working_hours || 8;
-    
-    // Calculate total working hours with minimum baseline for non-working day scenarios
-    let totalWorkingHours = workingDays * orgWorkingHours;
-    let isNonWorkingPeriod = false;
-    
-    // If no working days but there might be logged time, set minimum baseline
-    // This ensures that time logged on non-working days is treated as over-utilization
-    // Business Logic: If someone works on weekends/holidays when workingDays = 0,
-    // we use a minimal baseline (1 hour) so any logged time results in >100% utilization
-    if (totalWorkingHours === 0) {
-      totalWorkingHours = 1; // Minimal baseline to ensure over-utilization
-      isNonWorkingPeriod = true;
+    // Get hours_per_day for all selected projects
+    const projectHoursQuery = `SELECT id, hours_per_day FROM projects WHERE id IN (${projectIds})`;
+    const projectHoursResult = await db.query(projectHoursQuery, []);
+    const projectHoursMap: Record<string, number> = {};
+    for (const row of projectHoursResult.rows) {
+      projectHoursMap[row.id] = row.hours_per_day || 8;
+    }
+    // Sum total working hours for all selected projects
+    let totalWorkingHours = 0;
+    for (const pid of Object.keys(projectHoursMap)) {
+      totalWorkingHours += workingDays * projectHoursMap[pid];
     }
 
+    const durationClause = this.getDateRangeClause(duration || DATE_RANGES.LAST_WEEK, date_range);
     const archivedClause = archived
       ? ""
       : `AND p.id NOT IN (SELECT project_id FROM archived_projects WHERE project_id = p.id AND user_id = '${req.user?.id}') `;
 
-    const billableQuery = this.buildBillableQueryWithAlias(billable, 't');
-    const members = (req.body.members || []) as string[];
-    
-    // Prepare members filter - updated logic to handle Clear All scenario
-    let membersFilter = "";
-    if (members.length > 0) {
-      const memberIds = members.map(id => `'${id}'`).join(",");
-      membersFilter = `AND tmiv.team_member_id IN (${memberIds})`;
-    } else {
-      // No members selected - show no data (Clear All scenario)
-      membersFilter = `AND 1=0`; // This will match no rows
-    }
+    const billableQuery = this.buildBillableQuery(billable);
 
-    // Prepare projects filter
-    let projectsFilter = "";
-    if (projectIds.length > 0) {
-      projectsFilter = `AND p.id IN (${projectIds})`;
-    } else {
-      // If no projects are selected, don't show any data
-      projectsFilter = `AND 1=0`; // This will match no rows
-    }
-
-    // Prepare categories filter - updated logic
-    let categoriesFilter = "";
-    if (categories.length > 0 && noCategory) {
-      // Both specific categories and "No Category" are selected
-      const categoryIds = categories.map(id => `'${id}'`).join(",");
-      categoriesFilter = `AND (p.category_id IS NULL OR p.category_id IN (${categoryIds}))`;
-    } else if (categories.length === 0 && noCategory) {
-      // Only "No Category" is selected
-      categoriesFilter = `AND p.category_id IS NULL`;
-    } else if (categories.length > 0 && !noCategory) {
-      // Only specific categories are selected
-      const categoryIds = categories.map(id => `'${id}'`).join(",");
-      categoriesFilter = `AND p.category_id IN (${categoryIds})`;
-    } else {
-      // categories.length === 0 && !noCategory - no categories selected, show nothing
-      categoriesFilter = `AND 1=0`; // This will match no rows
-    }
-
-    // Create custom duration clause for twl table alias
-    let customDurationClause = "";
-    if (date_range && date_range.length === 2) {
-      const start = moment(date_range[0]).format("YYYY-MM-DD");
-      const end = moment(date_range[1]).format("YYYY-MM-DD");
-      if (start === end) {
-        customDurationClause = `AND twl.created_at::DATE = '${start}'::DATE`;
-      } else {
-        customDurationClause = `AND twl.created_at::DATE >= '${start}'::DATE AND twl.created_at < '${end}'::DATE + INTERVAL '1 day'`;
-      }
-    } else {
-      const key = duration || DATE_RANGES.LAST_WEEK;
-      if (key === DATE_RANGES.YESTERDAY)
-        customDurationClause = "AND twl.created_at >= (CURRENT_DATE - INTERVAL '1 day')::DATE AND twl.created_at < CURRENT_DATE::DATE";
-      else if (key === DATE_RANGES.LAST_WEEK)
-        customDurationClause = "AND twl.created_at >= (CURRENT_DATE - INTERVAL '1 week')::DATE AND twl.created_at < CURRENT_DATE::DATE + INTERVAL '1 day'";
-      else if (key === DATE_RANGES.LAST_MONTH)
-        customDurationClause = "AND twl.created_at >= (CURRENT_DATE - INTERVAL '1 month')::DATE AND twl.created_at < CURRENT_DATE::DATE + INTERVAL '1 day'";
-      else if (key === DATE_RANGES.LAST_QUARTER)
-        customDurationClause = "AND twl.created_at >= (CURRENT_DATE - INTERVAL '3 months')::DATE AND twl.created_at < CURRENT_DATE::DATE + INTERVAL '1 day'";
-    }
-
-    // Modified query to start from team members and calculate filtered time logs
     const q = `
-      SELECT 
-        tmiv.team_member_id, 
-        tmiv.email, 
-        tmiv.name, 
-        COALESCE(
-          (SELECT SUM(twl.time_spent)
-           FROM task_work_log twl
-           LEFT JOIN tasks t ON t.id = twl.task_id
-           LEFT JOIN projects p ON p.id = t.project_id
-           WHERE twl.user_id = tmiv.user_id
-             ${customDurationClause}
-             ${projectsFilter}
-             ${categoriesFilter}
-             ${archivedClause}
-             ${billableQuery}
-             AND p.team_id = tmiv.team_id
-          ), 0
-        ) AS logged_time
-      FROM team_member_info_view tmiv
-      WHERE tmiv.team_id IN (${teamIds})
-        AND tmiv.active = TRUE
-        ${membersFilter}
-      GROUP BY tmiv.email, tmiv.name, tmiv.team_member_id, tmiv.user_id, tmiv.team_id
-      ORDER BY logged_time DESC;`;
-
+        SELECT tmiv.email, tmiv.name, SUM(time_spent) AS logged_time
+            FROM team_member_info_view tmiv
+                    LEFT JOIN task_work_log ON task_work_log.user_id = tmiv.user_id
+                    LEFT JOIN tasks ON tasks.id = task_work_log.task_id ${billableQuery}
+                    LEFT JOIN projects p ON p.id = tasks.project_id AND p.team_id = tmiv.team_id
+            WHERE p.id IN (${projectIds})
+            ${durationClause} ${archivedClause}
+            GROUP BY tmiv.email, tmiv.name
+            ORDER BY logged_time DESC;`;
     const result = await db.query(q, []);
-    const utilization = (req.body.utilization || []) as string[];
 
-    // Precompute totalWorkingHours * 3600 for efficiency
-    const totalWorkingSeconds = totalWorkingHours * 3600;
-
-    // calculate utilization state
-    for (let i = 0, len = result.rows.length; i < len; i++) {
-      const member = result.rows[i];
-      const loggedSeconds = member.logged_time ? parseFloat(member.logged_time) : 0;
-      const utilizedHours = loggedSeconds / 3600;
-      
-      // For individual members, use the same logic as total calculation
-      let memberWorkingHours = totalWorkingHours;
-      if (isNonWorkingPeriod && loggedSeconds > 0) {
-        // Any time logged during non-working period should be treated as over-utilization
-        memberWorkingHours = Math.min(utilizedHours, 1); // Use actual time or 1 hour, whichever is smaller
-      }
-      
-      const utilizationPercent = memberWorkingHours > 0 && loggedSeconds
-        ? ((loggedSeconds / (memberWorkingHours * 3600)) * 100)
-        : 0;
-      const overUnder = utilizedHours - memberWorkingHours;
-
-      member.value = utilizedHours ? parseFloat(utilizedHours.toFixed(2)) : 0;
+    for (const member of result.rows) {
+      member.value = member.logged_time ? parseFloat(moment.duration(member.logged_time, "seconds").asHours().toFixed(2)) : 0;
       member.color_code = getColor(member.name);
-      member.total_working_hours = memberWorkingHours;
-      member.utilization_percent = utilizationPercent.toFixed(2);
-      member.utilized_hours = utilizedHours.toFixed(2);
+      member.total_working_hours = totalWorkingHours;
+      member.utilization_percent = (totalWorkingHours > 0 && member.logged_time) ? ((parseFloat(member.logged_time) / (totalWorkingHours * 3600)) * 100).toFixed(2) : '0.00';
+      member.utilized_hours = member.logged_time ? (parseFloat(member.logged_time) / 3600).toFixed(2) : '0.00';
+      // Over/under utilized hours: utilized_hours - total_working_hours
+      const overUnder = member.utilized_hours && member.total_working_hours ? (parseFloat(member.utilized_hours) - member.total_working_hours) : 0;
       member.over_under_utilized_hours = overUnder.toFixed(2);
-
-      if (utilizationPercent < 90) {
-        member.utilization_state = 'under';
-      } else if (utilizationPercent <= 110) {
-        member.utilization_state = 'optimal';
-      } else {
-        member.utilization_state = 'over';
-      }
     }
 
-    // Apply utilization filter
-    let filteredRows;
-    if (utilization.length > 0) {
-      // Filter to only show selected utilization states
-      filteredRows = result.rows.filter(member => utilization.includes(member.utilization_state));
-    } else {
-      // No utilization states selected - show no data (Clear All scenario)
-      filteredRows = [];
-    }
-
-    // Calculate totals
-    const total_time_logs = filteredRows.reduce((sum, member) => sum + parseFloat(member.logged_time || '0'), 0);
-    const total_estimated_hours = totalWorkingHours * filteredRows.length; // Total for all members
-    const total_utilization = total_time_logs > 0 && total_estimated_hours > 0
-      ? ((total_time_logs / (total_estimated_hours * 3600)) * 100).toFixed(1)
-      : '0';
-
-    return res.status(200).send(new ServerResponse(true, {
-      filteredRows,
-      totals: {
-        total_time_logs: ((total_time_logs / 3600).toFixed(2)).toString(),
-        total_estimated_hours: total_estimated_hours.toString(),
-        total_utilization: total_utilization.toString(),
-      },
-    }));
+    return res.status(200).send(new ServerResponse(true, result.rows));
   }
 
   @HandleExceptions()
@@ -800,9 +580,6 @@ export default class ReportingAllocationController extends ReportingControllerBa
 
     const projects = (req.body.projects || []) as string[];
     const projectIds = projects.map(p => `'${p}'`).join(",");
-    
-    const categories = (req.body.categories || []) as string[];
-    const noCategory = req.body.noCategory || false;
     const { type, billable } = req.body;
 
     if (!teamIds || !projectIds.length)
@@ -818,33 +595,6 @@ export default class ReportingAllocationController extends ReportingControllerBa
 
     const billableQuery = this.buildBillableQuery(billable);
 
-    // Prepare projects filter
-    let projectsFilter = "";
-    if (projectIds.length > 0) {
-      projectsFilter = `AND p.id IN (${projectIds})`;
-    } else {
-      // If no projects are selected, don't show any data
-      projectsFilter = `AND 1=0`; // This will match no rows
-    }
-
-    // Prepare categories filter - updated logic
-    let categoriesFilter = "";
-    if (categories.length > 0 && noCategory) {
-      // Both specific categories and "No Category" are selected
-      const categoryIds = categories.map(id => `'${id}'`).join(",");
-      categoriesFilter = `AND (p.category_id IS NULL OR p.category_id IN (${categoryIds}))`;
-    } else if (categories.length === 0 && noCategory) {
-      // Only "No Category" is selected
-      categoriesFilter = `AND p.category_id IS NULL`;
-    } else if (categories.length > 0 && !noCategory) {
-      // Only specific categories are selected
-      const categoryIds = categories.map(id => `'${id}'`).join(",");
-      categoriesFilter = `AND p.category_id IN (${categoryIds})`;
-    } else {
-      // categories.length === 0 && !noCategory - no categories selected, show nothing
-      categoriesFilter = `AND 1=0`; // This will match no rows
-    }
-
     const q = `
         SELECT p.id,
             p.name,
@@ -858,9 +608,9 @@ export default class ReportingAllocationController extends ReportingControllerBa
             WHERE project_id = p.id) AS estimated,
             color_code
         FROM projects p
-                LEFT JOIN tasks ON tasks.project_id = p.id
+                LEFT JOIN tasks ON tasks.project_id = p.id ${billableQuery}
                 LEFT JOIN task_work_log ON task_work_log.task_id = tasks.id
-        WHERE p.id IN (${projectIds}) ${durationClause} ${archivedClause} ${categoriesFilter} ${billableQuery}
+        WHERE p.id IN (${projectIds}) ${durationClause} ${archivedClause}
         GROUP BY p.id, p.name
         ORDER BY logged_time DESC;`;
     const result = await db.query(q, []);

worklenz-backend/src/controllers/reporting/reporting-controller-base-with-timezone.ts

@@ -0,0 +1,117 @@
+import WorklenzControllerBase from "../worklenz-controller-base";
+import { IWorkLenzRequest } from "../../interfaces/worklenz-request";
+import db from "../../config/db";
+import moment from "moment-timezone";
+import { DATE_RANGES } from "../../shared/constants";
+
+export default abstract class ReportingControllerBaseWithTimezone extends WorklenzControllerBase {
+  
+  /**
+   * Get the user's timezone from the database or request
+   * @param userId - The user ID
+   * @returns The user's timezone or 'UTC' as default
+   */
+  protected static async getUserTimezone(userId: string): Promise<string> {
+    const q = `SELECT tz.name as timezone 
+               FROM users u 
+               JOIN timezones tz ON u.timezone_id = tz.id 
+               WHERE u.id = $1`;
+    const result = await db.query(q, [userId]);
+    return result.rows[0]?.timezone || 'UTC';
+  }
+
+  /**
+   * Generate date range clause with timezone support
+   * @param key - Date range key (e.g., YESTERDAY, LAST_WEEK)
+   * @param dateRange - Array of date strings
+   * @param userTimezone - User's timezone (e.g., 'America/New_York')
+   * @returns SQL clause for date filtering
+   */
+  protected static getDateRangeClauseWithTimezone(key: string, dateRange: string[], userTimezone: string) {
+    // For custom date ranges
+    if (dateRange.length === 2) {
+      // Convert dates to user's timezone start/end of day
+      const start = moment.tz(dateRange[0], userTimezone).startOf('day');
+      const end = moment.tz(dateRange[1], userTimezone).endOf('day');
+      
+      // Convert to UTC for database comparison
+      const startUtc = start.utc().format("YYYY-MM-DD HH:mm:ss");
+      const endUtc = end.utc().format("YYYY-MM-DD HH:mm:ss");
+      
+      if (start.isSame(end, 'day')) {
+        // Single day selection
+        return `AND task_work_log.created_at >= '${startUtc}'::TIMESTAMP AND task_work_log.created_at <= '${endUtc}'::TIMESTAMP`;
+      }
+      
+      return `AND task_work_log.created_at >= '${startUtc}'::TIMESTAMP AND task_work_log.created_at <= '${endUtc}'::TIMESTAMP`;
+    }
+
+    // For predefined ranges, calculate based on user's timezone
+    const now = moment.tz(userTimezone);
+    let startDate, endDate;
+
+    switch (key) {
+      case DATE_RANGES.YESTERDAY:
+        startDate = now.clone().subtract(1, 'day').startOf('day');
+        endDate = now.clone().subtract(1, 'day').endOf('day');
+        break;
+      case DATE_RANGES.LAST_WEEK:
+        startDate = now.clone().subtract(1, 'week').startOf('week');
+        endDate = now.clone().subtract(1, 'week').endOf('week');
+        break;
+      case DATE_RANGES.LAST_MONTH:
+        startDate = now.clone().subtract(1, 'month').startOf('month');
+        endDate = now.clone().subtract(1, 'month').endOf('month');
+        break;
+      case DATE_RANGES.LAST_QUARTER:
+        startDate = now.clone().subtract(3, 'months').startOf('day');
+        endDate = now.clone().endOf('day');
+        break;
+      default:
+        return "";
+    }
+
+    if (startDate && endDate) {
+      const startUtc = startDate.utc().format("YYYY-MM-DD HH:mm:ss");
+      const endUtc = endDate.utc().format("YYYY-MM-DD HH:mm:ss");
+      return `AND task_work_log.created_at >= '${startUtc}'::TIMESTAMP AND task_work_log.created_at <= '${endUtc}'::TIMESTAMP`;
+    }
+
+    return "";
+  }
+
+  /**
+   * Format dates for display in user's timezone
+   * @param date - Date to format
+   * @param userTimezone - User's timezone
+   * @param format - Moment format string
+   * @returns Formatted date string
+   */
+  protected static formatDateInTimezone(date: string | Date, userTimezone: string, format: string = "YYYY-MM-DD HH:mm:ss") {
+    return moment.tz(date, userTimezone).format(format);
+  }
+
+  /**
+   * Get working days count between two dates in user's timezone
+   * @param startDate - Start date
+   * @param endDate - End date
+   * @param userTimezone - User's timezone
+   * @returns Number of working days
+   */
+  protected static getWorkingDaysInTimezone(startDate: string, endDate: string, userTimezone: string): number {
+    const start = moment.tz(startDate, userTimezone);
+    const end = moment.tz(endDate, userTimezone);
+    let workingDays = 0;
+    
+    const current = start.clone();
+    while (current.isSameOrBefore(end, 'day')) {
+      // Monday = 1, Friday = 5
+      if (current.isoWeekday() >= 1 && current.isoWeekday() <= 5) {
+        workingDays++;
+      }
+      current.add(1, 'day');
+    }
+    
+    return workingDays;
+  }
+}

worklenz-backend/src/controllers/reporting/reporting-members-controller.ts

@@ -6,10 +6,69 @@ import { IWorkLenzResponse } from "../../interfaces/worklenz-response";
 import { ServerResponse } from "../../models/server-response";
 import { DATE_RANGES, TASK_PRIORITY_COLOR_ALPHA } from "../../shared/constants";
 import { formatDuration, getColor, int } from "../../shared/utils";
-import ReportingControllerBase from "./reporting-controller-base";
+import ReportingControllerBaseWithTimezone from "./reporting-controller-base-with-timezone";
 import Excel from "exceljs";
 
-export default class ReportingMembersController extends ReportingControllerBase {
+export default class ReportingMembersController extends ReportingControllerBaseWithTimezone {
+
+  protected static getPercentage(n: number, total: number) {
+    return +(n ? (n / total) * 100 : 0).toFixed();
+  }
+
+  protected static getCurrentTeamId(req: IWorkLenzRequest): string | null {
+    return req.user?.team_id ?? null;
+  }
+
+  public static convertMinutesToHoursAndMinutes(totalMinutes: number) {
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    return `${hours}h ${minutes}m`;
+  }
+
+  public static convertSecondsToHoursAndMinutes(seconds: number) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    return `${hours}h ${minutes}m`;
+  }
+
+  protected static formatEndDate(endDate: string) {
+    const end = moment(endDate).format("YYYY-MM-DD");
+    const fEndDate = moment(end);
+    return fEndDate;
+  }
+
+  protected static formatCurrentDate() {
+    const current = moment().format("YYYY-MM-DD");
+    const fCurrentDate = moment(current);
+    return fCurrentDate;
+  }
+
+  protected static getDaysLeft(endDate: string): number | null {
+    if (!endDate) return null;
+
+    const fCurrentDate = this.formatCurrentDate();
+    const fEndDate = this.formatEndDate(endDate);
+
+    return fEndDate.diff(fCurrentDate, "days");
+  }
+
+  protected static isOverdue(endDate: string): boolean {
+    if (!endDate) return false;
+
+    const fCurrentDate = this.formatCurrentDate();
+    const fEndDate = this.formatEndDate(endDate);
+
+    return fEndDate.isBefore(fCurrentDate);
+  }
+
+  protected static isToday(endDate: string): boolean {
+    if (!endDate) return false;
+
+    const fCurrentDate = this.formatCurrentDate();
+    const fEndDate = this.formatEndDate(endDate);
+
+    return fEndDate.isSame(fCurrentDate);
+  }
 
   private static async getMembers(
     teamId: string, searchQuery = "",
@@ -31,7 +90,6 @@ export default class ReportingMembersController extends ReportingControllerBase
     const completedDurationClasue = this.completedDurationFilter(key, dateRange);
     const overdueActivityLogsClause = this.getActivityLogsOverdue(key, dateRange);
     const activityLogCreationFilter = this.getActivityLogsCreationClause(key, dateRange);
-    const timeLogDateRangeClause = this.getTimeLogDateRangeClause(key, dateRange);
 
     const q = `SELECT COUNT(DISTINCT email) AS total,
               (SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(t))), '[]'::JSON)
@@ -101,25 +159,7 @@ export default class ReportingMembersController extends ReportingControllerBase
                                   FROM tasks t
                                           LEFT JOIN tasks_assignees ta ON t.id = ta.task_id
                                   WHERE team_member_id = tmiv.team_member_id
-                                      AND is_doing((SELECT new_value FROM task_activity_logs tl WHERE tl.task_id = t.id AND tl.attribute_type = 'status' ${activityLogCreationFilter} ORDER BY tl.created_at DESC LIMIT 1)::UUID, t.project_id) ${archivedClause}) AS ongoing_by_activity_logs,
-
-                              (SELECT COALESCE(SUM(twl.time_spent), 0)
-                                  FROM task_work_log twl
-                                  LEFT JOIN tasks t ON twl.task_id = t.id
-                                  WHERE twl.user_id = (SELECT user_id FROM team_members WHERE id = tmiv.team_member_id)
-                                      AND t.billable IS TRUE
-                                      AND t.project_id IN (SELECT id FROM projects WHERE team_id = $1)
-                                      ${timeLogDateRangeClause}
-                                      ${includeArchived ? "" : `AND t.project_id NOT IN (SELECT project_id FROM archived_projects WHERE project_id = t.project_id AND archived_projects.user_id = '${userId}')`}) AS billable_time,
-
-                              (SELECT COALESCE(SUM(twl.time_spent), 0)
-                                  FROM task_work_log twl
-                                  LEFT JOIN tasks t ON twl.task_id = t.id
-                                  WHERE twl.user_id = (SELECT user_id FROM team_members WHERE id = tmiv.team_member_id)
-                                      AND t.billable IS FALSE
-                                      AND t.project_id IN (SELECT id FROM projects WHERE team_id = $1)
-                                      ${timeLogDateRangeClause}
-                                      ${includeArchived ? "" : `AND t.project_id NOT IN (SELECT project_id FROM archived_projects WHERE project_id = t.project_id AND archived_projects.user_id = '${userId}')`}) AS non_billable_time
+                                      AND is_doing((SELECT new_value FROM task_activity_logs tl WHERE tl.task_id = t.id AND tl.attribute_type = 'status' ${activityLogCreationFilter} ORDER BY tl.created_at DESC LIMIT 1)::UUID, t.project_id) ${archivedClause}) AS ongoing_by_activity_logs
                       FROM team_member_info_view tmiv
                       WHERE tmiv.team_id = $1 ${teamsClause}
                           AND tmiv.team_member_id IN (SELECT team_member_id
@@ -330,30 +370,6 @@ export default class ReportingMembersController extends ReportingControllerBase
     return "";
   }
 
-  protected static getTimeLogDateRangeClause(key: string, dateRange: string[]) {
-    if (dateRange.length === 2) {
-      const start = moment(dateRange[0]).format("YYYY-MM-DD");
-      const end = moment(dateRange[1]).format("YYYY-MM-DD");
-
-      if (start === end) {
-        return `AND twl.created_at::DATE = '${start}'::DATE`;
-      }
-
-      return `AND twl.created_at::DATE >= '${start}'::DATE AND twl.created_at < '${end}'::DATE + INTERVAL '1 day'`;
-    }
-
-    if (key === DATE_RANGES.YESTERDAY)
-      return `AND twl.created_at >= (CURRENT_DATE - INTERVAL '1 day')::DATE AND twl.created_at < CURRENT_DATE::DATE`;
-    if (key === DATE_RANGES.LAST_WEEK)
-      return `AND twl.created_at >= (CURRENT_DATE - INTERVAL '1 week')::DATE AND twl.created_at < CURRENT_DATE::DATE + INTERVAL '1 day'`;
-    if (key === DATE_RANGES.LAST_MONTH)
-      return `AND twl.created_at >= (CURRENT_DATE - INTERVAL '1 month')::DATE AND twl.created_at < CURRENT_DATE::DATE + INTERVAL '1 day'`;
-    if (key === DATE_RANGES.LAST_QUARTER)
-      return `AND twl.created_at >= (CURRENT_DATE - INTERVAL '3 months')::DATE AND twl.created_at < CURRENT_DATE::DATE + INTERVAL '1 day'`;
-
-    return "";
-  }
-
   private static formatDuration(duration: moment.Duration) {
     const empty = "0h 0m";
     let format = "";
@@ -466,8 +482,6 @@ export default class ReportingMembersController extends ReportingControllerBase
       { header: "Overdue Tasks", key: "overdue_tasks", width: 20 },
       { header: "Completed Tasks", key: "completed_tasks", width: 20 },
       { header: "Ongoing Tasks", key: "ongoing_tasks", width: 20 },
-      { header: "Billable Time (seconds)", key: "billable_time", width: 25 },
-      { header: "Non-Billable Time (seconds)", key: "non_billable_time", width: 25 },
       { header: "Done Tasks(%)", key: "done_tasks", width: 20 },
       { header: "Doing Tasks(%)", key: "doing_tasks", width: 20 },
       { header: "Todo Tasks(%)", key: "todo_tasks", width: 20 }
@@ -475,14 +489,14 @@ export default class ReportingMembersController extends ReportingControllerBase
 
     // set title
     sheet.getCell("A1").value = `Members from ${teamName}`;
-    sheet.mergeCells("A1:M1");
+    sheet.mergeCells("A1:K1");
     sheet.getCell("A1").alignment = { horizontal: "center" };
     sheet.getCell("A1").style.fill = { type: "pattern", pattern: "solid", fgColor: { argb: "D9D9D9" } };
     sheet.getCell("A1").font = { size: 16 };
 
     // set export date
     sheet.getCell("A2").value = `Exported on : ${exportDate}`;
-    sheet.mergeCells("A2:M2");
+    sheet.mergeCells("A2:K2");
     sheet.getCell("A2").alignment = { horizontal: "center" };
     sheet.getCell("A2").style.fill = { type: "pattern", pattern: "solid", fgColor: { argb: "F2F2F2" } };
     sheet.getCell("A2").font = { size: 12 };
@@ -492,7 +506,7 @@ export default class ReportingMembersController extends ReportingControllerBase
     sheet.mergeCells("A3:D3");
 
     // set table headers
-    sheet.getRow(5).values = ["Member", "Email", "Tasks Assigned", "Overdue Tasks", "Completed Tasks", "Ongoing Tasks", "Billable Time (seconds)", "Non-Billable Time (seconds)", "Done Tasks(%)", "Doing Tasks(%)", "Todo Tasks(%)"];
+    sheet.getRow(5).values = ["Member", "Email", "Tasks Assigned", "Overdue Tasks", "Completed Tasks", "Ongoing Tasks", "Done Tasks(%)", "Doing Tasks(%)", "Todo Tasks(%)"];
     sheet.getRow(5).font = { bold: true };
 
     for (const member of result.members) {
@@ -503,8 +517,6 @@ export default class ReportingMembersController extends ReportingControllerBase
         overdue_tasks: member.overdue,
         completed_tasks: member.completed,
         ongoing_tasks: member.ongoing,
-        billable_time: member.billable_time || 0,
-        non_billable_time: member.non_billable_time || 0,
         done_tasks: member.completed,
         doing_tasks: member.ongoing_by_activity_logs,
         todo_tasks: member.todo_by_activity_logs
@@ -534,7 +546,9 @@ export default class ReportingMembersController extends ReportingControllerBase
       dateRange = date_range.split(",");
     }
 
-    const durationClause = ReportingMembersController.getDateRangeClauseMembers(duration as string || DATE_RANGES.LAST_WEEK, dateRange, "twl");
+    // Get user timezone for proper date filtering
+    const userTimezone = await this.getUserTimezone(req.user?.id as string);
+    const durationClause = this.getDateRangeClauseWithTimezone(duration as string || DATE_RANGES.LAST_WEEK, dateRange, userTimezone);
     const minMaxDateClause = this.getMinMaxDates(duration as string || DATE_RANGES.LAST_WEEK, dateRange, "task_work_log");
     const memberName = (req.query.member_name as string)?.trim() || null;
 
@@ -1085,7 +1099,9 @@ export default class ReportingMembersController extends ReportingControllerBase
   public static async getMemberTimelogs(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
     const { team_member_id, team_id, duration, date_range, archived, billable } = req.body;
 
-    const durationClause = ReportingMembersController.getDateRangeClauseMembers(duration || DATE_RANGES.LAST_WEEK, date_range, "twl");
+    // Get user timezone for proper date filtering
+    const userTimezone = await this.getUserTimezone(req.user?.id as string);
+    const durationClause = this.getDateRangeClauseWithTimezone(duration || DATE_RANGES.LAST_WEEK, date_range, userTimezone);
     const minMaxDateClause = this.getMinMaxDates(duration || DATE_RANGES.LAST_WEEK, date_range, "task_work_log");
 
     const billableQuery = this.buildBillableQuery(billable);
@@ -1277,8 +1293,8 @@ public static async getSingleMemberProjects(req: IWorkLenzRequest, res: IWorkLen
     row.actual_time = int(row.actual_time);
     row.estimated_time_string = this.convertMinutesToHoursAndMinutes(int(row.estimated_time));
     row.actual_time_string = this.convertSecondsToHoursAndMinutes(int(row.actual_time));
-    row.days_left = ReportingControllerBase.getDaysLeft(row.end_date);
-    row.is_overdue = ReportingControllerBase.isOverdue(row.end_date);
+    row.days_left = this.getDaysLeft(row.end_date);
+    row.is_overdue = this.isOverdue(row.end_date);
     if (row.days_left && row.is_overdue) {
       row.days_left = row.days_left.toString().replace(/-/g, "");
     }

worklenz-backend/src/controllers/schedule-v2/schedule-controller.ts

@@ -74,9 +74,14 @@ export default class ScheduleControllerV2 extends WorklenzControllerBase {
             .map(day => `${day.toLowerCase()} = ${workingDays.includes(day)}`)
             .join(", ");
 
-        const updateQuery = `UPDATE public.organization_working_days
+        const updateQuery = `
+      UPDATE public.organization_working_days
       SET ${setClause}, updated_at = CURRENT_TIMESTAMP
-      WHERE organization_id IN (SELECT id FROM organizations WHERE user_id = $1);`;
+      WHERE organization_id IN (
+                                SELECT organization_id FROM organizations 
+                                WHERE user_id = $1
+                            );
+    `;
 
         await db.query(updateQuery, [req.user?.owner_id]);
 

worklenz-backend/src/controllers/task-phases-controller.ts

@@ -16,19 +16,23 @@ export default class TaskPhasesController extends WorklenzControllerBase {
     if (!req.query.id)
       return res.status(400).send(new ServerResponse(false, null, "Invalid request"));
 
+    // Use custom name if provided, otherwise use default naming pattern
+    const phaseName = req.body.name?.trim() || 
+      `Untitled Phase (${(await db.query("SELECT COUNT(*) FROM project_phases WHERE project_id = $1", [req.query.id])).rows[0].count + 1})`;
+
     const q = `
         INSERT INTO project_phases (name, color_code, project_id, sort_index)
         VALUES (
-                CONCAT('Untitled Phase (', (SELECT COUNT(*) FROM project_phases WHERE project_id = $2) + 1, ')'),
                 $1,
                 $2,
-                (SELECT COUNT(*) FROM project_phases WHERE project_id = $2) + 1)
+                $3,
+                (SELECT COUNT(*) FROM project_phases WHERE project_id = $3) + 1)
         RETURNING id, name, color_code, sort_index;
     `;
 
     req.body.color_code = this.DEFAULT_PHASE_COLOR;
 
-    const result = await db.query(q, [req.body.color_code, req.query.id]);
+    const result = await db.query(q, [phaseName, req.body.color_code, req.query.id]);
     const [data] = result.rows;
 
     data.color_code = getColor(data.name) + TASK_STATUS_COLOR_ALPHA;

worklenz-backend/src/controllers/task-statuses-controller.ts

@@ -134,6 +134,25 @@ export default class TaskStatusesController extends WorklenzControllerBase {
     return res.status(200).send(new ServerResponse(true, data));
   }
 
+  @HandleExceptions()
+  public static async updateCategory(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    const hasMoreCategories = await TaskStatusesController.hasMoreCategories(req.params.id, req.query.current_project_id as string);
+
+    if (!hasMoreCategories)
+      return res.status(200).send(new ServerResponse(false, null, existsErrorMessage).withTitle("Status category update failed!"));
+
+    const q = `
+      UPDATE task_statuses
+      SET category_id = $2
+      WHERE id = $1
+        AND project_id = $3
+      RETURNING (SELECT color_code FROM sys_task_status_categories WHERE id = task_statuses.category_id), (SELECT color_code_dark FROM sys_task_status_categories WHERE id = task_statuses.category_id);
+    `;
+    const result = await db.query(q, [req.params.id, req.body.category_id, req.query.current_project_id]);
+    const [data] = result.rows;
+    return res.status(200).send(new ServerResponse(true, data));
+  }
+
   @HandleExceptions()
   public static async updateStatusOrder(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
     const q = `SELECT update_status_order($1);`;

worklenz-backend/src/controllers/task-work-log-controller.ts

@@ -28,50 +28,32 @@ export default class TaskWorklogController extends WorklenzControllerBase {
     if (!id) return [];
 
     const q = `
-      WITH RECURSIVE task_hierarchy AS (
-        -- Base case: Start with the given task
-        SELECT id, name, 0 as level
-        FROM tasks
-        WHERE id = $1
-        
-        UNION ALL
-        
-        -- Recursive case: Get all subtasks
-        SELECT t.id, t.name, th.level + 1
-        FROM tasks t
-        INNER JOIN task_hierarchy th ON t.parent_task_id = th.id
-        WHERE t.archived IS FALSE
-      ),
-      time_logs AS (
-        SELECT 
-          twl.id,
-          twl.description,
-          twl.time_spent,
-          twl.created_at,
-          twl.user_id,
-          twl.logged_by_timer,
-          twl.task_id,
-          th.name AS task_name,
-          (SELECT name FROM users WHERE users.id = twl.user_id) AS user_name,
-          (SELECT email FROM users WHERE users.id = twl.user_id) AS user_email,
-          (SELECT avatar_url FROM users WHERE users.id = twl.user_id) AS avatar_url
-        FROM task_work_log twl
-        INNER JOIN task_hierarchy th ON twl.task_id = th.id
+      WITH time_logs AS (
+        --
+        SELECT id,
+               description,
+               time_spent,
+               created_at,
+               user_id,
+               logged_by_timer,
+               (SELECT name FROM users WHERE users.id = task_work_log.user_id) AS user_name,
+               (SELECT email FROM users WHERE users.id = task_work_log.user_id) AS user_email,
+               (SELECT avatar_url FROM users WHERE users.id = task_work_log.user_id) AS avatar_url
+        FROM task_work_log
+        WHERE task_id = $1
+        --
       )
-      SELECT 
-        id,
-        time_spent,
-        description,
-        created_at,
-        user_id,
-        logged_by_timer,
-        task_id,
-        task_name,
-        created_at AS start_time,
-        (created_at + INTERVAL '1 second' * time_spent) AS end_time,
-        user_name,
-        user_email,
-        avatar_url
+      SELECT id,
+             time_spent,
+             description,
+             created_at,
+             user_id,
+             logged_by_timer,
+             created_at AS start_time,
+             (created_at + INTERVAL '1 second' * time_spent) AS end_time,
+             user_name,
+             user_email,
+             avatar_url
       FROM time_logs
       ORDER BY created_at DESC;
     `;
@@ -161,7 +143,6 @@ export default class TaskWorklogController extends WorklenzControllerBase {
     };
 
     sheet.columns = [
-      {header: "Task Name", key: "task_name", width: 30},
       {header: "Reporter Name", key: "user_name", width: 25},
       {header: "Reporter Email", key: "user_email", width: 25},
       {header: "Start Time", key: "start_time", width: 25},
@@ -172,15 +153,14 @@ export default class TaskWorklogController extends WorklenzControllerBase {
     ];
 
     sheet.getCell("A1").value = metadata.project_name;
-    sheet.mergeCells("A1:H1");
+    sheet.mergeCells("A1:G1");
     sheet.getCell("A1").alignment = {horizontal: "center"};
 
     sheet.getCell("A2").value = `${metadata.name} (${exportDate})`;
-    sheet.mergeCells("A2:H2");
+    sheet.mergeCells("A2:G2");
     sheet.getCell("A2").alignment = {horizontal: "center"};
 
     sheet.getRow(4).values = [
-      "Task Name",
       "Reporter Name",
       "Reporter Email",
       "Start Time",
@@ -196,7 +176,6 @@ export default class TaskWorklogController extends WorklenzControllerBase {
     for (const item of results) {
       totalLogged += parseFloat((item.time_spent || 0).toString());
       const data = {
-        task_name: item.task_name,
         user_name: item.user_name,
         user_email: item.user_email,
         start_time: moment(item.start_time).add(timezone.hours || 0, "hours").add(timezone.minutes || 0, "minutes").format(timeFormat),
@@ -231,7 +210,6 @@ export default class TaskWorklogController extends WorklenzControllerBase {
     };
 
     sheet.addRow({
-      task_name: "",
       user_name: "",
       user_email: "",
       start_time: "Total",
@@ -241,7 +219,7 @@ export default class TaskWorklogController extends WorklenzControllerBase {
       time_spent: formatDuration(moment.duration(totalLogged, "seconds")),
     });
 
-    sheet.mergeCells(`A${sheet.rowCount}:G${sheet.rowCount}`);
+    sheet.mergeCells(`A${sheet.rowCount}:F${sheet.rowCount}`);
 
     sheet.getCell(`A${sheet.rowCount}`).value = "Total";
     sheet.getCell(`A${sheet.rowCount}`).alignment = {

worklenz-backend/src/controllers/tasks-controller-base.ts

@@ -16,6 +16,7 @@ export interface ITaskGroup {
   start_date?: string;
   end_date?: string;
   color_code: string;
+  color_code_dark: string;
   category_id: string | null;
   old_category_id?: string;
   todo_progress?: number;
@@ -81,31 +82,7 @@ export default class TasksControllerBase extends WorklenzControllerBase {
     task.is_sub_task = !!task.parent_task_id;
 
     task.time_spent_string = `${task.time_spent.hours}h ${(task.time_spent.minutes)}m`;
-    
-    // Use recursive estimation for parent tasks, own estimation for leaf tasks
-    const recursiveEstimation = task.recursive_estimation || {};
-    const hasSubtasks = (task.sub_tasks_count || 0) > 0;
-    
-    let displayMinutes;
-    if (hasSubtasks) {
-      // For parent tasks, use recursive estimation (sum of all subtasks)
-      displayMinutes = recursiveEstimation.recursive_total_minutes || 0;
-    } else {
-      // For leaf tasks, use their own estimation
-      displayMinutes = task.total_minutes || 0;
-    }
-    
-    // Format time string - show "0h" for zero time instead of "0h 0m"
-    const hours = ~~(displayMinutes / 60);
-    const minutes = displayMinutes % 60;
-    
-    if (displayMinutes === 0) {
-      task.total_time_string = "0h";
-    } else if (minutes === 0) {
-      task.total_time_string = `${hours}h`;
-    } else {
-      task.total_time_string = `${hours}h ${minutes}m`;
-    }
+    task.total_time_string = `${~~(task.total_minutes / 60)}h ${(task.total_minutes % 60)}m`;
 
     task.name_color = getColor(task.name);
     task.priority_color = PriorityColorCodes[task.priority_value] || PriorityColorCodes["0"];

worklenz-backend/src/controllers/tasks-controller.ts

@@ -427,24 +427,9 @@ export default class TasksController extends TasksControllerBase {
 
       task.names = WorklenzControllerBase.createTagList(task.assignees);
 
-      // Use recursive estimation if task has subtasks, otherwise use own estimation
-      const recursiveEstimation = task.recursive_estimation || {};
-      // Check both the recursive estimation count and the actual database count
-      const hasSubtasks = (task.sub_tasks_count || 0) > 0;
-      
-      let totalMinutes, hours, minutes;
-      
-      if (hasSubtasks) {
-        // For parent tasks, use the sum of all subtasks' estimation (excluding parent's own estimation)
-        totalMinutes = recursiveEstimation.recursive_total_minutes || 0;
-        hours = recursiveEstimation.recursive_total_hours || 0;
-        minutes = recursiveEstimation.recursive_remaining_minutes || 0;
-      } else {
-        // For tasks without subtasks, use their own estimation
-        totalMinutes = task.total_minutes || 0;
-        hours = Math.floor(totalMinutes / 60);
-        minutes = totalMinutes % 60;
-      }
+      const totalMinutes = task.total_minutes;
+      const hours = Math.floor(totalMinutes / 60);
+      const minutes = totalMinutes % 60;
 
       task.total_hours = hours;
       task.total_minutes = minutes;
@@ -623,18 +608,6 @@ export default class TasksController extends TasksControllerBase {
     return res.status(200).send(new ServerResponse(true, null));
   }
 
-  @HandleExceptions()
-  public static async resetParentTaskEstimations(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    const q = `SELECT reset_all_parent_task_estimations() AS updated_count;`;
-    const result = await db.query(q);
-    const [data] = result.rows;
-    
-    return res.status(200).send(new ServerResponse(true, { 
-      message: `Reset estimation for ${data.updated_count} parent tasks`,
-      updated_count: data.updated_count 
-    }));
-  }
-
   @HandleExceptions()
   public static async bulkAssignMembers(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
     const { tasks, members, project_id } = req.body;

worklenz-backend/src/controllers/worklenz-controller-base.ts

@@ -34,29 +34,24 @@ export default abstract class WorklenzControllerBase {
     const offset = queryParams.search ? 0 : (index - 1) * size;
     const paging = queryParams.paging || "true";
 
-    // let s = "";
-    // if (typeof searchField === "string") {
-    //   s = `${searchField} || ' ' || id::TEXT`;
-    // } else if (Array.isArray(searchField)) {
-    //   s = searchField.join(" || ' ' || ");
-    // }
-
-    // const search = (queryParams.search as string || "").trim();
-    // const searchQuery = search ? `AND TO_TSVECTOR(${s}) @@ TO_TSQUERY('${toTsQuery(search)}')` : "";
-
     const search = (queryParams.search as string || "").trim();
 
-    let s = "";
-    if (typeof searchField === "string") {
-      s = ` ${searchField} ILIKE '%${search}%'`;
-    } else if (Array.isArray(searchField)) {
-      s = searchField.map(index => ` ${index} ILIKE '%${search}%'`).join(" OR ");
-    }
-
     let searchQuery = "";
 
     if (search) {
-      searchQuery = isMemberFilter ? ` (${s})  AND ` : ` AND (${s}) `;
+      // Properly escape single quotes to prevent SQL syntax errors
+      const escapedSearch = search.replace(/'/g, "''");
+      
+      let s = "";
+      if (typeof searchField === "string") {
+        s = ` ${searchField} ILIKE '%${escapedSearch}%'`;
+      } else if (Array.isArray(searchField)) {
+        s = searchField.map(field => ` ${field} ILIKE '%${escapedSearch}%'`).join(" OR ");
+      }
+
+      if (s) {
+        searchQuery = isMemberFilter ? ` (${s})  AND ` : ` AND (${s}) `;
+      }
     }
 
     // Sort

worklenz-backend/src/middlewares/session-middleware.ts

@@ -6,11 +6,11 @@ import { isProduction } from "../shared/utils";
 const pgSession = require("connect-pg-simple")(session);
 
 export default session({
-  name: process.env.SESSION_NAME || "worklenz.sid",
+  name: process.env.SESSION_NAME,
   secret: process.env.SESSION_SECRET || "development-secret-key",
   proxy: false,
-  resave: true,
-  saveUninitialized: false,
+  resave: false,
+  saveUninitialized: true,
   rolling: true,
   store: new pgSession({
     pool: db.pool,
@@ -18,8 +18,10 @@ export default session({
   }),
   cookie: {
     path: "/",
-    httpOnly: true,
-    secure: false,
+    // secure: isProduction(),
+    // httpOnly: isProduction(),
+    // sameSite: "none",
+    // domain: isProduction() ? ".worklenz.com" : undefined,
     maxAge: 30 * 24 * 60 * 60 * 1000 // 30 days
   }
 });

worklenz-backend/src/middlewares/validators/ratecard-body-validator.ts

@@ -1,15 +0,0 @@
-import {NextFunction} from "express";
-
-import {IWorkLenzRequest} from "../../interfaces/worklenz-request";
-import {IWorkLenzResponse} from "../../interfaces/worklenz-response";
-import {ServerResponse} from "../../models/server-response";
-
-export default function (req: IWorkLenzRequest, res: IWorkLenzResponse, next: NextFunction): IWorkLenzResponse | void {
-  const {name} = req.body;
-  if (!name || name.trim() === "")
-    return res.status(200).send(new ServerResponse(false, null, "Name is required"));
-
-  req.body.name = req.body.name.trim();
-
-  return next();
-}

worklenz-backend/src/passport/deserialize.ts

@@ -30,7 +30,6 @@ export async function deserialize(user: { id: string | null }, done: IDeserializ
     const excludedSubscriptionTypes = ["TRIAL", "PADDLE"];
     const q = `SELECT deserialize_user($1) AS user;`;
     const result = await db.query(q, [id]);
-    
     if (result.rows.length) {
       const [data] = result.rows;
       if (data?.user) {

worklenz-backend/src/passport/passport-strategies/passport-local-login.ts

@@ -44,6 +44,7 @@ async function handleLogin(req: Request, email: string, password: string, done:
     req.flash(ERROR_KEY, errorMsg);
     return done(null, false);
   } catch (error) {
+    console.error("Login error:", error);
     log_error(error, req.body);
     return done(error);
   }

worklenz-backend/src/passport/passport-strategies/passport-local-signup.ts

@@ -47,55 +47,41 @@ async function handleSignUp(req: Request, email: string, password: string, done:
   // team = Invited team_id if req.body.from_invitation is true
   const {name, team_name, team_member_id, team_id, timezone} = req.body;
 
-  if (!team_name) {
-    req.flash(ERROR_KEY, "Team name is required");
-    return done(null, null, {message: "Team name is required"});
-  }
+  if (!team_name) return done(null, null, req.flash(ERROR_KEY, "Team name is required"));
 
   const googleAccountFound = await isGoogleAccountFound(email);
-  if (googleAccountFound) {
-    req.flash(ERROR_KEY, `${req.body.email} is already linked with a Google account.`);
-    return done(null, null, {message: `${req.body.email} is already linked with a Google account.`});
-  }
+  if (googleAccountFound)
+    return done(null, null, req.flash(ERROR_KEY, `${req.body.email} is already linked with a Google account.`));
 
   try {
     const user = await registerUser(password, team_id, name, team_name, email, timezone, team_member_id);
     sendWelcomeEmail(email, name);
-    req.flash(SUCCESS_KEY, "Registration successful. Please check your email for verification.");
-    return done(null, user, {message: "Registration successful. Please check your email for verification."});
+    return done(null, user, req.flash(SUCCESS_KEY, "Registration successful. Please check your email for verification."));
   } catch (error: any) {
     const message = (error?.message) || "";
 
     if (message === "ERROR_INVALID_JOINING_EMAIL") {
-      req.flash(ERROR_KEY, `No invitations found for email ${req.body.email}.`);
-      return done(null, null, {message: `No invitations found for email ${req.body.email}.`});
+      return done(null, null, req.flash(ERROR_KEY, `No invitations found for email ${req.body.email}.`));
     }
 
     // if error.message is "email already exists" then it should have the email address in the error message after ":".
     if (message.includes("EMAIL_EXISTS_ERROR") || error.constraint === "users_google_id_uindex") {
       const [, value] = error.message.split(":");
-      const errorMsg = `Worklenz account already exists for email ${value}.`;
-      req.flash(ERROR_KEY, errorMsg);
-      return done(null, null, {message: errorMsg});
+      return done(null, null, req.flash(ERROR_KEY, `Worklenz account already exists for email ${value}.`));
     }
 
     if (message.includes("TEAM_NAME_EXISTS_ERROR")) {
       const [, value] = error.message.split(":");
-      const errorMsg = `Team name "${value}" already exists. Please choose a different team name.`;
-      req.flash(ERROR_KEY, errorMsg);
-      return done(null, null, {message: errorMsg});
+      return done(null, null, req.flash(ERROR_KEY, `Team name "${value}" already exists. Please choose a different team name.`));
     }
 
     // The Team name is already taken.
     if (error.constraint === "teams_url_uindex" || error.constraint === "teams_name_uindex") {
-      const errorMsg = `Team name "${team_name}" is already taken. Please choose a different team name.`;
-      req.flash(ERROR_KEY, errorMsg);
-      return done(null, null, {message: errorMsg});
+      return done(null, null, req.flash(ERROR_KEY, `Team name "${team_name}" is already taken. Please choose a different team name.`));
     }
 
     log_error(error, req.body);
-    req.flash(ERROR_KEY, DEFAULT_ERROR_MESSAGE);
-    return done(null, null, {message: DEFAULT_ERROR_MESSAGE});
+    return done(null, null, req.flash(ERROR_KEY, DEFAULT_ERROR_MESSAGE));
   }
 }
 

worklenz-backend/src/public/locales/alb/404-page.json

@@ -0,0 +1,4 @@
+{
+  "doesNotExistText": "Na vjen keq, faqja që kërkoni nuk ekziston.",
+  "backHomeButton": "Kthehu në Faqen Kryesore"
+}

worklenz-backend/src/public/locales/alb/account-setup.json

@@ -0,0 +1,31 @@
+{
+  "continue": "Vazhdo",
+
+  "setupYourAccount": "Konfiguro Llogarinë Tënde në Worklenz.",
+  "organizationStepTitle": "Emërtoni Organizatën Tuaj",
+  "organizationStepLabel": "Zgjidhni një emër për llogarinë tuaj në Worklenz.",
+
+  "projectStepTitle": "Krijoni projektin tuaj të parë",
+  "projectStepLabel": "Në cilin projekt po punoni aktualisht?",
+  "projectStepPlaceholder": "p.sh. Plani i Marketingut",
+
+  "tasksStepTitle": "Krijoni detyrat tuaja të para",
+  "tasksStepLabel": "Shkruani disa detyra që do të kryeni në",
+  "tasksStepAddAnother": "Shto një tjetër",
+
+  "emailPlaceholder": "Adresa email",
+  "invalidEmail": "Ju lutemi vendosni një adresë email të vlefshme",
+  "or": "ose",
+  "templateButton": "Importo nga shablloni",
+  "goBack": "Kthehu Mbrapa",
+  "cancel": "Anulo",
+  "create": "Krijo",
+  "templateDrawerTitle": "Zgjidh nga shabllonet",
+  "step3InputLabel": "Fto me email",
+  "addAnother": "Shto një tjetër",
+  "skipForNow": "Kalo tani për tani",
+  "formTitle": "Krijoni detyrën tuaj të parë.",
+  "step3Title": "Fto ekipin tënd të punojë me",
+  "maxMembers": " (Mund të ftoni deri në 5 anëtarë)",
+  "maxTasks": " (Mund të krijoni deri në 5 detyra)"
+}

worklenz-backend/src/public/locales/alb/admin-center/current-bill.json

@@ -0,0 +1,113 @@
+{
+  "title": "Faturimet",
+  "currentBill": "Fatura Aktuale",
+  "configuration": "Konfigurimi",
+  "currentPlanDetails": "Detajet e Planit Aktual",
+  "upgradePlan": "Përmirëso Planin",
+  "cardBodyText01": "Provë falas",
+  "cardBodyText02": "(Plani juaj i provës skadon në 1 muaj 19 ditë)",
+  "redeemCode": "Kodi i Zbritjes",
+  "accountStorage": "Depozita e Llogarisë",
+  "used": "Përdorur:",
+  "remaining": "E mbetur:",
+  "charges": "Tarifat",
+  "tooltip": "Tarifat për ciklin aktual të faturimit",
+  "description": "Përshkrimi",
+  "billingPeriod": "Periudha e Faturimit",
+  "billStatus": "Statusi i Faturës",
+  "perUserValue": "Vlera për Përdorues",
+  "users": "Përdoruesit",
+
+  "amount": "Shuma",
+  "invoices": "Faturat",
+  "transactionId": "ID e Transaksionit",
+  "transactionDate": "Data e Transaksionit",
+  "paymentMethod": "Metoda e Pagesës",
+  "status": "Statusi",
+  "ltdUsers": "Mund të shtoni deri në {{ltd_users}} përdorues.",
+
+  "totalSeats": "Vende totale",
+  "availableSeats": "Vende të disponueshme",
+  "addMoreSeats": "Shto më shumë vende",
+
+  "drawerTitle": "Kodi i Zbritjes",
+  "label": "Kodi i Zbritjes",
+  "drawerPlaceholder": "Vendosni kodin tuaj të zbritjes",
+  "redeemSubmit": "Paraqit",
+
+  "modalTitle": "Zgjidhni planin më të mirë për ekipin tuaj",
+  "seatLabel": "Numri i vendeve",
+  "freePlan": "Plan Falas",
+  "startup": "Startup",
+  "business": "Biznes",
+  "tag": "Më i Popullarizuar",
+  "enterprise": "Ndërmarrje",
+
+  "freeSubtitle": "falas përgjithmonë",
+  "freeUsers": "Më e mira për përdorim personal",
+  "freeText01": "100MB depozitë",
+  "freeText02": "3 projekte",
+  "freeText03": "5 anëtarë të ekipit",
+
+  "startupSubtitle": "ÇMIM I RASTËSISHËM / muaj",
+  "startupUsers": "Deri në 15 përdorues",
+  "startupText01": "25GB depozitë",
+  "startupText02": "Projekte të pakufizuara aktive",
+  "startupText03": "Orar",
+  "startupText04": "Raportim",
+  "startupText05": "Abonohu në projekte",
+
+  "businessSubtitle": "përdorues / muaj",
+  "businessUsers": "16 - 200 përdorues",
+
+  "enterpriseUsers": "200 - 500+ përdorues",
+
+  "footerTitle": "Ju lutemi na jepni një numër kontakti që mund të përdorim për t'ju kontaktuar.",
+  "footerLabel": "Numri i Kontaktit",
+  "footerButton": "Na kontaktoni",
+
+  "redeemCodePlaceHolder": "Vendosni kodin tuaj të zbritjes",
+  "submit": "Paraqit",
+
+  "trialPlan": "Provë Falas",
+  "trialExpireDate": "E vlefshme deri më {{trial_expire_date}}",
+  "trialExpired": "Provat tuaja falas skaduan {{trial_expire_string}}",
+  "trialInProgress": "Provat tuaja falas skadojnë {{trial_expire_string}}",
+
+  "required": "Kjo fushë është e detyrueshme",
+  "invalidCode": "Kod i pavlefshëm",
+
+  "selectPlan": "Zgjidhni planin më të mirë për ekipin tuaj",
+  "changeSubscriptionPlan": "Ndryshoni planin tuaj të abonimit",
+  "noOfSeats": "Numri i vendeve",
+  "annualPlan": "Pro - Vjetor",
+  "monthlyPlan": "Pro - Mujor",
+  "freeForever": "Falas Përgjithmonë",
+  "bestForPersonalUse": "Më e mira për përdorim personal",
+  "storage": "Depozitë",
+  "projects": "Projekte",
+  "teamMembers": "Anëtarët e Ekipit",
+  "unlimitedTeamMembers": "Anëtarë të pakufizuar të ekipit",
+  "unlimitedActiveProjects": "Projekte të pakufizuara aktive",
+  "schedule": "Orar",
+  "reporting": "Raportim",
+  "subscribeToProjects": "Abonohu në projekte",
+  "billedAnnually": "Faturuar çdo vit",
+  "billedMonthly": "Faturuar çdo muaj",
+
+  "pausePlan": "Pauzë Planin",
+  "resumePlan": "Rifillo Planin",
+  "changePlan": "Ndrysho Planin",
+  "cancelPlan": "Anulo Planin",
+
+  "perMonthPerUser": "për përdorues/muaj",
+  "viewInvoice": "Shiko Faturën",
+  "switchToFreePlan": "Kalo në Planin Falas",
+
+  "expirestoday": "sot",
+  "expirestomorrow": "nesër",
+  "expiredDaysAgo": "{{days}} ditë më parë",
+
+  "continueWith": "Vazhdo me {{plan}}",
+  "changeToPlan": "Ndrysho në {{plan}}"
+}

worklenz-backend/src/public/locales/alb/admin-center/overview.json

@@ -0,0 +1,8 @@
+{
+  "overview": "Përmbledhje",
+  "name": "Emri i Organizatës",
+  "owner": "Pronari i Organizatës",
+  "admins": "Administruesit e Organizatës",
+  "contactNumber": "Shto Numrin e Kontaktit",
+  "edit": "Redakto"
+}

worklenz-backend/src/public/locales/alb/admin-center/projects.json

@@ -0,0 +1,12 @@
+{
+  "membersCount": "Numri i Anëtarëve",
+  "createdAt": "Krijuar më",
+  "projectName": "Emri i Projektit",
+  "teamName": "Emri i Ekipit",
+  "refreshProjects": "Rifresko Projektet",
+  "searchPlaceholder": "Kërkoni sipas emrit të projektit",
+  "deleteProject": "Jeni i sigurt që dëshironi të fshini këtë projekt?",
+  "confirm": "Konfirmo",
+  "cancel": "Anulo",
+  "delete": "Fshi Projektin"
+}

worklenz-backend/src/public/locales/alb/admin-center/sidebar.json

@@ -0,0 +1,8 @@
+{
+  "overview": "Përmbledhje",
+  "users": "Përdoruesit",
+  "teams": "Ekipet",
+  "billing": "Faturimi",
+  "projects": "Projektet",
+  "adminCenter": "Qendra Administrative"
+}

worklenz-backend/src/public/locales/alb/admin-center/teams.json

@@ -0,0 +1,33 @@
+{
+  "title": "Ekipet",
+  "subtitle": "ekipet",
+  "tooltip": "Rifresko ekipet",
+  "placeholder": "Kërko sipas emrit",
+  "addTeam": "Shto Ekip",
+  "team": "Ekipi",
+  "membersCount": "Numri i Anëtarëve",
+  "members": "Anëtarët",
+  "drawerTitle": "Krijo Ekip të Ri",
+  "label": "Emri i Ekipit",
+  "drawerPlaceholder": "Emri",
+  "create": "Krijo",
+  "delete": "Fshi",
+  "settings": "Cilësimet",
+  "popTitle": "Jeni i sigurt?",
+  "message": "Ju lutemi shkruani një Emër",
+  "teamSettings": "Cilësimet e Ekipit",
+  "teamName": "Emri i Ekipit",
+  "teamDescription": "Përshkrimi i Ekipit",
+  "teamMembers": "Anëtarët e Ekipit",
+  "teamMembersCount": "Numri i Anëtarëve të Ekipit",
+  "teamMembersPlaceholder": "Kërko sipas emrit",
+  "addMember": "Shto Anëtar",
+  "add": "Shto",
+  "update": "Përditëso",
+  "teamNamePlaceholder": "Emri i ekipit",
+  "user": "Përdoruesi",
+  "role": "Roli",
+  "owner": "Pronari",
+  "admin": "Administruesi",
+  "member": "Anëtari"
+}

worklenz-backend/src/public/locales/alb/admin-center/users.json

@@ -0,0 +1,9 @@
+{
+  "title": "Përdoruesit",
+  "subTitle": "përdoruesit",
+  "placeholder": "Kërko sipas emrit",
+  "user": "Përdoruesi",
+  "email": "Email",
+  "lastActivity": "Aktiviteti i Fundit",
+  "refresh": "Rifresko përdoruesit"
+}

worklenz-backend/src/public/locales/alb/all-project-list.json

@@ -0,0 +1,34 @@
+{
+  "name": "Emri",
+  "client": "Klienti",
+  "category": "Kategoria",
+  "status": "Statusi",
+  "tasksProgress": "Përparimi i Detyrave",
+  "updated_at": "E Përditësuar së Fundi",
+  "members": "Anëtarët",
+  "setting": "Cilësimet",
+  "projects": "Projektet",
+  "refreshProjects": "Rifresko projektet",
+  "all": "Të gjitha",
+  "favorites": "Të preferuarit",
+  "archived": "E arkivuar",
+  "placeholder": "Kërko sipas emrit",
+  "archive": "Arkivo",
+  "unarchive": "Çarkivo",
+  "archiveConfirm": "Jeni i sigurt që dëshironi të arkivoni këtë projekt?",
+  "unarchiveConfirm": "Jeni i sigurt që dëshironi të çarkivoni këtë projekt?",
+  "yes": "Po",
+  "no": "Jo",
+  "clickToFilter": "Kliko për të filtruar sipas",
+  "noProjects": "Nuk u gjetën projekte",
+  "addToFavourites": "Shto te të preferuarit",
+  "list": "Lista",
+  "group": "Grupi",
+  "listView": "Pamja e Listës",
+  "groupView": "Pamja e Grupit",
+  "groupBy": {
+    "category": "Kategoria",
+    "client": "Klienti"
+  },
+  "noPermission": "Nuk keni leje për të kryer këtë veprim"
+}

worklenz-backend/src/public/locales/alb/auth/auth-common.json

@@ -0,0 +1,5 @@
+{
+  "loggingOut": "Po dilni...",
+  "authenticating": "Po autentikoheni...",
+  "gettingThingsReady": "Po përgatiten gjërat për ju..."
+}

worklenz-backend/src/public/locales/alb/auth/forgot-password.json

@@ -0,0 +1,12 @@
+{
+  "headerDescription": "Rivendosni fjalëkalimin tuaj",
+  "emailLabel": "Email",
+  "emailPlaceholder": "Vendosni email-in tuaj",
+  "emailRequired": "Ju lutemi vendosni Email-in tuaj!",
+  "resetPasswordButton": "Rivendos Fjalëkalimin",
+  "returnToLoginButton": "Kthehu te Hyrja",
+  "passwordResetSuccessMessage": "Një lidhje për rivendosjen e fjalëkalimit është dërguar në email-in tuaj.",
+  "orText": "OSE",
+  "successTitle": "U dërguan udhëzimet për rivendosje!",
+  "successMessage": "Informacioni për rivendosje është dërguar në email-in tuaj. Ju lutemi kontrolloni email-in."
+}

worklenz-backend/src/public/locales/alb/auth/login.json

@@ -0,0 +1,27 @@
+{
+  "headerDescription": "Hyni në llogarinë tuaj",
+  "emailLabel": "Email",
+  "emailPlaceholder": "Vendosni email-in tuaj",
+  "emailRequired": "Ju lutemi vendosni Email-in tuaj!",
+  "passwordLabel": "Fjalëkalimi",
+  "passwordPlaceholder": "Vendosni fjalëkalimin",
+  "passwordRequired": "Ju lutemi vendosni Fjalëkalimin!",
+  "rememberMe": "Më mbaj mend",
+  "loginButton": "Hyr",
+  "signupButton": "Regjistrohu",
+  "forgotPasswordButton": "Keni harruar fjalëkalimin?",
+  "signInWithGoogleButton": "Hyr me Google",
+  "dontHaveAccountText": "Nuk keni llogari?",
+  "orText": "OSE",
+  "successMessage": "Jeni futur me sukses!",
+  "loginError": "Hyrja dështoi",
+  "googleLoginError": "Hyrja përmes Google dështoi",
+  "validationMessages": {
+    "email": "Ju lutemi vendosni një adresë email të vlefshme",
+    "password": "Fjalëkalimi duhet të jetë së paku 8 karaktere"
+  },
+  "errorMessages": {
+    "loginErrorTitle": "Hyrja dështoi",
+    "loginErrorMessage": "Ju lutemi kontrolloni email-in dhe fjalëkalimin dhe provoni përsëri"
+  }
+}

worklenz-backend/src/public/locales/alb/auth/signup.json

@@ -0,0 +1,29 @@
+{
+  "headerDescription": "Regjistrohuni për të filluar",
+  "nameLabel": "Emri i Plotë",
+  "namePlaceholder": "Shkruani emrin tuaj të plotë",
+  "nameRequired": "Ju lutemi shkruani emrin tuaj të plotë!",
+  "nameMinCharacterRequired": "Emri duhet të jetë së paku 4 karaktere!",
+  "emailLabel": "Email",
+  "emailPlaceholder": "Shkruani email-in tuaj",
+  "emailRequired": "Ju lutemi shkruani Email-in tuaj!",
+  "passwordLabel": "Fjalëkalimi",
+  "passwordPlaceholder": "Krijoni një fjalëkalim",
+  "passwordRequired": "Ju lutemi krijoni një Fjalëkalim!",
+  "passwordMinCharacterRequired": "Fjalëkalimi duhet të jetë së paku 8 karaktere!",
+  "passwordPatternRequired": "Fjalëkalimi nuk plotëson kërkesat!",
+  "strongPasswordPlaceholder": "Vendosni një fjalëkalim më të fortë",
+  "passwordValidationAltText": "Fjalëkalimi duhet të përmbajë së paku 8 karaktere me shkronja të mëdha dhe të vogla, një numër dhe një simbol.",
+  "signupSuccessMessage": "Jeni regjistruar me sukses!",
+  "privacyPolicyLink": "Politika e Privatësisë",
+  "termsOfUseLink": "Kushtet e Përdorimit",
+  "bySigningUpText": "Duke u regjistruar, ju pranoni",
+  "andText": "dhe",
+  "signupButton": "Regjistrohu",
+  "signInWithGoogleButton": "Hyr me Google",
+  "alreadyHaveAccountText": "Keni tashmë një llogari?",
+  "loginButton": "Hyr",
+  "orText": "OSE",
+  "reCAPTCHAVerificationError": "Gabim në Verifikimin e reCAPTCHA",
+  "reCAPTCHAVerificationErrorMessage": "Nuk mundëm të verifikojmë reCAPTCHA-n tuaj. Ju lutemi provoni përsëri."
+}

worklenz-backend/src/public/locales/alb/auth/verify-reset-email.json

@@ -0,0 +1,14 @@
+{
+  "title": "Verifikoni Email-in për Rivendosje",
+  "description": "Vendosni fjalëkalimin tuaj të ri",
+  "placeholder": "Vendosni fjalëkalimin tuaj të ri",
+  "confirmPasswordPlaceholder": "Konfirmoni fjalëkalimin e ri",
+  "passwordHint": "Të paktën 8 karaktere, me shkronja të mëdha dhe të vogla, një numër dhe një simbol.",
+  "resetPasswordButton": "Rivendos fjalëkalimin",
+  "orText": "Ose",
+  "resendResetEmail": "Dërgo përsëri email-in e rivendosjes",
+  "passwordRequired": "Ju lutemi vendosni fjalëkalimin e ri",
+  "returnToLoginButton": "Kthehu te Hyrja",
+  "confirmPasswordRequired": "Ju lutemi konfirmoni fjalëkalimin e ri",
+  "passwordMismatch": "Fjalëkalimet nuk përputhen"
+}

worklenz-backend/src/public/locales/alb/common.json

@@ -0,0 +1,9 @@
+{
+  "login-success": "Hyrja u krye me sukses!",
+  "login-failed": "Hyrja dështoi. Ju lutemi kontrolloni kredencialet dhe provoni përsëri.",
+  "signup-success": "Regjistrimi u krye me sukses! Mirë se erdhët.",
+  "signup-failed": "Regjistrimi dështoi. Ju lutemi sigurohuni që të gjitha fushat e nevojshme janë plotësuar dhe provoni përsëri.",
+  "reconnecting": "Jeni shkëputur nga serveri.",
+  "connection-lost": "Lidhja me serverin dështoi. Ju lutemi kontrolloni lidhjen tuaj me internet.",
+  "connection-restored": "U lidhët me serverin me sukses"
+}

worklenz-backend/src/public/locales/alb/create-first-project-form.json

@@ -0,0 +1,13 @@
+{
+  "formTitle": "Krijoni projektin tuaj të parë",
+  "inputLabel": "Në cilin projekt po punoni aktualisht?",
+  "or": "ose",
+  "templateButton": "Importo nga shablloni",
+  "createFromTemplate": "Krijo nga shablloni",
+  "goBack": "Kthehu Mbrapa",
+  "continue": "Vazhdo",
+  "cancel": "Anulo",
+  "create": "Krijo",
+  "templateDrawerTitle": "Zgjidh nga shabllonet",
+  "createProject": "Krijo Projekt"
+}

worklenz-backend/src/public/locales/alb/create-first-tasks.json

@@ -0,0 +1,7 @@
+{
+  "formTitle": "Krijo detyrën tënde të parë.",
+  "inputLabel": "Shkruaj disa detyra që do të kryesh në",
+  "addAnother": "Shto një tjetër",
+  "goBack": "Kthehu mbrapa",
+  "continue": "Vazhdo"
+}

worklenz-backend/src/public/locales/alb/home.json

@@ -0,0 +1,46 @@
+{
+  "todoList": {
+    "title": "Lista e Detyrave",
+    "refreshTasks": "Rifresko detyrat",
+    "addTask": "+ Shto Detyrë",
+    "noTasks": "Asnjë detyrë",
+    "pressEnter": "Shtyp",
+    "toCreate": "për të krijuar.",
+    "markAsDone": "Shëno si të përfunduar"
+  },
+  "projects": {
+    "title": "Projektet",
+    "refreshProjects": "Rifresko projektet",
+    "noRecentProjects": "Aktualisht nuk jeni caktuar në asnjë projekt.",
+    "noFavouriteProjects": "Asnjë projekt i shënuar si i preferuar.",
+    "recent": "Të Fundit",
+    "favourites": "Të Preferuarat"
+  },
+  "tasks": {
+    "assignedToMe": "Më janë caktuar",
+    "assignedByMe": "I kam caktuar",
+    "all": "Të Gjitha",
+    "today": "Sot",
+    "upcoming": "Ardhj",
+    "overdue": "Të vonuara",
+    "noDueDate": "Pa afat",
+    "noTasks": "Asnjë detyrë për të shfaqur.",
+    "addTask": "+ Shto detyrë",
+    "name": "Emri",
+    "project": "Projekti",
+    "status": "Statusi",
+    "dueDate": "Afati",
+    "dueDatePlaceholder": "Cakto Afatin",
+    "tomorrow": "Nesër",
+    "nextWeek": "Javën e Ardhshme",
+    "nextMonth": "Muajin e Ardhshëm",
+    "projectRequired": "Ju lutemi zgjidhni një projekt",
+    "pressTabToSelectDueDateAndProject": "Shtyp Tab për të zgjedhur afatin dhe projektin",
+    "dueOn": "Detyrat me afat më",
+    "taskRequired": "Ju lutemi shtoni një detyrë",
+    "list": "Listë",
+    "calendar": "Kalendar",
+    "tasks": "Detyrat",
+    "refresh": "Rifresko"
+  }
+}

worklenz-backend/src/public/locales/alb/invite-initial-team-members.json

@@ -0,0 +1,8 @@
+{
+  "formTitle": "Fto ekipin tënd të punojë me",
+  "inputLabel": "Fto me email",
+  "addAnother": "Shto një tjetër",
+  "goBack": "Kthehu mbrapa",
+  "continue": "Vazhdo",
+  "skipForNow": "Anashkalo tani për tani"
+}

worklenz-backend/src/public/locales/alb/kanban-board.json

@@ -0,0 +1,30 @@
+{
+  "rename": "Riemërto",
+  "delete": "Fshi",
+  "addTask": "Shto Detyrë",
+  "addSectionButton": "Shto Seksion",
+  "changeCategory": "Ndrysho kategorinë",
+
+  "deleteTooltip": "Fshi",
+  "deleteConfirmationTitle": "Jeni i sigurt?",
+  "deleteConfirmationOk": "Po",
+  "deleteConfirmationCancel": "Anulo",
+
+  "dueDate": "Data e përfundimit",
+  "cancel": "Anulo",
+
+  "today": "Sot",
+  "tomorrow": "Nesër",
+  "assignToMe": "Cakto mua",
+  "archive": "Arkivo",
+
+  "newTaskNamePlaceholder": "Shkruaj emrin e detyrës",
+  "newSubtaskNamePlaceholder": "Shkruaj emrin e nëndetyrës",
+  "untitledSection": "Seksion pa titull",
+  "unmapped": "Pa hartë",
+  "clickToChangeDate": "Klikoni për të ndryshuar datën",
+  "noDueDate": "Pa datë përfundimi",
+  "save": "Ruaj",
+  "clear": "Pastro",
+  "nextWeek": "Javën e ardhshme"
+}

worklenz-backend/src/public/locales/alb/license-expired.json

@@ -0,0 +1,6 @@
+{
+  "title": "Prova juaj e Worklenz ka skaduar!",
+  "subtitle": "Ju lutemi përmirësoni tani.",
+  "button": "Përmirëso tani",
+  "checking": "Po kontrollohet statusi i abonimit..."
+}

worklenz-backend/src/public/locales/alb/navbar.json

@@ -0,0 +1,31 @@
+{
+  "logoAlt": "Logoja e Worklenz",
+  "home": "Kryefaqja",
+  "projects": "Projektet",
+  "schedule": "Orari",
+  "reporting": "Raportimi",
+  "clients": "Klientët",
+  "teams": "Ekipet",
+  "labels": "Etiketa",
+  "jobTitles": "Tituj Pune",
+  "upgradePlan": "Përmirëso Abonimin",
+  "upgradePlanTooltip": "Përmirëso abonimin",
+  "invite": "Fto",
+  "inviteTooltip": "Fto anëtarë të ekipit të bashkohen",
+  "switchTeamTooltip": "Ndrysho ekipin",
+  "help": "Ndihmë",
+  "notificationTooltip": "Shiko njoftimet",
+  "profileTooltip": "Shiko profilin",
+  "adminCenter": "Qendra Administrative",
+  "settings": "Cilësimet",
+  "logOut": "Dil",
+  "notificationsDrawer": {
+    "read": "Lexuara e njoftimet ",
+    "unread": "Njoftimet e palexuara",
+    "markAsRead": "Shëno si të lexuara",
+    "readAndJoin": "Lexo & Bashkohu",
+    "accept": "Prano",
+    "acceptAndJoin": "Prano & Bashkohu",
+    "noNotifications": "Asnjë njoftim"
+  }
+}

worklenz-backend/src/public/locales/alb/organization-name-form.json

@@ -0,0 +1,5 @@
+{
+  "nameYourOrganization": "Emërtoni organizatën tuaj.",
+  "worklenzAccountTitle": "Zgjidhni një emër për llogarinë tuaj në Worklenz.",
+  "continue": "Vazhdo"
+}

worklenz-backend/src/public/locales/alb/phases-drawer.json

@@ -0,0 +1,19 @@
+{
+  "configurePhases": "Konfiguro Fazat",
+  "phaseLabel": "Etiketa e Fazës",
+  "enterPhaseName": "Vendosni një emër për etiketën e fazës",
+  "addOption": "Shto Opsion",
+  "phaseOptions": "Opsionet e Fazës:",
+  "dragToReorderPhases": "Zvarrit fazat për t'i rirenditur. Çdo fazë mund të ketë një ngjyrë të ndryshme.",
+  "enterNewPhaseName": "Shkruani emrin e fazës së re...",
+  "addPhase": "Shto Fazë",
+  "noPhasesFound": "Nuk u gjetën faza. Krijoni fazën tuaj të parë më sipër.",
+  "deletePhase": "Fshi Fazën",
+  "deletePhaseConfirm": "Jeni të sigurt që doni të fshini këtë fazë? Ky veprim nuk mund të zhbëhet.",
+  "rename": "Riemëro",
+  "delete": "Fshi",
+  "enterPhaseName": "Shkruani emrin e fazës",
+  "selectColor": "Zgjidh ngjyrën",
+  "managePhases": "Menaxho Fazat",
+  "close": "Mbyll"
+}

worklenz-backend/src/public/locales/alb/project-drawer.json

@@ -0,0 +1,42 @@
+{
+  "createProject": "Krijo Projekt",
+  "editProject": "Modifiko Projektin",
+  "enterCategoryName": "Vendosni emër për kategorinë",
+  "hitEnterToCreate": "Shtyp Enter për të krijuar!",
+  "enterNotes": "Shënime",
+  "youCanManageClientsUnderSettings": "Mund të menaxhoni klientët nën Cilësimet",
+  "addCategory": "Shto kategori projektit",
+  "newCategory": "Kategori e Re",
+  "notes": "Shënime",
+  "startDate": "Data e Fillimit",
+  "endDate": "Data e Përfundimit",
+  "estimateWorkingDays": "Vlerëso ditët e punës",
+  "estimateManDays": "Vlerëso ditët e punëtorëve",
+  "hoursPerDay": "Orë në ditë",
+  "create": "Krijo",
+  "update": "Përditëso",
+  "delete": "Fshi",
+  "typeToSearchClients": "Shkruani për të kërkuar klientë",
+  "projectColor": "Ngjyra e Projektit",
+  "pleaseEnterAName": "Ju lutemi vendosni një emër",
+  "enterProjectName": "Vendosni emrin e projektit",
+  "name": "Emri",
+  "status": "Statusi",
+  "health": "Gjendja",
+  "category": "Kategoria",
+  "projectManager": "Menaxheri i Projektit",
+  "client": "Klienti",
+  "deleteConfirmation": "Jeni i sigurt që doni të fshini?",
+  "deleteConfirmationDescription": "Kjo do të fshijë të gjitha të dhënat e lidhura dhe nuk mund të zhbëhet.",
+  "yes": "Po",
+  "no": "Jo",
+  "createdAt": "Krijuar më",
+  "updatedAt": "Përditësuar më",
+  "by": "nga",
+  "add": "Shto",
+  "asClient": "si klient",
+  "createClient": "Krijo klient",
+  "searchInputPlaceholder": "Kërko sipas emrit ose emailit",
+  "hoursPerDayValidationMessage": "Orët në ditë duhet të jenë një numër midis 1 dhe 24",
+  "noPermission": "Nuk ka leje"
+}

worklenz-backend/src/public/locales/alb/project-view-files.json

@@ -0,0 +1,14 @@
+{
+  "nameColumn": "Emri",
+  "attachedTaskColumn": "Detyra e Bashkangjitur",
+  "sizeColumn": "Madhësia",
+  "uploadedByColumn": "Ngarkuar Nga",
+  "uploadedAtColumn": "Ngarkuar Më",
+  "fileIconAlt": "Ikona e skedarit",
+  "titleDescriptionText": "Të gjitha bashkëngjitjet e detyrave në këtë projekt do të shfahen këtu.",
+  "deleteConfirmationTitle": "Jeni i sigurt?",
+  "deleteConfirmationOk": "Po",
+  "deleteConfirmationCancel": "Anulo",
+  "segmentedTooltip": "Së shpejti! Kaloni midis pamjes listë dhe pamjes miniaturash.",
+  "emptyText": "Nuk ka bashkëngjitje në projekt."
+}

worklenz-backend/src/public/locales/alb/project-view-insights.json

@@ -0,0 +1,41 @@
+{
+  "overview": {
+    "title": "Përmbledhje",
+    "statusOverview": "Përmbledhje Statusi",
+    "priorityOverview": "Përmbledhje Prioriteti",
+    "lastUpdatedTasks": "Detyrat e Përditësuara Së Fundi"
+  },
+  "members": {
+    "title": "Anëtarët",
+    "tooltip": "Anëtarët",
+    "tasksByMembers": "Detyrat sipas anëtarëve",
+    "tasksByMembersTooltip": "Detyrat sipas anëtarëve",
+    "name": "Emri",
+    "taskCount": "Numri i Detyrave",
+    "contribution": "Kontributi",
+    "completed": "Të Përfunduara",
+    "incomplete": "Të Papërfunduara",
+    "overdue": "Të Vonuara",
+    "progress": "Progresi"
+  },
+  "tasks": {
+    "overdueTasks": "Detyrat e Vonuara",
+    "overLoggedTasks": "Detyrat me regjistrim të tepërt",
+    "tasksCompletedEarly": "Detyrat e përfunduara para afatit",
+    "tasksCompletedLate": "Detyrat e përfunduara pas afatit",
+    "overLoggedTasksTooltip": "Detyrat me kohë të regjistruar mbi kohën e vlerësuar",
+    "overdueTasksTooltip": "Detyrat që kanë kaluar afatin e tyre"
+  },
+  "common": {
+    "seeAll": "Shiko të gjitha",
+    "totalLoggedHours": "Orët totale të regjistruara",
+    "totalEstimation": "Vlerësimi total",
+    "completedTasks": "Detyrat e përfunduara",
+    "incompleteTasks": "Detyrat e papërfunduara",
+    "overdueTasks": "Detyrat e vonuara",
+    "overdueTasksTooltip": "Detyrat që kanë kaluar afatin e tyre",
+    "totalLoggedHoursTooltip": "Vlerësimi dhe koha e regjistruar për detyrat.",
+    "includeArchivedTasks": "Përfshi Detyrat e Arkivuara",
+    "export": "Eksporto"
+  }
+}

worklenz-backend/src/public/locales/alb/project-view-members.json

@@ -0,0 +1,17 @@
+{
+  "nameColumn": "Emri",
+  "jobTitleColumn": "Titulli i Punës",
+  "emailColumn": "Email",
+  "tasksColumn": "Detyrat",
+  "taskProgressColumn": "Progresi i Detyrave",
+  "accessColumn": "Qasja",
+  "fileIconAlt": "Ikona e skedarit",
+  "deleteConfirmationTitle": "Jeni i sigurt?",
+  "deleteConfirmationOk": "Po",
+  "deleteConfirmationCancel": "Anulo",
+  "refreshButtonTooltip": "Rifresko anëtarët",
+  "deleteButtonTooltip": "Hiq nga projekti",
+  "memberCount": "Anëtar",
+  "membersCountPlural": "Anëtarë",
+  "emptyText": "Nuk ka bashkëngjitje në projekt."
+}

worklenz-backend/src/public/locales/alb/project-view-updates.json

@@ -0,0 +1,6 @@
+{
+  "inputPlaceholder": "Shto një koment..",
+  "addButton": "Shto",
+  "cancelButton": "Anulo",
+  "deleteButton": "Fshi"
+}

worklenz-backend/src/public/locales/alb/project-view.json

@@ -0,0 +1,14 @@
+{
+  "taskList": "Lista e Detyrave",
+  "board": "Tabela Kanban",
+  "insights": "Analiza",
+  "files": "Skedarë",
+  "members": "Anëtarë",
+  "updates": "Përditësime",
+  "projectView": "Pamja e Projektit",
+  "loading": "Duke ngarkuar projektin...",
+  "error": "Gabim në ngarkimin e projektit",
+  "pinnedTab": "E fiksuar si tab i parazgjedhur",
+  "pinTab": "Fikso si tab i parazgjedhur",
+  "unpinTab": "Hiqe fiksimin e tab-it të parazgjedhur"
+} 

worklenz-backend/src/public/locales/alb/project-view/import-task-templates.json

@@ -0,0 +1,11 @@
+{
+  "importTaskTemplate": "Importo Shabllon Detyrash",
+  "templateName": "Emri i Shabllonit",
+  "templateDescription": "Përshkrimi i Shabllonit",
+  "selectedTasks": "Detyrat e Përzgjedhura",
+  "tasks": "Detyrat",
+  "templates": "Shabllonet",
+  "remove": "Hiq",
+  "cancel": "Anulo",
+  "import": "Importo"
+}

worklenz-backend/src/public/locales/alb/project-view/project-member-drawer.json

@@ -0,0 +1,7 @@
+{
+  "title": "Anëtarët e Projektit",
+  "searchLabel": "Shtoni anëtarë duke shkruar emrin ose email-in e tyre",
+  "searchPlaceholder": "Shkruani emrin ose email-in",
+  "inviteAsAMember": "Fto si anëtar",
+  "inviteNewMemberByEmail": "Fto anëtar të ri me email"
+}

worklenz-backend/src/public/locales/alb/project-view/project-view-header.json

@@ -0,0 +1,30 @@
+{
+  "importTasks": "Importo detyra",
+  "importTask": "Importo detyrë",
+  "createTask": "Krijo detyrë",
+  "settings": "Cilësimet",
+  "subscribe": "Abonohu",
+  "unsubscribe": "Çabonohu",
+  "deleteProject": "Fshi projektin",
+  "startDate": "Data e fillimit",
+  "endDate": "Data e mbarimit",
+  "projectSettings": "Cilësimet e projektit",
+  "projectSummary": "Përmbledhja e projektit",
+  "receiveProjectSummary": "Merrni një përmbledhje të projektit çdo mbrëmje.",
+  "refreshProject": "Rifresko projektin",
+  "saveAsTemplate": "Ruaj si model",
+  "invite": "Fto",
+  "share": "Ndaj",
+  "subscribeTooltip": "Abonohu tek njoftimet e projektit",
+  "unsubscribeTooltip": "Çabonohu nga njoftimet e projektit",
+  "refreshTooltip": "Rifresko të dhënat e projektit",
+  "settingsTooltip": "Hap cilësimet e projektit",
+  "saveAsTemplateTooltip": "Ruaj këtë projekt si model",
+  "inviteTooltip": "Fto anëtarë të ekipit në këtë projekt",
+  "createTaskTooltip": "Krijo një detyrë të re",
+  "importTaskTooltip": "Importo detyrë nga modeli",
+  "navigateBackTooltip": "Kthehu tek lista e projekteve",
+  "projectStatusTooltip": "Statusi i projektit",
+  "projectDatesInfo": "Informacion për kohëzgjatjen e projektit",
+  "projectCategoryTooltip": "Kategoria e projektit"
+}

worklenz-backend/src/public/locales/alb/project-view/save-as-template.json

@@ -0,0 +1,27 @@
+{
+  "title": "Ruaj si Shabllon",
+  "templateName": "Emri i Shabllonit",
+  "includes": "Çfarë duhet të përfshihet në shabllon nga projekti?",
+  "includesOptions": {
+    "statuses": "Statuset",
+    "phases": "Fazat",
+    "labels": "Etiketat"
+  },
+  "taskIncludes": "Çfarë duhet të përfshihet në shabllon nga detyrat?",
+  "taskIncludesOptions": {
+    "statuses": "Statuset",
+    "phases": "Fazat",
+    "labels": "Etiketat",
+    "name": "Emri",
+    "priority": "Prioriteti",
+    "status": "Statusi",
+    "phase": "Faza",
+    "label": "Etiketa",
+    "timeEstimate": "Vlerësimi i Kohës",
+    "description": "Përshkrimi",
+    "subTasks": "Nëndetyrat"
+  },
+  "cancel": "Anulo",
+  "save": "Ruaj",
+  "templateNamePlaceholder": "Shkruani emrin e shabllonit"
+}

worklenz-backend/src/public/locales/alb/reporting-members-drawer.json

@@ -0,0 +1,90 @@
+{
+  "exportButton": "Eksporto",
+  "timeLogsButton": "Regjistrimet e Kohës",
+  "activityLogsButton": "Regjistrimet e Aktivitetit",
+  "tasksButton": "Detyrat",
+  "searchByNameInputPlaceholder": "Kërko sipas emrit",
+
+  "overviewTab": "Përmbledhje",
+  "timeLogsTab": "Regjistrimet e Kohës",
+  "activityLogsTab": "Regjistrimet e Aktivitetit",
+  "tasksTab": "Detyrat",
+
+  "projectsText": "Projektet",
+  "totalTasksText": "Detyrat Gjithsej",
+  "assignedTasksText": "Detyrat e Caktuara",
+  "completedTasksText": "Detyrat e Përfunduara",
+  "ongoingTasksText": "Detyrat në Vazhdim",
+  "overdueTasksText": "Detyrat e Vonuara",
+  "loggedHoursText": "Orët e Regjistruara",
+
+  "tasksText": "Detyrat",
+  "allText": "Të Gjitha",
+
+  "tasksByProjectsText": "Detyrat Sipas Projekteve",
+  "tasksByStatusText": "Detyrat Sipas Statusit",
+  "tasksByPriorityText": "Detyrat Sipas Prioritetit",
+
+  "todoText": "Për Të Bërë",
+  "doingText": "Duke bërë",
+  "doneText": "E Përfunduar",
+  "lowText": "I Ulët",
+  "mediumText": "I Mesëm",
+  "highText": "I Lartë",
+
+  "billableButton": "Fakturueshme",
+  "billableText": "Fakturueshme",
+  "nonBillableText": "Jo Fakturueshme",
+
+  "timeLogsEmptyPlaceholder": "Asnjë regjistrim kohe për të shfaqur",
+  "loggedText": "Regjistruar",
+  "forText": "për",
+  "inText": "në",
+  "updatedText": "Përditësuar",
+  "fromText": "Nga",
+  "toText": "në",
+  "withinText": "brenda",
+
+  "activityLogsEmptyPlaceholder": "Asnjë regjistrim aktiviteti për të shfaqur",
+
+  "filterByText": "Filtro sipas:",
+  "selectProjectPlaceholder": "Zgjidh Projektin",
+
+  "taskColumn": "Detyra",
+  "nameColumn": "Emri",
+  "projectColumn": "Projekti",
+  "statusColumn": "Statusi",
+  "priorityColumn": "Prioriteti",
+  "dueDateColumn": "Afati",
+  "completedDateColumn": "Data e Përfundimit",
+  "estimatedTimeColumn": "Koha e Vlerësuar",
+  "loggedTimeColumn": "Koha e Regjistruar",
+  "overloggedTimeColumn": "Koha e Tepërt",
+  "daysLeftColumn": "Ditë të Mbetura/Vonuar",
+  "startDateColumn": "Data e Fillimit",
+  "endDateColumn": "Data e Përfundimit",
+  "actualTimeColumn": "Koha Aktuale",
+  "projectHealthColumn": "Gjendja e Projektit",
+  "categoryColumn": "Kategoria",
+  "projectManagerColumn": "Menaxheri i Projektit",
+
+  "tasksStatsOverviewDrawerTitle": "Detyrat e ",
+  "projectsStatsOverviewDrawerTitle": "Projektet e ",
+
+  "cancelledText": "Anuluar",
+  "blockedText": "E Bllokuar",
+  "onHoldText": "Në Pritje",
+  "proposedText": "E Propozuar",
+  "inPlanningText": "Në Planifikim",
+  "inProgressText": "Në Progres",
+  "completedText": "E Përfunduar",
+  "continuousText": "E Vazhdueshme",
+
+  "daysLeftText": "ditë të mbetura",
+  "daysOverdueText": "ditë vonuar",
+
+  "notSetText": "Pa Caktuar",
+  "needsAttentionText": "Kërkon Vëmendje",
+  "atRiskText": "Në Rrezik",
+  "goodText": "Në Rregull"
+}