Merge pull request #265 from Worklenz/development

Development

README.md

@@ -6,6 +6,24 @@
     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)
+The fastest way to get Worklenz running locally with all dependencies included.
-- PostgreSQL database
-- An S3-compatible storage service (like MinIO) or Azure Blob Storage
 
-### 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
+2. Start the Docker containers:
-   - 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
 ```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:
+For local development, follow the [Quick Start (Docker)](#-quick-start-docker---recommended) section above.
-- Frontend React application
-- Backend server
-- PostgreSQL database
-- MinIO for S3-compatible storage
 
-1. Clone the repository:
+### Remote Server Deployment
-```bash
-git clone https://github.com/Worklenz/worklenz.git
-cd worklenz
-```
 
-2. Start the Docker containers (choose one option):
+When deploying to a remote server:
 
-**Using Docker Compose directly**
+1. Set up the environment files with your server's hostname:
-```bash
+   ```bash
-docker-compose up -d
+   # For HTTP/WS
-```
+   ./update-docker-env.sh your-server-hostname
    
-3. The application will be available at:
+   # For HTTPS/WSS
-   - Frontend: http://localhost:5000
+   ./update-docker-env.sh your-server-hostname true
-   - Backend API: http://localhost:3000
+   ```
-   - MinIO Console: http://localhost:9001 (login with minioadmin/minioadmin)
 
-4. To stop the services:
+2. Pull and run the latest Docker images:
-```bash
+   ```bash
-docker-compose down
+   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
+
+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,215 +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
+We welcome contributions from the community! If you'd like to contribute, please follow our [contributing guidelines](CONTRIBUTING.md).
-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)
-
-4. 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).
-
-### 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
-
-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).
-
-### 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:
+      - backend
-        condition: service_started
+    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
+        source: ./worklenz-backend/database/sql
-        target: /docker-entrypoint-initdb.d
+        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
+        bash -c '
-        apt-get update && apt-get install -y dos2unix
+          if command -v apt-get >/dev/null 2>&1; then
-      elif command -v apk >/dev/null 2>&1; then
+            apt-get update && apt-get install -y dos2unix
-        apk add --no-cache dos2unix
+          elif command -v apk >/dev/null 2>&1; then
-      fi && find /docker-entrypoint-initdb.d -type f -name "*.sh" -exec sh -c '\''
+            apk add --no-cache dos2unix
-        dos2unix "{}" 2>/dev/null || true
+          fi
-        chmod +x "{}"
+
-      '\'' \; && exec docker-entrypoint.sh postgres '
+          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/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": {}
+}

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
+# --- Stage 1: Build ---
-FROM node:20
+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
+RUN echo "$RELEASE_VERSION" > release
-EXPOSE 3000
+
+# --- 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-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/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/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/sql/1_tables.sql

@@ -12,7 +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');
+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;

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

@@ -4325,6 +4325,7 @@ DECLARE
     _from_group UUID;
     _to_group   UUID;
     _group_by   TEXT;
+    _batch_size INT := 100; -- PERFORMANCE OPTIMIZATION: Batch size for large updates
 BEGIN
     _project_id = (_body ->> 'project_id')::UUID;
     _task_id = (_body ->> 'task_id')::UUID;
@@ -4337,16 +4338,26 @@ BEGIN
 
     _group_by = (_body ->> 'group_by')::TEXT;
 
+    -- PERFORMANCE OPTIMIZATION: Use CTE for better query planning
     IF (_from_group <> _to_group OR (_from_group <> _to_group) IS NULL)
     THEN
+        -- PERFORMANCE OPTIMIZATION: Batch update group changes
         IF (_group_by = 'status')
         THEN
-            UPDATE tasks SET status_id = _to_group WHERE id = _task_id AND status_id = _from_group;
+            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;
+            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')
@@ -4365,14 +4376,15 @@ BEGIN
             END IF;
         END IF;
 
+        -- PERFORMANCE OPTIMIZATION: Optimized sort order handling
         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);
+            PERFORM handle_task_list_sort_inside_group_optimized(_from_index, _to_index, _task_id, _project_id, _batch_size);
         ELSE
-            PERFORM handle_task_list_sort_between_groups(_from_index, _to_index, _task_id, _project_id);
+            PERFORM handle_task_list_sort_between_groups_optimized(_from_index, _to_index, _task_id, _project_id, _batch_size);
         END IF;
     ELSE
-        PERFORM handle_task_list_sort_inside_group(_from_index, _to_index, _task_id, _project_id);
+        PERFORM handle_task_list_sort_inside_group_optimized(_from_index, _to_index, _task_id, _project_id, _batch_size);
     END IF;
 END
 $$;
@@ -5485,8 +5497,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
@@ -5495,6 +5514,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
 $$;
@@ -6372,3 +6414,144 @@ BEGIN
     );
 END;
 $$;
+
+-- 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
+$$;
+
+-- Simple function to update task sort orders in bulk
+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/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",
@@ -85,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",
@@ -93,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": {
@@ -102,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/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/projects-controller.ts

@@ -756,4 +756,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/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/tasks-controller-base.ts

@@ -50,11 +50,16 @@ export default class TasksControllerBase extends WorklenzControllerBase {
       task.progress = parseInt(task.progress_value);
       task.complete_ratio = parseInt(task.progress_value);
     }
-    // For tasks with no subtasks and no manual progress, calculate based on time
+    // For tasks with no subtasks and no manual progress
     else {
-      task.progress = task.total_minutes_spent && task.total_minutes
+      // Only calculate progress based on time if time-based progress is enabled for the project
-        ? ~~(task.total_minutes_spent / task.total_minutes * 100)
+      if (task.project_use_time_progress && task.total_minutes_spent && task.total_minutes) {
-        : 0;
+        // Cap the progress at 100% to prevent showing more than 100% progress
+        task.progress = Math.min(~~(task.total_minutes_spent / task.total_minutes * 100), 100);
+      } else {
+        // Default to 0% progress when time-based calculation is not enabled
+        task.progress = 0;
+      }
 
       // Set complete_ratio to match progress
       task.complete_ratio = task.progress;

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

@@ -109,7 +109,7 @@ export default class TasksControllerV2 extends TasksControllerBase {
   }
 
   private static getQuery(userId: string, options: ParsedQs) {
-    const searchField = options.search ? "t.name" : "sort_order";
+    const searchField = options.search ? ["t.name", "CONCAT((SELECT key FROM projects WHERE id = t.project_id), '-', task_no)"] : "sort_order";
     const { searchQuery, sortField } = TasksControllerV2.toPaginationOptions(options, searchField);
 
     const isSubTasks = !!options.parent_task;
@@ -326,9 +326,18 @@ export default class TasksControllerV2 extends TasksControllerBase {
 
   @HandleExceptions()
   public static async getList(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    // Before doing anything else, refresh task progress values for this project
+    const startTime = performance.now();
-    if (req.params.id) {
+    console.log(`[PERFORMANCE] getList method called for project ${req.params.id} - THIS METHOD IS DEPRECATED, USE getTasksV3 INSTEAD`);
+
+    // PERFORMANCE OPTIMIZATION: Skip expensive progress calculation by default
+    // Progress values are already calculated and stored in the database
+    // Only refresh if explicitly requested via refresh_progress=true query parameter
+    if (req.query.refresh_progress === "true" && req.params.id) {
+      console.log(`[PERFORMANCE] Starting progress refresh for project ${req.params.id} (getList)`);
+      const progressStartTime = performance.now();
       await this.refreshProjectTaskProgressValues(req.params.id);
+      const progressEndTime = performance.now();
+      console.log(`[PERFORMANCE] Progress refresh completed in ${(progressEndTime - progressStartTime).toFixed(2)}ms`);
     }
 
     const isSubTasks = !!req.query.parent_task;
@@ -366,6 +375,15 @@ export default class TasksControllerV2 extends TasksControllerBase {
       };
     });
 
+    const endTime = performance.now();
+    const totalTime = endTime - startTime;
+    console.log(`[PERFORMANCE] getList method completed in ${totalTime.toFixed(2)}ms for project ${req.params.id} with ${tasks.length} tasks`);
+
+    // Log warning if this deprecated method is taking too long
+    if (totalTime > 1000) {
+      console.warn(`[PERFORMANCE WARNING] DEPRECATED getList method taking ${totalTime.toFixed(2)}ms - Frontend should use getTasksV3 instead!`);
+    }
+
     return res.status(200).send(new ServerResponse(true, updatedGroups));
   }
 
@@ -373,20 +391,11 @@ export default class TasksControllerV2 extends TasksControllerBase {
     let index = 0;
     const unmapped = [];
 
-    // First, ensure we have the latest progress values for all tasks
+    // PERFORMANCE OPTIMIZATION: Remove expensive individual DB calls for each task
-    for (const task of tasks) {
+    // Progress values are already calculated and included in the main query
-      // For any task with subtasks, ensure we have the latest progress values
+    // No need to make additional database calls here
-      if (task.sub_tasks_count > 0) {
-        const info = await this.getTaskCompleteRatio(task.id);
-        if (info) {
-          task.complete_ratio = info.ratio;
-          task.progress_value = info.ratio; // Ensure progress_value reflects the calculated ratio
-          console.log(`Updated task ${task.name} (${task.id}): complete_ratio=${task.complete_ratio}`);
-        }
-      }
-    }
 
-    // Now group the tasks with their updated progress values
+    // Process tasks with their already-calculated progress values
     for (const task of tasks) {
       task.index = index++;
       TasksControllerV2.updateTaskViewModel(task);
@@ -426,9 +435,18 @@ export default class TasksControllerV2 extends TasksControllerBase {
 
   @HandleExceptions()
   public static async getTasksOnly(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
-    // Before doing anything else, refresh task progress values for this project
+    const startTime = performance.now();
-    if (req.params.id) {
+    console.log(`[PERFORMANCE] getTasksOnly method called for project ${req.params.id} - Consider using getTasksV3 for better performance`);
+
+    // PERFORMANCE OPTIMIZATION: Skip expensive progress calculation by default
+    // Progress values are already calculated and stored in the database
+    // Only refresh if explicitly requested via refresh_progress=true query parameter
+    if (req.query.refresh_progress === "true" && req.params.id) {
+      console.log(`[PERFORMANCE] Starting progress refresh for project ${req.params.id} (getTasksOnly)`);
+      const progressStartTime = performance.now();
       await this.refreshProjectTaskProgressValues(req.params.id);
+      const progressEndTime = performance.now();
+      console.log(`[PERFORMANCE] Progress refresh completed in ${(progressEndTime - progressStartTime).toFixed(2)}ms`);
     }
 
     const isSubTasks = !!req.query.parent_task;
@@ -448,27 +466,24 @@ export default class TasksControllerV2 extends TasksControllerBase {
     } else { // else we return a flat list of tasks
       data = [...result.rows];
 
-      for (const task of data) {
+      // PERFORMANCE OPTIMIZATION: Remove expensive individual DB calls for each task
-        // For tasks with subtasks, get the complete ratio from the database function
+      // Progress values are already calculated and included in the main query via get_task_complete_ratio
-        if (task.sub_tasks_count > 0) {
+      // The database query already includes complete_ratio, so no need for additional calls
-          try {
-            const result = await db.query("SELECT get_task_complete_ratio($1) AS info;", [task.id]);
-            const [ratioData] = result.rows;
-            if (ratioData && ratioData.info) {
-              task.complete_ratio = +(ratioData.info.ratio || 0).toFixed();
-              task.completed_count = ratioData.info.total_completed;
-              task.total_tasks_count = ratioData.info.total_tasks;
-              console.log(`Updated task ${task.id} (${task.name}) from DB: complete_ratio=${task.complete_ratio}`);
-            }
-          } catch (error) {
-            // Proceed with default calculation if database call fails
-          }
-        }
 
+      for (const task of data) {
         TasksControllerV2.updateTaskViewModel(task);
       }
     }
 
+    const endTime = performance.now();
+    const totalTime = endTime - startTime;
+    console.log(`[PERFORMANCE] getTasksOnly method completed in ${totalTime.toFixed(2)}ms for project ${req.params.id} with ${data.length} tasks`);
+
+    // Log warning if this method is taking too long
+    if (totalTime > 1000) {
+      console.warn(`[PERFORMANCE WARNING] getTasksOnly method taking ${totalTime.toFixed(2)}ms - Consider using getTasksV3 for better performance!`);
+    }
+
     return res.status(200).send(new ServerResponse(true, data));
   }
 
@@ -610,6 +625,21 @@ export default class TasksControllerV2 extends TasksControllerBase {
     return this.createTagList(result.rows);
   }
 
+  public static async getProjectSubscribers(projectId: string) {
+    const q = `
+      SELECT u.name, u.avatar_url, ps.user_id, ps.team_member_id, ps.project_id
+      FROM project_subscribers ps
+             LEFT JOIN users u ON ps.user_id = u.id
+      WHERE ps.project_id = $1;
+    `;
+    const result = await db.query(q, [projectId]);
+
+    for (const member of result.rows)
+      member.color_code = getColor(member.name);
+
+    return this.createTagList(result.rows);
+  }
+
   public static async checkUserAssignedToTask(taskId: string, userId: string, teamId: string) {
     const q = `
     SELECT EXISTS(
@@ -952,4 +982,409 @@ export default class TasksControllerV2 extends TasksControllerBase {
       log_error(`Error updating task weight: ${error}`);
     }
   }
+
+  @HandleExceptions()
+  public static async getTasksV3(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    const startTime = performance.now();
+    const isSubTasks = !!req.query.parent_task;
+    const groupBy = (req.query.group || GroupBy.STATUS) as string;
+    const archived = req.query.archived === "true";
+
+    // PERFORMANCE OPTIMIZATION: Skip expensive progress calculation by default
+    // Progress values are already calculated and stored in the database
+    // Only refresh if explicitly requested via refresh_progress=true query parameter
+    // This dramatically improves initial load performance (from ~2-5s to ~200-500ms)
+    const shouldRefreshProgress = req.query.refresh_progress === "true";
+
+    if (shouldRefreshProgress && req.params.id) {
+      const progressStartTime = performance.now();
+      await this.refreshProjectTaskProgressValues(req.params.id);
+      const progressEndTime = performance.now();
+    }
+
+    const queryStartTime = performance.now();
+    const q = TasksControllerV2.getQuery(req.user?.id as string, req.query);
+    const params = isSubTasks ? [req.params.id || null, req.query.parent_task] : [req.params.id || null];
+
+    const result = await db.query(q, params);
+    const tasks = [...result.rows];
+    const queryEndTime = performance.now();
+
+    // Get groups metadata dynamically from database
+    const groupsStartTime = performance.now();
+    const groups = await this.getGroups(groupBy, req.params.id);
+    const groupsEndTime = performance.now();
+
+    // Create priority value to name mapping
+    const priorityMap: Record<string, string> = {
+      "0": "low",
+      "1": "medium",
+      "2": "high"
+    };
+
+    // Create status category mapping based on actual status names from database
+    const statusCategoryMap: Record<string, string> = {};
+    for (const group of groups) {
+      if (groupBy === GroupBy.STATUS && group.id) {
+        // Use the actual status name from database, convert to lowercase for consistency
+        statusCategoryMap[group.id] = group.name.toLowerCase().replace(/\s+/g, "_");
+      }
+    }
+
+
+
+    // Transform tasks with all necessary data preprocessing
+    const transformStartTime = performance.now();
+    const transformedTasks = tasks.map((task, index) => {
+      // Update task with calculated values (lightweight version)
+      TasksControllerV2.updateTaskViewModel(task);
+      task.index = index;
+
+      // Convert time values
+      const convertTimeValue = (value: any): number => {
+        if (typeof value === "number") return value;
+        if (typeof value === "string") {
+          const parsed = parseFloat(value);
+          return isNaN(parsed) ? 0 : parsed;
+        }
+        if (value && typeof value === "object") {
+          if ("hours" in value || "minutes" in value) {
+            const hours = Number(value.hours || 0);
+            const minutes = Number(value.minutes || 0);
+            return hours + (minutes / 60);
+          }
+        }
+        return 0;
+      };
+
+      return {
+        id: task.id,
+        task_key: task.task_key || "",
+        title: task.name || "",
+        description: task.description || "",
+        // Use dynamic status mapping from database
+        status: statusCategoryMap[task.status] || task.status,
+        // Pre-processed priority using mapping
+        priority: priorityMap[task.priority_value?.toString()] || "medium",
+        // Use actual phase name from database
+        phase: task.phase_name || "Development",
+        progress: typeof task.complete_ratio === "number" ? task.complete_ratio : 0,
+        assignees: task.assignees?.map((a: any) => a.team_member_id) || [],
+        assignee_names: task.assignee_names || task.names || [],
+        labels: task.labels?.map((l: any) => ({
+          id: l.id || l.label_id,
+          name: l.name,
+          color: l.color_code || "#1890ff",
+          end: l.end,
+          names: l.names
+        })) || [],
+        dueDate: task.end_date || task.END_DATE,
+        startDate: task.start_date,
+        timeTracking: {
+          estimated: convertTimeValue(task.total_time),
+          logged: convertTimeValue(task.time_spent),
+        },
+        customFields: {},
+        custom_column_values: task.custom_column_values || {}, // Include custom column values
+        createdAt: task.created_at || new Date().toISOString(),
+        updatedAt: task.updated_at || new Date().toISOString(),
+        order: typeof task.sort_order === "number" ? task.sort_order : 0,
+        // Additional metadata for frontend
+        originalStatusId: task.status,
+        originalPriorityId: task.priority,
+        statusColor: task.status_color,
+        priorityColor: task.priority_color,
+        // Add subtask count
+        sub_tasks_count: task.sub_tasks_count || 0,
+        // Add indicator fields for frontend icons
+        comments_count: task.comments_count || 0,
+        has_subscribers: !!task.has_subscribers,
+        attachments_count: task.attachments_count || 0,
+        has_dependencies: !!task.has_dependencies,
+        schedule_id: task.schedule_id || null,
+        reporter: task.reporter || null,
+      };
+    });
+    const transformEndTime = performance.now();
+
+    // Create groups based on dynamic data from database
+    const groupingStartTime = performance.now();
+    const groupedResponse: Record<string, any> = {};
+
+    // Initialize groups from database data
+    groups.forEach(group => {
+      const groupKey = groupBy === GroupBy.STATUS
+        ? group.name.toLowerCase().replace(/\s+/g, "_")
+        : groupBy === GroupBy.PRIORITY
+        ? priorityMap[(group as any).value?.toString()] || group.name.toLowerCase()
+        : group.name.toLowerCase().replace(/\s+/g, "_");
+
+      groupedResponse[groupKey] = {
+        id: group.id,
+        title: group.name,
+        groupType: groupBy,
+        groupValue: groupKey,
+        collapsed: false,
+        tasks: [],
+        taskIds: [],
+        color: group.color_code || this.getDefaultGroupColor(groupBy, groupKey),
+        // Include additional metadata from database
+        category_id: group.category_id,
+        start_date: group.start_date,
+        end_date: group.end_date,
+        sort_index: (group as any).sort_index,
+      };
+    });
+
+    // Distribute tasks into groups
+    const unmappedTasks: any[] = [];
+
+    transformedTasks.forEach(task => {
+      let groupKey: string;
+      let taskAssigned = false;
+
+      if (groupBy === GroupBy.STATUS) {
+        groupKey = task.status;
+        if (groupedResponse[groupKey]) {
+          groupedResponse[groupKey].tasks.push(task);
+          groupedResponse[groupKey].taskIds.push(task.id);
+          taskAssigned = true;
+        }
+      } else if (groupBy === GroupBy.PRIORITY) {
+        groupKey = task.priority;
+        if (groupedResponse[groupKey]) {
+          groupedResponse[groupKey].tasks.push(task);
+          groupedResponse[groupKey].taskIds.push(task.id);
+          taskAssigned = true;
+        }
+      } else if (groupBy === GroupBy.PHASE) {
+        // For phase grouping, check if task has a valid phase
+        if (task.phase && task.phase.trim() !== "") {
+          groupKey = task.phase.toLowerCase().replace(/\s+/g, "_");
+          if (groupedResponse[groupKey]) {
+            groupedResponse[groupKey].tasks.push(task);
+            groupedResponse[groupKey].taskIds.push(task.id);
+            taskAssigned = true;
+          }
+        }
+        // If task doesn't have a valid phase, add to unmapped
+        if (!taskAssigned) {
+          unmappedTasks.push(task);
+        }
+      }
+    });
+
+    // Calculate progress stats for priority and phase grouping
+    if (groupBy === GroupBy.PRIORITY || groupBy === GroupBy.PHASE) {
+      Object.values(groupedResponse).forEach((group: any) => {
+        if (group.tasks && group.tasks.length > 0) {
+          const todoCount = group.tasks.filter((task: any) => {
+            // For tasks, we need to check their original status category
+            const originalTask = tasks.find(t => t.id === task.id);
+            return originalTask?.status_category?.is_todo;
+          }).length;
+          
+          const doingCount = group.tasks.filter((task: any) => {
+            const originalTask = tasks.find(t => t.id === task.id);
+            return originalTask?.status_category?.is_doing;
+          }).length;
+          
+          const doneCount = group.tasks.filter((task: any) => {
+            const originalTask = tasks.find(t => t.id === task.id);
+            return originalTask?.status_category?.is_done;
+          }).length;
+
+          const total = group.tasks.length;
+
+          // Calculate progress percentages
+          group.todo_progress = total > 0 ? +((todoCount / total) * 100).toFixed(0) : 0;
+          group.doing_progress = total > 0 ? +((doingCount / total) * 100).toFixed(0) : 0;
+          group.done_progress = total > 0 ? +((doneCount / total) * 100).toFixed(0) : 0;
+        }
+      });
+    }
+
+    // Create unmapped group if there are tasks without proper phase assignment
+    if (unmappedTasks.length > 0 && groupBy === GroupBy.PHASE) {
+      const unmappedGroup = {
+        id: UNMAPPED,
+        title: UNMAPPED,
+        groupType: groupBy,
+        groupValue: UNMAPPED.toLowerCase(),
+        collapsed: false,
+        tasks: unmappedTasks,
+        taskIds: unmappedTasks.map(task => task.id),
+        color: "#fbc84c69", // Orange color with transparency
+        category_id: null,
+        start_date: null,
+        end_date: null,
+        sort_index: 999, // Put unmapped group at the end
+        todo_progress: 0,
+        doing_progress: 0,
+        done_progress: 0,
+      };
+
+      // Calculate progress stats for unmapped group
+      if (unmappedTasks.length > 0) {
+        const todoCount = unmappedTasks.filter((task: any) => {
+          const originalTask = tasks.find(t => t.id === task.id);
+          return originalTask?.status_category?.is_todo;
+        }).length;
+        
+        const doingCount = unmappedTasks.filter((task: any) => {
+          const originalTask = tasks.find(t => t.id === task.id);
+          return originalTask?.status_category?.is_doing;
+        }).length;
+        
+        const doneCount = unmappedTasks.filter((task: any) => {
+          const originalTask = tasks.find(t => t.id === task.id);
+          return originalTask?.status_category?.is_done;
+        }).length;
+
+        const total = unmappedTasks.length;
+
+        unmappedGroup.todo_progress = total > 0 ? +((todoCount / total) * 100).toFixed(0) : 0;
+        unmappedGroup.doing_progress = total > 0 ? +((doingCount / total) * 100).toFixed(0) : 0;
+        unmappedGroup.done_progress = total > 0 ? +((doneCount / total) * 100).toFixed(0) : 0;
+      }
+
+      groupedResponse[UNMAPPED.toLowerCase()] = unmappedGroup;
+    }
+
+    // Sort tasks within each group by order
+    Object.values(groupedResponse).forEach((group: any) => {
+      group.tasks.sort((a: any, b: any) => a.order - b.order);
+    });
+
+    // Convert to array format expected by frontend, maintaining database order
+    const responseGroups = groups
+      .map(group => {
+        const groupKey = groupBy === GroupBy.STATUS
+          ? group.name.toLowerCase().replace(/\s+/g, "_")
+          : groupBy === GroupBy.PRIORITY
+          ? priorityMap[(group as any).value?.toString()] || group.name.toLowerCase()
+          : group.name.toLowerCase().replace(/\s+/g, "_");
+
+        return groupedResponse[groupKey];
+      })
+      .filter(group => group && (group.tasks.length > 0 || req.query.include_empty === "true"));
+
+    // Add unmapped group to the end if it exists
+    if (groupedResponse[UNMAPPED.toLowerCase()]) {
+      responseGroups.push(groupedResponse[UNMAPPED.toLowerCase()]);
+    }
+
+    const groupingEndTime = performance.now();
+
+    const endTime = performance.now();
+    const totalTime = endTime - startTime;
+
+    // Log warning if request is taking too long
+    if (totalTime > 1000) {
+      console.warn(`[PERFORMANCE WARNING] Slow request detected: ${totalTime.toFixed(2)}ms for project ${req.params.id} with ${transformedTasks.length} tasks`);
+    }
+
+    return res.status(200).send(new ServerResponse(true, {
+      groups: responseGroups,
+      allTasks: transformedTasks,
+      grouping: groupBy,
+      totalTasks: transformedTasks.length
+    }));
+  }
+
+  private static getDefaultGroupColor(groupBy: string, groupValue: string): string {
+    const colorMaps: Record<string, Record<string, string>> = {
+      [GroupBy.STATUS]: {
+        todo: "#f0f0f0",
+        doing: "#1890ff",
+        done: "#52c41a",
+      },
+      [GroupBy.PRIORITY]: {
+        critical: "#ff4d4f",
+        high: "#ff7a45",
+        medium: "#faad14",
+        low: "#52c41a",
+      },
+      [GroupBy.PHASE]: {
+        planning: "#722ed1",
+        development: "#1890ff",
+        testing: "#faad14",
+        deployment: "#52c41a",
+        unmapped: "#fbc84c69",
+      },
+    };
+
+    return colorMaps[groupBy]?.[groupValue] || "#d9d9d9";
+  }
+
+  @HandleExceptions()
+  public static async refreshTaskProgress(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    try {
+      const startTime = performance.now();
+
+      if (req.params.id) {
+        console.log(`[PERFORMANCE] Starting background progress refresh for project ${req.params.id}`);
+        await this.refreshProjectTaskProgressValues(req.params.id);
+
+        const endTime = performance.now();
+        const totalTime = endTime - startTime;
+        console.log(`[PERFORMANCE] Background progress refresh completed in ${totalTime.toFixed(2)}ms for project ${req.params.id}`);
+
+        return res.status(200).send(new ServerResponse(true, {
+          message: "Task progress values refreshed successfully",
+          performanceMetrics: {
+            refreshTime: Math.round(totalTime),
+            projectId: req.params.id
+          }
+        }));
+      }
+      return res.status(400).send(new ServerResponse(false, null, "Project ID is required"));
+    } catch (error) {
+      console.error("Error refreshing task progress:", error);
+      return res.status(500).send(new ServerResponse(false, null, "Failed to refresh task progress"));
+    }
+  }
+
+  // Optimized method for getting task progress without blocking main UI
+  @HandleExceptions()
+  public static async getTaskProgressStatus(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    try {
+      if (!req.params.id) {
+        return res.status(400).send(new ServerResponse(false, null, "Project ID is required"));
+      }
+
+      // Get basic progress stats without expensive calculations
+      const result = await db.query(`
+        SELECT
+          COUNT(*) as total_tasks,
+          COUNT(CASE WHEN EXISTS(
+            SELECT 1 FROM tasks_with_status_view
+            WHERE tasks_with_status_view.task_id = tasks.id
+            AND is_done IS TRUE
+          ) THEN 1 END) as completed_tasks,
+          AVG(CASE
+            WHEN progress_value IS NOT NULL THEN progress_value
+            ELSE 0
+          END) as avg_progress,
+          MAX(updated_at) as last_updated
+        FROM tasks
+        WHERE project_id = $1 AND archived IS FALSE
+      `, [req.params.id]);
+
+      const [stats] = result.rows;
+
+      return res.status(200).send(new ServerResponse(true, {
+        projectId: req.params.id,
+        totalTasks: parseInt(stats.total_tasks) || 0,
+        completedTasks: parseInt(stats.completed_tasks) || 0,
+        avgProgress: parseFloat(stats.avg_progress) || 0,
+        lastUpdated: stats.last_updated,
+        completionPercentage: stats.total_tasks > 0 ?
+          Math.round((parseInt(stats.completed_tasks) / parseInt(stats.total_tasks)) * 100) : 0
+      }));
+    } catch (error) {
+      console.error("Error getting task progress status:", error);
+      return res.status(500).send(new ServerResponse(false, null, "Failed to get task progress status"));
+    }
+  }
 }

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: true,
+  proxy: false,
   resave: false,
-  saveUninitialized: false,
+  saveUninitialized: true,
   rolling: true,
   store: new pgSession({
     pool: db.pool,
@@ -18,9 +18,10 @@ export default session({
   }),
   cookie: {
     path: "/",
-    secure: isProduction(), // Use secure cookies in production
+    // secure: isProduction(),
-    httpOnly: true,
+    // httpOnly: isProduction(),
-    sameSite: "lax", // Standard setting for same-origin requests
+    // sameSite: "none",
+    // domain: isProduction() ? ".worklenz.com" : undefined,
     maxAge: 30 * 24 * 60 * 60 * 1000 // 30 days
   }
 });

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"
+}

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

@@ -0,0 +1,35 @@
+{
+  "yesterdayText": "Dje",
+  "lastSevenDaysText": "7 Ditët e Fundit",
+  "lastWeekText": "Javën e Kaluar",
+  "lastThirtyDaysText": "30 Ditët e Fundit",
+  "lastMonthText": "Muajin e Kaluar",
+  "lastThreeMonthsText": "3 Muajt e Fundit",
+  "allTimeText": "Të Gjitha",
+  "customRangeText": "Interval i Përshtatur",
+  "startDateInputPlaceholder": "Data e fillimit",
+  "EndDateInputPlaceholder": "Data e përfundimit",
+  "filterButton": "Filtro",
+
+  "membersTitle": "Anëtarët",
+  "includeArchivedButton": "Përfshij Projektet e Arkivuara",
+  "exportButton": "Eksporto",
+  "excelButton": "Excel",
+  "searchByNameInputPlaceholder": "Kërko sipas emrit",
+
+  "memberColumn": "Anëtari",
+  "tasksProgressColumn": "Progresi i Detyrave",
+  "tasksAssignedColumn": "Detyrat e Caktuara",
+  "completedTasksColumn": "Detyrat e Përfunduara",
+  "overdueTasksColumn": "Detyrat e Vonuara",
+  "ongoingTasksColumn": "Detyrat në Vazhdim",
+
+  "tasksAssignedColumnTooltip": "Detyrat e caktuara në intervalin e zgjedhur",
+  "overdueTasksColumnTooltip": "Detyrat e vonuara deri në fund të intervalit të zgjedhur",
+  "completedTasksColumnTooltip": "Detyrat e përfunduara në intervalin e zgjedhur",
+  "ongoingTasksColumnTooltip": "Detyrat e filluara por jo të përfunduara ende",
+
+  "todoText": "Për Të Bërë",
+  "doingText": "Duke bërë",
+  "doneText": "E Përfunduar"
+}

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

@@ -0,0 +1,39 @@
+{
+  "exportButton": "Eksporto",
+  "projectsButton": "Projektet",
+  "membersButton": "Anëtarët",
+  "searchByNameInputPlaceholder": "Kërko sipas emrit",
+
+  "overviewTab": "Përmbledhje",
+  "projectsTab": "Projektet",
+  "membersTab": "Anëtarët",
+
+  "projectsByStatusText": "Projektet Sipas Statusit",
+  "projectsByCategoryText": "Projektet Sipas Kategorisë",
+  "projectsByHealthText": "Projektet Sipas Gjendjes",
+
+  "projectsText": "Projektet",
+  "allText": "Të Gjitha",
+
+  "cancelledText": "Anuluar",
+  "blockedText": "E Bllokuar",
+  "onHoldText": "Në Pritje",
+  "proposedText": "E Propozuar",
+  "inPlanningText": "Në Planifikim",
+  "inProgressText": "Në Progres",
+  "completedText": "E Përfunduar",
+  "continuousText": "E Vazhdueshme",
+
+  "notSetText": "Pa Caktuar",
+  "needsAttentionText": "Kërkon Vëmendje",
+  "atRiskText": "Në Rrezik",
+  "goodText": "Në Rregull",
+
+  "nameColumn": "Emri",
+  "emailColumn": "Email",
+  "projectsColumn": "Projektet",
+  "tasksColumn": "Detyrat",
+  "overdueTasksColumn": "Detyrat e Vonuara",
+  "completedTasksColumn": "Detyrat e Përfunduara",
+  "ongoingTasksColumn": "Detyrat në Vazhdim"
+}

worklenz-backend/src/public/locales/alb/reporting-overview.json

@@ -0,0 +1,25 @@
+{
+  "overviewTitle": "Përmbledhje",
+  "includeArchivedButton": "Përfshij Projektet e Arkivuara",
+
+  "teamCount": "Ekip",
+  "teamCountPlural": "Ekipe",
+  "projectCount": "Projekt",
+  "projectCountPlural": "Projekte",
+  "memberCount": "Anëtar",
+  "memberCountPlural": "Anëtarë",
+  "activeProjectCount": "Projekt Aktiv",
+  "activeProjectCountPlural": "Projekte Aktive",
+  "overdueProjectCount": "Projekt i Vonuar",
+  "overdueProjectCountPlural": "Projekte të Vonuara",
+  "unassignedMemberCount": "Anëtar i Pacaktuar",
+  "unassignedMemberCountPlural": "Anëtarë të Pacaktuar",
+  "memberWithOverdueTaskCount": "Anëtar me Detyrë të Vonuar",
+  "memberWithOverdueTaskCountPlural": "Anëtarë me Detyra të Vonuara",
+
+  "teamsText": "Ekipet",
+
+  "nameColumn": "Emri",
+  "projectsColumn": "Projektet",
+  "membersColumn": "Anëtarët"
+}

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

@@ -0,0 +1,59 @@
+{
+  "exportButton": "Eksporto",
+  "membersButton": "Anëtarët",
+  "tasksButton": "Detyrat",
+  "searchByNameInputPlaceholder": "Kërko sipas emrit",
+
+  "overviewTab": "Përmbledhje",
+  "membersTab": "Anëtarët",
+  "tasksTab": "Detyrat",
+
+  "completedTasksText": "Detyrat e Përfunduara",
+  "incompleteTasksText": "Detyrat e Papërfunduara",
+  "overdueTasksText": "Detyrat e Vonuara",
+  "allocatedHoursText": "Orët e Alokuara",
+  "loggedHoursText": "Orët e Regjistruara",
+
+  "tasksText": "Detyrat",
+  "allText": "Të Gjitha",
+
+  "tasksByStatusText": "Detyrat Sipas Statusit",
+  "tasksByPriorityText": "Detyrat Sipas Prioritetit",
+  "tasksByDueDateText": "Detyrat Sipas Afatit",
+
+  "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ë",
+  "completedText": "E Përfunduar",
+  "upcomingText": "Në Ardhje",
+  "overdueText": "E Vonuar",
+  "noDueDateText": "Pa Afat",
+
+  "nameColumn": "Emri",
+  "tasksCountColumn": "Numri i Detyrave",
+  "completedTasksColumn": "Detyrat e Përfunduara",
+  "incompleteTasksColumn": "Detyrat e Papërfunduara",
+  "overdueTasksColumn": "Detyrat e Vonuara",
+  "contributionColumn": "Kontributi",
+  "progressColumn": "Progresi",
+  "loggedTimeColumn": "Koha e Regjistruar",
+  "taskColumn": "Detyra",
+  "projectColumn": "Projekti",
+  "statusColumn": "Statusi",
+  "priorityColumn": "Prioriteti",
+  "phaseColumn": "Faza",
+  "dueDateColumn": "Afati",
+  "completedDateColumn": "Data e Përfundimit",
+  "estimatedTimeColumn": "Koha e Vlerësuar",
+  "overloggedTimeColumn": "Koha e Tepërt",
+  "completedOnColumn": "Përfunduar Më",
+  "daysOverdueColumn": "Ditë vonim",
+
+  "groupByText": "Grupo Sipas:",
+  "statusText": "Statusi",
+  "priorityText": "Prioriteti",
+  "phaseText": "Faza"
+}

worklenz-backend/src/public/locales/alb/reporting-projects-filters.json

@@ -0,0 +1,35 @@
+{
+  "searchByNamePlaceholder": "Kërko sipas emrit",
+  "searchByCategoryPlaceholder": "Kërko sipas kategorisë",
+
+  "statusText": "Statusi",
+  "healthText": "Gjendja",
+  "categoryText": "Kategoria",
+  "projectManagerText": "Menaxheri i Projektit",
+  "showFieldsText": "Shfaq fushat",
+
+  "cancelledText": "Anuluar",
+  "blockedText": "E bllokuar",
+  "onHoldText": "Në pritje",
+  "proposedText": "E propozuar",
+  "inPlanningText": "Në planifikim",
+  "inProgressText": "Në progres",
+  "completedText": "E përfunduar",
+  "continuousText": "E vazhdueshme",
+
+  "notSetText": "Pa caktuar",
+  "needsAttentionText": "Kërkon vëmendje",
+  "atRiskText": "Në rrezik",
+  "goodText": "Në rregull",
+
+  "nameText": "Projekti",
+  "estimatedVsActualText": "Vlerësuar vs Aktual",
+  "tasksProgressText": "Progresi i detyrave",
+  "lastActivityText": "Aktiviteti i fundit",
+  "datesText": "Datat e Fillimit/Përfundimit",
+  "daysLeftText": "Ditë të mbetura/vonuar",
+  "projectHealthText": "Gjendja e projektit",
+  "projectUpdateText": "Përditësimi i projektit",
+  "clientText": "Klienti",
+  "teamText": "Ekipi"
+}

worklenz-backend/src/public/locales/alb/reporting-projects.json

@@ -0,0 +1,52 @@
+{
+  "projectCount": "Projekt",
+  "projectCountPlural": "Projekte",
+  "includeArchivedButton": "Përfshij Projektet e Arkivuara",
+  "exportButton": "Eksporto",
+  "excelButton": "Excel",
+
+  "projectColumn": "Projekti",
+  "estimatedVsActualColumn": "Vlerësuar vs Aktual",
+  "tasksProgressColumn": "Progresi i Detyrave",
+  "lastActivityColumn": "Aktiviteti i Fundit",
+  "statusColumn": "Statusi",
+  "datesColumn": "Data e Fillimit/Përfundimit",
+  "daysLeftColumn": "Ditë të Mbetura/Vonuar",
+  "projectHealthColumn": "Gjendja e Projektit",
+  "categoryColumn": "Kategoria",
+  "projectUpdateColumn": "Përditësimi i Projektit",
+  "clientColumn": "Klienti",
+  "teamColumn": "Ekipi",
+  "projectManagerColumn": "Menaxheri i Projektit",
+
+  "openButton": "Hap",
+
+  "estimatedText": "Vlerësuar",
+  "actualText": "Aktual",
+
+  "todoText": "Për të Bërë",
+  "doingText": "duke bërë",
+  "doneText": "E Përfunduar",
+
+  "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",
+  "dayLeftText": "ditë e mbetur",
+  "daysOverdueText": "ditë vonuar",
+
+  "notSetText": "Pa Caktuar",
+  "needsAttentionText": "Kërkon Vëmendje",
+  "atRiskText": "Në Rrezik",
+  "goodText": "Në Rregull",
+
+  "setCategoryText": "Cakto Kategorinë",
+  "searchByNameInputPlaceholder": "Kërko sipas emrit",
+  "todayText": "Sot"
+}

worklenz-backend/src/public/locales/alb/reporting-sidebar.json

@@ -0,0 +1,8 @@
+{
+  "overview": "Përmbledhje",
+  "projects": "Projektet",
+  "members": "Anëtarët",
+  "timeReports": "Raportet e Kohës",
+  "estimateVsActual": "Vlerësimi vs Aktual",
+  "currentOrganizationTooltip": "Organizata aktuale"
+}

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

@@ -0,0 +1,39 @@
+{
+  "today": "Sot",
+  "week": "Javë",
+  "month": "Muaj",
+
+  "settings": "Cilësimet",
+  "workingDays": "Ditët e punës",
+  "monday": "E hënë",
+  "tuesday": "E martë",
+  "wednesday": "E mërkurë",
+  "thursday": "E enjte",
+  "friday": "E premte",
+  "saturday": "E shtunë",
+  "sunday": "E diel",
+  "workingHours": "Orët e punës",
+  "hours": "Orë",
+  "saveButton": "Ruaj",
+
+  "totalAllocation": "Alokimi Total",
+  "timeLogged": "Koha e Regjistruar",
+  "remainingTime": "Koha e Mbetur",
+  "total": "Total",
+  "perDay": "Në Ditë",
+  "tasks": "detyra",
+  "startDate": "Data e Fillimit",
+  "endDate": "Data e Përfundimit",
+
+  "hoursPerDay": "Orë Në Ditë",
+  "totalHours": "Orë Totale",
+  "deleteButton": "Fshi",
+  "cancelButton": "Anulo",
+
+  "tabTitle": "Detyra pa Data Fillimi & Përfundimi",
+
+  "allocatedTime": "Koha e alokuar",
+  "totalLogged": "Total i Regjistruar",
+  "loggedBillable": "Regjistruar Fakturueshme",
+  "loggedNonBillable": "Regjistruar Jo Fakturueshme"
+}

worklenz-backend/src/public/locales/alb/settings/categories.json

@@ -0,0 +1,10 @@
+{
+  "categoryColumn": "Kategoria",
+  "deleteConfirmationTitle": "Jeni të sigurt?",
+  "deleteConfirmationOk": "Po",
+  "deleteConfirmationCancel": "Anulo",
+  "associatedTaskColumn": "Projektet e Lidhura",
+  "searchPlaceholder": "Kërko sipas emrit",
+  "emptyText": "Kategoritë mund të krijohen gjatë përditësimit ose krijimit të projekteve.",
+  "colorChangeTooltip": "Klikoni për të ndryshuar ngjyrën"
+}

worklenz-backend/src/public/locales/alb/settings/change-password.json

@@ -0,0 +1,15 @@
+{
+  "title": "Ndrysho Fjalëkalimin",
+  "currentPassword": "Fjalëkalimi Aktual",
+  "newPassword": "Fjalëkalimi i Ri",
+  "confirmPassword": "Konfirmo Fjalëkalimin",
+  "currentPasswordPlaceholder": "Vendosni fjalëkalimin aktual",
+  "newPasswordPlaceholder": "Fjalëkalimi i Ri",
+  "confirmPasswordPlaceholder": "Konfirmo Fjalëkalimin",
+  "currentPasswordRequired": "Ju lutemi vendosni fjalëkalimin aktual!",
+  "newPasswordRequired": "Ju lutemi vendosni fjalëkalimin e ri!",
+  "passwordValidationError": "Fjalëkalimi duhet të përmbajë të paktën 8 karaktere, me një shkronjë të madhe, një numër dhe një simbol.",
+  "passwordMismatch": "Fjalëkalimet nuk përputhen!",
+  "passwordRequirements": "Fjalëkalimi i ri duhet të jetë së paku 8 karaktere, me një shkronjë të madhe, një numër dhe një simbol.",
+  "updateButton": "Përditëso Fjalëkalimin"
+}

worklenz-backend/src/public/locales/alb/settings/clients.json

@@ -0,0 +1,22 @@
+{
+  "nameColumn": "Emri",
+  "projectColumn": "Projekti",
+  "noProjectsAvailable": "Nuk ka projekte të disponueshme",
+  "deleteConfirmationTitle": "Jeni i sigurt?",
+  "deleteConfirmationOk": "Po",
+  "deleteConfirmationCancel": "Anulo",
+  "searchPlaceholder": "Kërko sipas emrit",
+  "createClient": "Krijo Klient",
+  "pinTooltip": "Klikoni për ta fiksuar në menynë kryesore",
+  "createClientDrawerTitle": "Krijo Klient",
+  "updateClientDrawerTitle": "Përditëso Klientin",
+  "nameLabel": "Emri",
+  "namePlaceholder": "Emri",
+  "nameRequiredError": "Ju lutemi shkruani një Emër",
+  "createButton": "Krijo",
+  "updateButton": "Përditëso",
+  "createClientSuccessMessage": "Klienti u krijua me sukses!",
+  "createClientErrorMessage": "Krijimi i klientit dështoi!",
+  "updateClientSuccessMessage": "Klienti u përditësua me sukses!",
+  "updateClientErrorMessage": "Përditësimi i klientit dështoi!"
+}

worklenz-backend/src/public/locales/alb/settings/job-titles.json

@@ -0,0 +1,20 @@
+{
+  "nameColumn": "Emri",
+  "deleteConfirmationTitle": "Jeni i sigurt?",
+  "deleteConfirmationOk": "Po",
+  "deleteConfirmationCancel": "Anulo",
+  "searchPlaceholder": "Kërko sipas emrit",
+  "createJobTitleButton": "Krijo Titull Pune",
+  "pinTooltip": "Klikoni për ta fiksuar në menynë kryesore",
+  "createJobTitleDrawerTitle": "Krijo Titull Pune",
+  "updateJobTitleDrawerTitle": "Përditëso Titullin e Punës",
+  "nameLabel": "Emri",
+  "namePlaceholder": "Emri",
+  "nameRequiredError": "Ju lutemi shkruani një Emër",
+  "createButton": "Krijo",
+  "updateButton": "Përditëso",
+  "createJobTitleSuccessMessage": "Titulli i punës u krijua me sukses!",
+  "createJobTitleErrorMessage": "Krijimi i titullit të punës dështoi!",
+  "updateJobTitleSuccessMessage": "Titulli i punës u përditësua me sukses!",
+  "updateJobTitleErrorMessage": "Përditësimi i titullit të punës dështoi!"
+}

worklenz-backend/src/public/locales/alb/settings/labels.json

@@ -0,0 +1,11 @@
+{
+  "labelColumn": "Etiketa",
+  "deleteConfirmationTitle": "Jeni i sigurt?",
+  "deleteConfirmationOk": "Po",
+  "deleteConfirmationCancel": "Anulo",
+  "associatedTaskColumn": "Numri i Detyrave të Lidhura",
+  "searchPlaceholder": "Kërko sipas emrit",
+  "emptyText": "Etiketat mund të krijohen gjatë përditësimit ose krijimit të detyrave.",
+  "pinTooltip": "Klikoni për ta fiksuar në menynë kryesore",
+  "colorChangeTooltip": "Klikoni për të ndryshuar ngjyrën"
+}

worklenz-backend/src/public/locales/alb/settings/language.json

@@ -0,0 +1,7 @@
+{
+  "language": "Gjuha",
+  "language_required": "Gjuha është e detyrueshme",
+  "time_zone": "Zona kohore",
+  "time_zone_required": "Zona kohore është e detyrueshme",
+  "save_changes": "Ruaj Ndryshimet"
+}

worklenz-backend/src/public/locales/alb/settings/notifications.json

@@ -0,0 +1,11 @@
+{
+  "title": "Cilësimet e Njoftimeve",
+  "emailTitle": "Më dërgo njoftime me email",
+  "emailDescription": "Kjo përfshin caktimet e reja të detyrave",
+  "dailyDigestTitle": "Më dërgo një përmbledhje ditore",
+  "dailyDigestDescription": "Çdo mbrëmje, do të merrni një përmbledhje të aktivitetit të fundit në detyra.",
+  "popupTitle": "Shfaq njoftimet në kompjuterin tim kur Worklenz është i hapur",
+  "popupDescription": "Njoftimet e shfaqura mund të çaktivizohen nga shfletuesi juaj. Ndryshoni cilësimet e shfletuesit për t'i lejuar ato.",
+  "unreadItemsTitle": "Shfaq numrin e artikujve të palexuar",
+  "unreadItemsDescription": "Do të shihni numërimin për çdo njoftim."
+}

worklenz-backend/src/public/locales/alb/settings/profile.json

@@ -0,0 +1,14 @@
+{
+  "uploadError": "Mund të ngarkoni vetëm skedarë JPG/PNG!",
+  "uploadSizeError": "Imazhi duhet të jetë më i vogël se 2MB!",
+  "upload": "Ngarko",
+  "nameLabel": "Emri",
+  "nameRequiredError": "Emri është i detyrueshëm",
+  "emailLabel": "Email",
+  "emailRequiredError": "Email-i është i detyrueshëm",
+  "saveChanges": "Ruaj Ndryshimet",
+  "profileJoinedText": "U bashkua një muaj më parë",
+  "profileLastUpdatedText": "Përditësuar një muaj më parë",
+  "avatarTooltip": "Klikoni për të ngarkuar një avatar",
+  "title": "Cilësimet e Profilit"
+}

worklenz-backend/src/public/locales/alb/settings/project-templates.json

@@ -0,0 +1,8 @@
+{
+  "nameColumn": "Emri",
+  "editToolTip": "Modifiko",
+  "deleteToolTip": "Fshi",
+  "confirmText": "Jeni i sigurt?",
+  "okText": "Po",
+  "cancelText": "Anulo"
+}

worklenz-backend/src/public/locales/alb/settings/sidebar.json

@@ -0,0 +1,14 @@
+{
+  "profile": "Profili",
+  "notifications": "Njoftimet",
+  "clients": "Klientët",
+  "job-titles": "Tituj Pune",
+  "labels": "Etiketa",
+  "categories": "Kategoritë",
+  "project-templates": "Shabllonet e Projekteve",
+  "task-templates": "Shabllonet e Detyrave",
+  "team-members": "Anëtarët e Ekipit",
+  "teams": "Ekipet",
+  "change-password": "Ndrysho Fjalëkalimin",
+  "language-and-region": "Gjuha dhe Rajoni"
+}

worklenz-backend/src/public/locales/alb/settings/task-templates.json

@@ -0,0 +1,9 @@
+{
+  "nameColumn": "Emri",
+  "createdColumn": "Krijuar",
+  "editToolTip": "Redakto",
+  "deleteToolTip": "Fshi",
+  "confirmText": "Jeni i sigurt?",
+  "okText": "Po",
+  "cancelText": "Anulo"
+}

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

@@ -0,0 +1,47 @@
+{
+  "title": "Anëtarët e Ekipit",
+  "nameColumn": "Emri",
+  "projectsColumn": "Projektet",
+  "emailColumn": "Email",
+  "teamAccessColumn": "Qasja në Ekip",
+  "memberCount": "Anëtar",
+  "membersCountPlural": "Anëtarë",
+  "searchPlaceholder": "Kërko anëtarë sipas emrit",
+  "pinTooltip": "Rifresko listën e anëtarëve",
+  "addMemberButton": "Shto Anëtar të Ri",
+  "editTooltip": "Modifiko anëtarin",
+  "deactivateTooltip": "Çaktivizo anëtarin",
+  "activateTooltip": "Aktivizo anëtarin",
+  "deleteTooltip": "Fshi anëtarin",
+  "confirmDeleteTitle": "Jeni i sigurt që doni të fshini këtë anëtar?",
+  "confirmActivateTitle": "Jeni i sigurt që doni të ndryshoni statusin e këtij anëtari?",
+  "okText": "Po, vazhdo",
+  "cancelText": "Jo, anulo",
+  "deactivatedText": "(Aktualisht i çaktivizuar)",
+  "pendingInvitationText": "(Ftesë në pritje)",
+  "addMemberDrawerTitle": "Shto Anëtar të Ri në Ekip",
+  "updateMemberDrawerTitle": "Përditëso Anëtarin e Ekipit",
+  "addMemberEmailHint": "Anëtarët do të shtohen në ekip pavarësisht nga statusi i pranimit të ftesës",
+  "memberEmailLabel": "Email(o)",
+  "memberEmailPlaceholder": "Vendos adresën email të anëtarit të ekipit",
+  "memberEmailRequiredError": "Ju lutemi vendosni një adresë email të vlefshme",
+  "jobTitleLabel": "Titulli i Punës",
+  "jobTitlePlaceholder": "Zgjidh ose kërko titull pune (Opsionale)",
+  "memberAccessLabel": "Niveli i Qasjes",
+  "addToTeamButton": "Shto Anëtar në Ekip",
+  "updateButton": "Ruaj Ndryshimet",
+  "resendInvitationButton": "Dërgo Përsëri Email-in e Ftesës",
+  "invitationSentSuccessMessage": "Ftesa për ekip u dërgua me sukses!",
+  "createMemberSuccessMessage": "Anëtari i ri i ekipit u shtua me sukses!",
+  "createMemberErrorMessage": "Dështoi shtimi i anëtarit të ri. Ju lutemi provoni përsëri.",
+  "updateMemberSuccessMessage": "Anëtari i ekipit u përditësua me sukses!",
+  "updateMemberErrorMessage": "Dështoi përditësimi i anëtarit. Ju lutemi provoni përsëri.",
+  "memberText": "Anëtar",
+  "adminText": "Administrues",
+  "ownerText": "Pronar i Ekipit",
+  "addedText": "Shtuar",
+  "updatedText": "Përditësuar",
+  "noResultFound": "Shkruani një adresë email dhe shtypni Enter...",
+  "jobTitlesFetchError": "Dështoi marrja e titujve të punës",
+  "invitationResent": "Ftesa u dërgua sërish me sukses!"
+}

worklenz-backend/src/public/locales/alb/settings/teams.json

@@ -0,0 +1,16 @@
+{
+  "title": "Ekipet",
+  "team": "Ekip",
+  "teams": "Ekipet",
+  "name": "Emri",
+  "created": "Krijuar",
+  "ownsBy": "I përket",
+  "edit": "Ndrysho",
+  "editTeam": "Ndrysho Ekipin",
+  "pinTooltip": "Kliko për ta fiksuar në menunë kryesore",
+  "editTeamName": "Ndrysho Emrin e Ekipit",
+  "updateName": "Përditëso Emrin",
+  "namePlaceholder": "Emri",
+  "nameRequired": "Ju lutem shkruani një Emër",
+  "updateFailed": "Ndryshimi i emrit të ekipit dështoi!"
+} 

worklenz-backend/src/public/locales/alb/task-drawer/task-drawer-info-tab.json

@@ -0,0 +1,29 @@
+{
+  "details": {
+    "task-key": "Çelësi i Detyrës",
+    "phase": "Faza",
+    "assignees": "Përgjegjësit",
+    "due-date": "Data e Përfundimit",
+    "time-estimation": "Vlerësimi i Kohës",
+    "priority": "Prioriteti",
+    "labels": "Etiketa",
+    "billable": "Fakturueshme",
+    "notify": "Njofto",
+    "when-done-notify": "Kur të përfundojë, njofto",
+    "start-date": "Data e Fillimit",
+    "end-date": "Data e Përfundimit",
+    "hide-start-date": "Fshih Datën e Fillimit",
+    "show-start-date": "Shfaq Datën e Fillimit",
+    "hours": "Orë",
+    "minutes": "Minuta"
+  },
+  "description": {
+    "title": "Përshkrimi",
+    "placeholder": "Shtoni një përshkrim më të detajuar..."
+  },
+  "subTasks": {
+    "title": "Nën-Detyrat",
+    "add-sub-task": "+ Shto Nën-Detyrë",
+    "refresh-sub-tasks": "Rifresko Nën-Detyrat"
+  }
+}

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

@@ -0,0 +1,123 @@
+{
+  "taskHeader": {
+    "taskNamePlaceholder": "Shkruani Detyrën tuaj",
+    "deleteTask": "Fshi Detyrën"
+  },
+  "taskInfoTab": {
+    "title": "Informacioni",
+    "details": {
+      "title": "Detajet",
+      "task-key": "Çelësi i Detyrës",
+      "phase": "Faza",
+      "assignees": "Të Caktuar",
+      "due-date": "Data e Përfundimit",
+      "time-estimation": "Vlerësimi i Kohës",
+      "priority": "Prioriteti",
+      "labels": "Etiketat",
+      "billable": "E Faturueshme",
+      "notify": "Njofto",
+      "when-done-notify": "Kur përfundon, njofto",
+      "start-date": "Data e Fillimit",
+      "end-date": "Data e Përfundimit",
+      "hide-start-date": "Fshih Datën e Fillimit",
+      "show-start-date": "Shfaq Datën e Fillimit",
+      "hours": "Orë",
+      "minutes": "Minuta",
+      "progressValue": "Vlera e Progresit",
+      "progressValueTooltip": "Vendosni përqindjen e progresit (0-100%)",
+      "progressValueRequired": "Ju lutemi vendosni një vlerë progresi",
+      "progressValueRange": "Progresi duhet të jetë midis 0 dhe 100",
+      "taskWeight": "Pesha e Detyrës",
+      "taskWeightTooltip": "Vendosni peshën e kësaj nëndetyre (përqindje)",
+      "taskWeightRequired": "Ju lutemi vendosni një peshë detyre",
+      "taskWeightRange": "Pesha duhet të jetë midis 0 dhe 100",
+      "recurring": "E Përsëritur"
+    },
+    "labels": {
+      "labelInputPlaceholder": "Kërko ose krijo",
+      "labelsSelectorInputTip": "Shtyp Enter për të krijuar"
+    },
+    "description": {
+      "title": "Përshkrimi",
+      "placeholder": "Shto një përshkrim më të detajuar..."
+    },
+    "subTasks": {
+      "title": "Nëndetyrat",
+      "addSubTask": "Shto Nëndetyrë",
+      "addSubTaskInputPlaceholder": "Shkruani detyrën tuaj dhe shtypni enter",
+      "refreshSubTasks": "Rifresko Nëndetyrat",
+      "edit": "Modifiko",
+      "delete": "Fshi",
+      "confirmDeleteSubTask": "Jeni i sigurt që doni të fshini këtë nëndetyrë?",
+      "deleteSubTask": "Fshi Nëndetyrën"
+    },
+    "dependencies": {
+      "title": "Varësitë",
+      "addDependency": "+ Shto varësi të re",
+      "blockedBy": "Bllokuar nga",
+      "searchTask": "Shkruani për të kërkuar detyrë",
+      "noTasksFound": "Nuk u gjetën detyra",
+      "confirmDeleteDependency": "Jeni i sigurt që doni të fshini?"
+    },
+    "attachments": {
+      "title": "Bashkëngjitjet",
+      "chooseOrDropFileToUpload": "Zgjidhni ose hidhni skedar për të ngarkuar",
+      "uploading": "Duke ngarkuar..."
+    },
+    "comments": {
+      "title": "Komentet",
+      "addComment": "+ Shto koment të ri",
+      "noComments": "Ende pa komente. Bëhu i pari që komenton!",
+      "delete": "Fshi",
+      "confirmDeleteComment": "Jeni i sigurt që doni të fshini këtë koment?",
+      "addCommentPlaceholder": "Shto një koment...",
+      "cancel": "Anulo",
+      "commentButton": "Komento",
+      "attachFiles": "Bashkëngjit skedarë",
+      "addMoreFiles": "Shto më shumë skedarë",
+      "selectedFiles": "Skedarët e Zgjedhur (Deri në 25MB, Maksimumi {count})",
+      "maxFilesError": "Mund të ngarkoni maksimum {count} skedarë",
+      "processFilesError": "Dështoi përpunimi i skedarëve",
+      "addCommentError": "Ju lutemi shtoni një koment ose bashkëngjitni skedarë",
+      "createdBy": "Krijuar {{time}} nga {{user}}",
+      "updatedTime": "Përditësuar {{time}}"
+    },
+    "searchInputPlaceholder": "Kërko sipas emrit",
+    "pendingInvitation": "Ftesë në Pritje"
+  },
+  "taskTimeLogTab": {
+    "title": "Regjistri i Kohës",
+    "addTimeLog": "Shto regjistrim të ri kohe",
+    "totalLogged": "Totali i Regjistruar",
+    "exportToExcel": "Eksporto në Excel",
+    "noTimeLogsFound": "Nuk u gjetën regjistra kohe",
+    "timeLogForm": {
+      "date": "Data",
+      "startTime": "Koha e Fillimit",
+      "endTime": "Koha e Përfundimit",
+      "workDescription": "Përshkrimi i Punës",
+      "descriptionPlaceholder": "Shto një përshkrim",
+      "logTime": "Regjistro kohën",
+      "updateTime": "Përditëso kohën",
+      "cancel": "Anulo",
+      "selectDateError": "Ju lutemi zgjidhni një datë",
+      "selectStartTimeError": "Ju lutemi zgjidhni kohën e fillimit",
+      "selectEndTimeError": "Ju lutemi zgjidhni kohën e përfundimit",
+      "endTimeAfterStartError": "Koha e përfundimit duhet të jetë pas kohës së fillimit"
+    }
+  },
+  "taskActivityLogTab": {
+    "title": "Regjistri i Aktivitetit",
+    "add": "SHTO",
+    "remove": "HIQE",
+    "none": "Asnjë",
+    "weight": "Pesha",
+    "createdTask": "krijoi detyrën."
+  },
+  "taskProgress": {
+    "markAsDoneTitle": "Shëno Detyrën si të Kryer?",
+    "confirmMarkAsDone": "Po, shëno si të kryer",
+    "cancelMarkAsDone": "Jo, mbaj statusin aktual",
+    "markAsDoneDescription": "Keni vendosur progresin në 100%. Doni të përditësoni statusin e detyrës në \"Kryer\"?"
+  }
+}

worklenz-backend/src/public/locales/alb/task-list-filters.json

@@ -0,0 +1,85 @@
+{
+  "searchButton": "Kërko",
+  "resetButton": "Rivendos",
+  "searchInputPlaceholder": "Kërko sipas emrit",
+
+  "sortText": "Rendit",
+  "statusText": "Statusi",
+  "phaseText": "Faza",
+  "memberText": "Anëtarët",
+  "assigneesText": "Përgjegjësit",
+  "priorityText": "Prioriteti",
+  "labelsText": "Etiketa",
+  "membersText": "Anëtarët",
+  "groupByText": "Grupo sipas",
+  "showArchivedText": "Shfaq të arkivuara",
+  "showFieldsText": "Shfaq fushat",
+  "keyText": "Çelësi",
+  "taskText": "Detyra",
+  "descriptionText": "Përshkrimi",
+  "phasesText": "Fazat",
+  "listText": "Listë",
+  "progressText": "Progresi",
+  "timeTrackingText": "Gjurmimi i Kohës",
+  "timetrackingText": "Gjurmimi i Kohës",
+  "estimationText": "Vlerësimi",
+  "startDateText": "Data e Fillimit",
+  "startdateText": "Data e Fillimit",
+  "endDateText": "Data e Përfundimit",
+  "dueDateText": "Afati",
+  "duedateText": "Afati",
+  "completedDateText": "Data e Përfundimit",
+  "completeddateText": "Data e Përfundimit",
+  "createdDateText": "Data e Krijimit",
+  "createddateText": "Data e Krijimit",
+  "lastUpdatedText": "Përditësuar Së Fundi",
+  "lastupdatedText": "Përditësuar Së Fundi",
+  "reporterText": "Raportuesi",
+  "dueTimeText": "Koha e Afatit",
+  "duetimeText": "Koha e Afatit",
+
+  "lowText": "I ulët",
+  "mediumText": "I mesëm",
+  "highText": "I lartë",
+
+  "createStatusButtonTooltip": "Cilësimet e statusit",
+  "configPhaseButtonTooltip": "Cilësimet e fazës",
+  "noLabelsFound": "Nuk u gjetën etiketa",
+
+  "addStatusButton": "Shto Status",
+  "addPhaseButton": "Shto Fazë",
+
+  "createStatus": "Krijo Status",
+  "name": "Emri",
+  "category": "Kategoria",
+  "selectCategory": "Zgjidh një kategori",
+  "pleaseEnterAName": "Ju lutemi vendosni një emër",
+  "pleaseSelectACategory": "Ju lutemi zgjidhni një kategori",
+  "create": "Krijo",
+
+  "searchTasks": "Kërko detyrat...",
+  "searchPlaceholder": "Kërko...",
+  "fieldsText": "Fushat",
+  "loadingFilters": "Duke ngarkuar filtrat...",
+  "noOptionsFound": "Nuk u gjetën opsione",
+  "filtersActive": "filtra aktiv",
+  "filterActive": "filtër aktiv",
+  "clearAll": "Pastro të gjitha",
+  "clearing": "Duke pastruar...",
+  "cancel": "Anulo",
+  "search": "Kërko",
+  "groupedBy": "Grupuar sipas",
+  "manageStatuses": "Menaxho Statuset",
+  "managePhases": "Menaxho Fazat",
+  "dragToReorderStatuses": "Zvarrit statuset për t'i rirenditur. Çdo status mund të ketë një kategori të ndryshme.",
+  "enterNewStatusName": "Shkruani emrin e statusit të ri...",
+  "addStatus": "Shto Status",
+  "noStatusesFound": "Nuk u gjetën statuse. Krijoni statusin tuaj të parë më sipër.",
+  "deleteStatus": "Fshi Statusin",
+  "deleteStatusConfirm": "Jeni të sigurt që doni të fshini këtë status? Ky veprim nuk mund të zhbëhet.",
+  "rename": "Riemëro",
+  "delete": "Fshi",
+  "enterStatusName": "Shkruani emrin e statusit",
+  "selectCategory": "Zgjidh kategorinë",
+  "close": "Mbyll"
+}

worklenz-backend/src/public/locales/alb/task-list-table.json

@@ -0,0 +1,136 @@
+{
+  "keyColumn": "Çelësi",
+  "taskColumn": "Detyra",
+  "descriptionColumn": "Përshkrimi",
+  "progressColumn": "Progresi",
+  "membersColumn": "Anëtarët",
+  "assigneesColumn": "Përgjegjësit",
+  "labelsColumn": "Etiketa",
+  "phasesColumn": "Fazat",
+  "phaseColumn": "Faza",
+  "statusColumn": "Statusi",
+  "priorityColumn": "Prioriteti",
+  "timeTrackingColumn": "Gjurmimi i Kohës",
+  "timetrackingColumn": "Gjurmimi i Kohës",
+  "estimationColumn": "Vlerësimi",
+  "startDateColumn": "Data e Fillimit",
+  "startdateColumn": "Data e Fillimit",
+  "dueDateColumn": "Data e Afatit",
+  "duedateColumn": "Data e Afatit",
+  "completedDateColumn": "Data e Përfundimit",
+  "completeddateColumn": "Data e Përfundimit",
+  "createdDateColumn": "Data e Krijimit",
+  "createddateColumn": "Data e Krijimit",
+  "lastUpdatedColumn": "Përditësuar Së Fundi",
+  "lastupdatedColumn": "Përditësuar Së Fundi",
+  "reporterColumn": "Raportuesi",
+  "dueTimeColumn": "Koha e Afatit",
+  "todoSelectorText": "Për të Bërë",
+  "doingSelectorText": "Duke bërë",
+  "doneSelectorText": "E Përfunduar",
+
+  "lowSelectorText": "I ulët",
+  "mediumSelectorText": "I mesëm",
+  "highSelectorText": "I lartë",
+
+  "selectText": "Zgjidh",
+  "labelsSelectorInputTip": "Shtyp Enter për të krijuar!",
+
+  "addTaskText": "Shto Detyrë",
+  "addSubTaskText": "+ Shto Nën-Detyrë",
+  "noTasksInGroup": "Nuk ka detyra në këtë grup",
+  "addTaskInputPlaceholder": "Shkruaj detyrën dhe shtyp Enter",
+
+  "openButton": "Hap",
+  "okButton": "Në rregull",
+
+  "noLabelsFound": "Nuk u gjetën etiketa",
+  "searchInputPlaceholder": "Kërko ose krijo",
+  "assigneeSelectorInviteButton": "Fto një anëtar të ri me email",
+  "labelInputPlaceholder": "Kërko ose krijo",
+  "searchLabelsPlaceholder": "Kërko etiketa...",
+  "createLabelButton": "Krijo \"{{name}}\"",
+  "manageLabelsPath": "Cilësimet → Etiketat",
+
+  "pendingInvitation": "Ftesë në Pritje",
+
+  "contextMenu": {
+    "assignToMe": "Cakto mua",
+    "moveTo": "Zhvendos në",
+    "unarchive": "Ç'arkivizo",
+    "archive": "Arkivizo",
+    "convertToSubTask": "Shndërro në Nën-Detyrë",
+    "convertToTask": "Shndërro në Detyrë",
+    "delete": "Fshi",
+    "searchByNameInputPlaceholder": "Kërko sipas emrit"
+  },
+  "setDueDate": "Cakto datën e afatit",
+  "setStartDate": "Cakto datën e fillimit",
+  "clearDueDate": "Pastro datën e afatit",
+  "clearStartDate": "Pastro datën e fillimit",
+  "dueDatePlaceholder": "Data e afatit",
+  "startDatePlaceholder": "Data e fillimit",
+
+  "emptyStates": {
+    "noTaskGroups": "Nuk u gjetën grupe detyrash",
+    "noTaskGroupsDescription": "Detyrat do të shfaqen këtu kur krijohen ose kur aplikohen filtra.",
+    "errorPrefix": "Gabim:",
+    "dragTaskFallback": "Detyrë"
+  },
+
+  "customColumns": {
+    "addCustomColumn": "Shto një kolonë të personalizuar",
+    "customColumnHeader": "Kolona e Personalizuar",
+    "customColumnSettings": "Cilësimet e kolonës së personalizuar",
+    "noCustomValue": "Asnjë vlerë",
+    "peopleField": "Fusha e njerëzve",
+    "noDate": "Asnjë datë",
+    "unsupportedField": "Lloj fushe i pambështetur",
+    
+    "modal": {
+      "addFieldTitle": "Shto fushë",
+      "editFieldTitle": "Redakto fushën",
+      "fieldTitle": "Titulli i fushës",
+      "fieldTitleRequired": "Titulli i fushës është i kërkuar",
+      "columnTitlePlaceholder": "Titulli i kolonës",
+      "type": "Lloji",
+      "deleteConfirmTitle": "Jeni i sigurt që doni të fshini këtë kolonë të personalizuar?",
+      "deleteConfirmDescription": "Kjo veprim nuk mund të zhbëhet. Të gjitha të dhënat e lidhura me këtë kolonë do të fshihen përgjithmonë.",
+      "deleteButton": "Fshi",
+      "cancelButton": "Anulo",
+      "createButton": "Krijo",
+      "updateButton": "Përditëso",
+      "createSuccessMessage": "Kolona e personalizuar u krijua me sukses",
+      "updateSuccessMessage": "Kolona e personalizuar u përditësua me sukses",
+      "deleteSuccessMessage": "Kolona e personalizuar u fshi me sukses",
+      "deleteErrorMessage": "Dështoi në fshirjen e kolonës së personalizuar",
+      "createErrorMessage": "Dështoi në krijimin e kolonës së personalizuar",
+      "updateErrorMessage": "Dështoi në përditësimin e kolonës së personalizuar"
+    },
+    
+    "fieldTypes": {
+      "people": "Njerëz",
+      "number": "Numër",
+      "date": "Data",
+      "selection": "Zgjedhje",
+      "checkbox": "Kutia e kontrollit",
+      "labels": "Etiketat",
+      "key": "Çelësi",
+      "formula": "Formula"
+    }
+  },
+
+  "indicators": {
+    "tooltips": {
+      "subtasks": "{{count}} nën-detyrë",
+      "subtasks_plural": "{{count}} nën-detyra",
+      "comments": "{{count}} koment",
+      "comments_plural": "{{count}} komente",
+      "attachments": "{{count}} bashkëngjitje",
+      "attachments_plural": "{{count}} bashkëngjitje",
+      "subscribers": "Detyra ka pajtues",
+      "dependencies": "Detyra ka varësi",
+      "recurring": "Detyrë përsëritëse"
+    }
+  }
+}

worklenz-backend/src/public/locales/alb/task-management.json

@@ -0,0 +1,21 @@
+{
+  "noTasksInGroup": "Nuk ka detyra në këtë grup",
+  "noTasksInGroupDescription": "Shtoni një detyrë për të filluar",
+  "addFirstTask": "Shtoni detyrën tuaj të parë",
+  "openTask": "Hap",
+  "subtask": "nën-detyrë",
+  "subtasks": "nën-detyra",
+  "comment": "koment",
+  "comments": "komente",
+  "attachment": "bashkëngjitje",
+  "attachments": "bashkëngjitje",
+  "enterSubtaskName": "Shkruani emrin e nën-detyrës...",
+  "add": "Shto",
+  "cancel": "Anulo",
+  "renameGroup": "Riemërto Grupin",
+  "renameStatus": "Riemërto Statusin",
+  "renamePhase": "Riemërto Fazën",
+  "changeCategory": "Ndrysho Kategorinë",
+  "clickToEditGroupName": "Kliko për të ndryshuar emrin e grupit",
+  "enterGroupName": "Shkruani emrin e grupit"
+}

worklenz-backend/src/public/locales/alb/task-template-drawer.json

@@ -0,0 +1,11 @@
+{
+  "createTaskTemplate": "Krijo Shabllon Detyre",
+  "editTaskTemplate": "Modifiko Shabllon Detyre",
+  "cancelText": "Anulo",
+  "saveText": "Ruaj",
+  "templateNameText": "Emri i Shabllonit",
+  "selectedTasks": "Detyrat e Përzgjedhura",
+  "removeTask": "Hiq",
+  "cancelButton": "Anulo",
+  "saveButton": "Ruaj"
+}

worklenz-backend/src/public/locales/alb/tasks/task-table-bulk-actions.json

@@ -0,0 +1,26 @@
+{
+  "taskSelected": "detyrë e zgjedhur",
+  "tasksSelected": "detyra të zgjedhura",
+  "changeStatus": "Ndrysho Statusin/ Prioritetin/ Fazat",
+  "changeLabel": "Ndrysho Etiketën",
+  "assignToMe": "Cakto mua",
+  "changeAssignees": "Ndrysho Përgjegjësit",
+  "archive": "Arkivo",
+  "unarchive": "Ç'arkivo",
+  "delete": "Fshi",
+  "moreOptions": "Më shumë opsione",
+  "deselectAll": "Zgjidhja të gjitha",
+  "status": "Statusi",
+  "priority": "Prioriteti",
+  "phase": "Faza",
+  "member": "Anëtar",
+  "createTaskTemplate": "Krijo Shabllon Detyre",
+  "apply": "Apliko",
+  "createLabel": "+ Krijo Etiketë",
+  "searchOrCreateLabel": "Kërko ose krijo etiketë...",
+  "hitEnterToCreate": "Shtyp Enter për të krijuar",
+  "labelExists": "Etiketa ekziston tashmë",
+  "pendingInvitation": "Ftesë në Pritje",
+  "noMatchingLabels": "Asnjë etiketë që përputhet",
+  "noLabels": "Asnjë etiketë"
+}

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

@@ -0,0 +1,19 @@
+{
+  "title": "Modifiko Shabllon Detyre",
+  "cancelText": "Anulo",
+  "saveText": "Ruaj",
+  "templateNameText": "Emri i Shabllonit",
+  "selectedTasks": "Detyrat e Përzgjedhura",
+  "removeTask": "Hiq",
+  "description": "Përshkrimi",
+  "phase": "Faza",
+  "statuses": "Statuset",
+  "priorities": "Prioritetet",
+  "labels": "Etiketa",
+  "tasks": "Detyrat",
+  "noTemplateSelected": "Asnjë shabllon i përzgjedhur",
+  "noDescription": "Pa përshkrim",
+  "worklenzTemplates": "Shabllonet Worklenz",
+  "yourTemplatesLibrary": "Biblioteka Juaj",
+  "searchTemplates": "Kërko Shabllone"
+}

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

@@ -0,0 +1,23 @@
+{
+  "bugTracking": "Gjurmimi i Gabimeve",
+  "construction": "Ndërtim",
+  "designCreative": "Dizajn & Kreativ",
+  "education": "Arsim",
+  "finance": "Financë",
+  "hrRecruiting": "Burime Njerëzore & Rekrutim",
+  "informationTechnology": "Teknologji Informacioni",
+  "legal": "Juridik",
+  "manufacturing": "Prodhim",
+  "marketing": "Marketing",
+  "nonprofit": "Jo-fitimprurës",
+  "personalUse": "Përdorim Personal",
+  "salesCRM": "Shitje & CRM",
+  "serviceConsulting": "Shërbime & Këshillim",
+  "softwareDevelopment": "Zhvillim Softueri",
+  "description": "Përshkrimi",
+  "phase": "Faza",
+  "statuses": "Statuset",
+  "priorities": "Prioritetet",
+  "labels": "Etiketa",
+  "tasks": "Detyrat"
+}

worklenz-backend/src/public/locales/alb/time-report.json

@@ -0,0 +1,44 @@
+{
+  "includeArchivedProjects": "Përfshij Projektet e Arkivuara",
+  "export": "Eksporto",
+  "timeSheet": "Fletë Kohore",
+
+  "searchByName": "Kërko sipas emrit",
+  "selectAll": "Zgjidh të Gjitha",
+  "teams": "Ekipet",
+
+  "searchByProject": "Kërko sipas emrit të projektit",
+  "projects": "Projektet",
+
+  "searchByCategory": "Kërko sipas emrit të kategorisë",
+  "categories": "Kategoritë",
+
+  "billable": "Fakturueshme",
+  "nonBillable": "Jo Fakturueshme",
+
+  "total": "Total",
+
+  "projectsTimeSheet": "Fletë Kohore e Projekteve",
+
+  "loggedTime": "Koha e Regjistruar(orë)",
+
+  "exportToExcel": "Eksporto në Excel",
+  "logged": "regjistruar",
+  "for": "për",
+
+  "membersTimeSheet": "Fletë Kohore e Anëtarëve",
+  "member": "Anëtar",
+
+  "estimatedVsActual": "Vlerësuar vs Aktual",
+  "workingDays": "Ditë Pune",
+  "manDays": "Ditë Njeri",
+  "days": "Ditë",
+  "estimatedDays": "Ditë të Vlerësuara",
+  "actualDays": "Ditë Aktuale",
+
+  "noCategories": "Nuk u gjetën kategori",
+  "noCategory": "Pa Kategori",
+  "noProjects": "Nuk u gjetën projekte",
+  "noTeams": "Nuk u gjetën ekipe",
+  "noData": "Nuk u gjetën të dhëna"
+}

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

@@ -0,0 +1,5 @@
+{
+  "title": "E paautorizuar!",
+  "subtitle": "Nuk jeni të autorizuar të hyni në këtë faqe",
+  "button": "Kthehu në Faqen Kryesore"
+}

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

@@ -0,0 +1,4 @@
+{
+  "doesNotExistText": "Entschuldigung, die von Ihnen besuchte Seite existiert nicht.",
+  "backHomeButton": "Zurück zur Startseite"
+}

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

@@ -0,0 +1,31 @@
+{
+  "continue": "Weiter",
+
+  "setupYourAccount": "Richten Sie Ihr Worklenz-Konto ein.",
+  "organizationStepTitle": "Organisation benennen",
+  "organizationStepLabel": "Wählen Sie einen Namen für Ihr Worklenz-Konto.",
+
+  "projectStepTitle": "Erstellen Sie Ihr erstes Projekt",
+  "projectStepLabel": "An welchem Projekt arbeiten Sie gerade?",
+  "projectStepPlaceholder": "z.B. Marketingplan",
+
+  "tasksStepTitle": "Erstellen Sie Ihre ersten Aufgaben",
+  "tasksStepLabel": "Geben Sie einige Aufgaben ein, die Sie in",
+  "tasksStepAddAnother": "Weitere hinzufügen",
+
+  "emailPlaceholder": "E-Mail-Adresse",
+  "invalidEmail": "Bitte geben Sie eine gültige E-Mail-Adresse ein",
+  "or": "oder",
+  "templateButton": "Aus Vorlage importieren",
+  "goBack": "Zurück",
+  "cancel": "Abbrechen",
+  "create": "Erstellen",
+  "templateDrawerTitle": "Aus Vorlagen auswählen",
+  "step3InputLabel": "Per E-Mail einladen",
+  "addAnother": "Weitere hinzufügen",
+  "skipForNow": "Jetzt überspringen",
+  "formTitle": "Erstellen Sie Ihre erste Aufgabe.",
+  "step3Title": "Laden Sie Ihr Team zur Zusammenarbeit ein",
+  "maxMembers": " (Sie können bis zu 5 Mitglieder einladen)",
+  "maxTasks": " (Sie können bis zu 5 Aufgaben erstellen)"
+}

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

@@ -0,0 +1,113 @@
+{
+  "title": "Abrechnungen",
+  "currentBill": "Aktuelle Rechnung",
+  "configuration": "Konfiguration",
+  "currentPlanDetails": "Aktuelle Plan Details",
+  "upgradePlan": "Plan upgraden",
+  "cardBodyText01": "Kostenlose Testversion",
+  "cardBodyText02": "(Ihr Testplan läuft in 1 Monat 19 Tagen ab)",
+  "redeemCode": "Gutscheincode einlösen",
+  "accountStorage": "Kontospeicher",
+  "used": "Verwendet:",
+  "remaining": "Verbleibend:",
+  "charges": "Gebühren",
+  "tooltip": "Gebühren für den aktuellen Abrechnungszeitraum",
+  "description": "Beschreibung",
+  "billingPeriod": "Abrechnungszeitraum",
+  "billStatus": "Rechnungsstatus",
+  "perUserValue": "Pro Benutzer Wert",
+  "users": "Benutzer",
+
+  "amount": "Betrag",
+  "invoices": "Rechnungen",
+  "transactionId": "Transaktions-ID",
+  "transactionDate": "Transaktionsdatum",
+  "paymentMethod": "Zahlungsmethode",
+  "status": "Status",
+  "ltdUsers": "Sie können bis zu {{ltd_users}} Benutzer hinzufügen.",
+
+  "totalSeats": "Gesamte Plätze",
+  "availableSeats": "Verfügbare Plätze",
+  "addMoreSeats": "Weitere Plätze hinzufügen",
+
+  "drawerTitle": "Gutscheincode einlösen",
+  "label": "Gutscheincode",
+  "drawerPlaceholder": "Geben Sie Ihren Gutscheincode ein",
+  "redeemSubmit": "Einreichen",
+
+  "modalTitle": "Wählen Sie den besten Plan für Ihr Team",
+  "seatLabel": "Anzahl der Plätze",
+  "freePlan": "Kostenloser Plan",
+  "startup": "Startup",
+  "business": "Business",
+  "tag": "Am beliebtesten",
+  "enterprise": "Enterprise",
+
+  "freeSubtitle": "kostenlos für immer",
+  "freeUsers": "Ideal für die persönliche Nutzung",
+  "freeText01": "100MB Speicher",
+  "freeText02": "3 Projekte",
+  "freeText03": "5 Teammitglieder",
+
+  "startupSubtitle": "PAUSCHALPREIS / Monat",
+  "startupUsers": "Bis zu 15 Benutzer",
+  "startupText01": "25GB Speicher",
+  "startupText02": "Unbegrenzte aktive Projekte",
+  "startupText03": "Zeitplan",
+  "startupText04": "Berichterstattung",
+  "startupText05": "Projekte abonnieren",
+
+  "businessSubtitle": "Benutzer / Monat",
+  "businessUsers": "16 - 200 Benutzer",
+
+  "enterpriseUsers": "200 - 500+ Benutzer",
+
+  "footerTitle": "Bitte geben Sie uns eine Kontaktnummer, unter der wir Sie erreichen können.",
+  "footerLabel": "Kontaktnummer",
+  "footerButton": "Kontaktieren Sie uns",
+
+  "redeemCodePlaceHolder": "Geben Sie Ihren Gutscheincode ein",
+  "submit": "Einreichen",
+
+  "trialPlan": "Kostenlose Testversion",
+  "trialExpireDate": "Gültig bis {{trial_expire_date}}",
+  "trialExpired": "Ihre kostenlose Testversion ist {{trial_expire_string}} abgelaufen",
+  "trialInProgress": "Ihre kostenlose Testversion läuft {{trial_expire_string}} ab",
+
+  "required": "Dieses Feld ist erforderlich",
+  "invalidCode": "Ungültiger Code",
+
+  "selectPlan": "Wählen Sie den besten Plan für Ihr Team",
+  "changeSubscriptionPlan": "Ändern Sie Ihren Abonnementplan",
+  "noOfSeats": "Anzahl der Plätze",
+  "annualPlan": "Pro - Jährlich",
+  "monthlyPlan": "Pro - Monatlich",
+  "freeForever": "Kostenlos für immer",
+  "bestForPersonalUse": "Ideal für die persönliche Nutzung",
+  "storage": "Speicher",
+  "projects": "Projekte",
+  "teamMembers": "Teammitglieder",
+  "unlimitedTeamMembers": "Unbegrenzte Teammitglieder",
+  "unlimitedActiveProjects": "Unbegrenzte aktive Projekte",
+  "schedule": "Zeitplan",
+  "reporting": "Berichterstattung",
+  "subscribeToProjects": "Projekte abonnieren",
+  "billedAnnually": "Jährlich abgerechnet",
+  "billedMonthly": "Monatlich abgerechnet",
+
+  "pausePlan": "Plan pausieren",
+  "resumePlan": "Plan fortsetzen",
+  "changePlan": "Plan ändern",
+  "cancelPlan": "Plan kündigen",
+
+  "perMonthPerUser": "pro Benutzer/Monat",
+  "viewInvoice": "Rechnung anzeigen",
+  "switchToFreePlan": "Wechsel zum kostenlosen Plan",
+
+  "expirestoday": "heute",
+  "expirestomorrow": "morgen",
+  "expiredDaysAgo": "vor {{days}} Tagen",
+
+  "continueWith": "Fortfahren mit {{plan}}",
+  "changeToPlan": "Wechseln zu {{plan}}"
+}

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

@@ -0,0 +1,8 @@
+{
+  "overview": "Übersicht",
+  "name": "Organisationsname",
+  "owner": "Organisationsinhaber",
+  "admins": "Organisationsadministratoren",
+  "contactNumber": "Kontaktnummer hinzufügen",
+  "edit": "Bearbeiten"
+}