Merge branch 'main' of https://github.com/Worklenz/worklenz into feature/task-activities-by-user

2025-07-14 12:46:18 +05:30
parent 7c04598264 e87f33dcc8
commit 5b1cbb0c46
1166 changed files with 82289 additions and 15230 deletions
--- a/worklenz-backend/src/app.ts
+++ b/worklenz-backend/src/app.ts
@@ -6,7 +6,7 @@ import logger from "morgan";
 import helmet from "helmet";
 import compression from "compression";
 import passport from "passport";
-import csurf from "csurf";
+import { csrfSync } from "csrf-sync";
 import rateLimit from "express-rate-limit";
 import cors from "cors";
 import flash from "connect-flash";
@@ -112,17 +112,13 @@ function isLoggedIn(req: Request, _res: Response, next: NextFunction) {
  return req.user ? next() : next(createError(401));
 }

-// CSRF configuration
-const csrfProtection = csurf({
-  cookie: {
-    key: "XSRF-TOKEN",
-    path: "/",
-    httpOnly: false,
-    secure: isProduction(), // Only secure in production
-    sameSite: isProduction() ? "none" : "lax", // Different settings for dev vs prod
-    domain: isProduction() ? ".worklenz.com" : undefined // Only set domain in production
-  },
-  ignoreMethods: ["HEAD", "OPTIONS"]
+// CSRF configuration using csrf-sync for session-based authentication
+const {
+  invalidCsrfTokenError,
+  generateToken,
+  csrfSynchronisedProtection,
+} = csrfSync({
+  getTokenFromRequest: (req: Request) => req.headers["x-csrf-token"] as string || (req.body && req.body["_csrf"])
 });

 // Apply CSRF selectively (exclude webhooks and public routes)
@@ -135,38 +131,25 @@ app.use((req, res, next) => {
  ) {
    next();
  } else {
-    csrfProtection(req, res, next);
+    csrfSynchronisedProtection(req, res, next);
  }
 });

-// Set CSRF token cookie
+// Set CSRF token method on request object for compatibility
 app.use((req: Request, res: Response, next: NextFunction) => {
-  if (req.csrfToken) {
-    const token = req.csrfToken();
-    res.cookie("XSRF-TOKEN", token, {
-      httpOnly: false,
-      secure: isProduction(),
-      sameSite: isProduction() ? "none" : "lax",
-      domain: isProduction() ? ".worklenz.com" : undefined,
-      path: "/"
-    });
+  // Add csrfToken method to request object for compatibility
+  if (!req.csrfToken && generateToken) {
+    req.csrfToken = (overwrite?: boolean) => generateToken(req, overwrite);
  }
  next();
 });

 // CSRF token refresh endpoint
 app.get("/csrf-token", (req: Request, res: Response) => {
-  if (req.csrfToken) {
-    const token = req.csrfToken();
-    res.cookie("XSRF-TOKEN", token, {
-      httpOnly: false,
-      secure: isProduction(),
-      sameSite: isProduction() ? "none" : "lax",
-      domain: isProduction() ? ".worklenz.com" : undefined,
-      path: "/"
-    });
-    res.status(200).json({ done: true, message: "CSRF token refreshed" });
-  } else {
+  try {
+    const token = generateToken(req);
+    res.status(200).json({ done: true, message: "CSRF token refreshed", token });
+  } catch (error) {
    res.status(500).json({ done: false, message: "Failed to generate CSRF token" });
  }
 });
@@ -219,7 +202,7 @@ if (isInternalServer()) {

 // CSRF error handler
 app.use((err: any, req: Request, res: Response, next: NextFunction) => {
-  if (err.code === "EBADCSRFTOKEN") {
+  if (err === invalidCsrfTokenError) {
    return res.status(403).json({
      done: false,
      message: "Invalid CSRF token",
--- a/worklenz-backend/src/controllers/admin-center-controller.ts
+++ b/worklenz-backend/src/controllers/admin-center-controller.ts
@@ -5,7 +5,7 @@ import db from "../config/db";
 import {ServerResponse} from "../models/server-response";
 import WorklenzControllerBase from "./worklenz-controller-base";
 import HandleExceptions from "../decorators/handle-exceptions";
-import {calculateMonthDays, getColor, megabytesToBytes} from "../shared/utils";
+import {calculateMonthDays, getColor, log_error, megabytesToBytes} from "../shared/utils";
 import moment from "moment";
 import {calculateStorage} from "../shared/s3";
 import {checkTeamSubscriptionStatus, getActiveTeamMemberCount, getCurrentProjectsCount, getFreePlanSettings, getOwnerIdByTeam, getTeamMemberCount, getUsedStorage} from "../shared/paddle-utils";
@@ -232,7 +232,11 @@ export default class AdminCenterController extends WorklenzControllerBase {
                                     FROM team_member_info_view
                                     WHERE team_member_info_view.team_member_id = tm.id),
                                    role_id,
-                                    r.name AS role_name
+                                    r.name AS role_name,
+                                    EXISTS(SELECT email
+                                           FROM email_invitations
+                                           WHERE team_member_id = tm.id
+                                             AND email_invitations.team_id = tm.team_id) AS pending_invitation
                             FROM team_members tm
                                    LEFT JOIN users u on tm.user_id = u.id
                                    LEFT JOIN roles r on tm.role_id = r.id
@@ -255,22 +259,33 @@ export default class AdminCenterController extends WorklenzControllerBase {
    const {id} = req.params;
    const {name, teamMembers} = req.body;

-    const updateNameQuery = `UPDATE teams
-                             SET name = $1
-                             WHERE id = $2;`;
-    await db.query(updateNameQuery, [name, id]);
+    try {
+      // Update team name
+      const updateNameQuery = `UPDATE teams SET name = $1 WHERE id = $2 RETURNING id;`;
+      const nameResult = await db.query(updateNameQuery, [name, id]);
+      
+      if (!nameResult.rows.length) {
+        return res.status(404).send(new ServerResponse(false, null, "Team not found"));
+      }

-    if (teamMembers.length) {
-      teamMembers.forEach(async (element: { role_name: string; user_id: string; }) => {
-        const q = `UPDATE team_members
-                   SET role_id = (SELECT id FROM roles WHERE roles.team_id = $1 AND name = $2)
-                   WHERE user_id = $3
-                     AND team_id = $1;`;
-        await db.query(q, [id, element.role_name, element.user_id]);
-      });
+      // Update team member roles if provided
+      if (teamMembers?.length) {
+        // Use Promise.all to handle all role updates concurrently
+        await Promise.all(teamMembers.map(async (member: { role_name: string; user_id: string; }) => {
+          const roleQuery = `
+            UPDATE team_members 
+            SET role_id = (SELECT id FROM roles WHERE roles.team_id = $1 AND name = $2)
+            WHERE user_id = $3 AND team_id = $1
+            RETURNING id;`;
+          await db.query(roleQuery, [id, member.role_name, member.user_id]);
+        }));
+      }
+
+      return res.status(200).send(new ServerResponse(true, null, "Team updated successfully"));
+    } catch (error) {
+      log_error("Error updating team:", error);
+      return res.status(500).send(new ServerResponse(false, null, "Failed to update team"));
    }
-
-    return res.status(200).send(new ServerResponse(true, [], "Team updated successfully"));
  }

  @HandleExceptions()
--- a/worklenz-backend/src/controllers/auth-controller.ts
+++ b/worklenz-backend/src/controllers/auth-controller.ts
@@ -35,8 +35,18 @@ export default class AuthController extends WorklenzControllerBase {
    const auth_error = errors.length > 0 ? errors[0] : null;
    const message = messages.length > 0 ? messages[0] : null;

-    const midTitle = req.query.strategy === "login" ? "Login Failed!" : "Signup Failed!";
-    const title = req.query.strategy ? midTitle : null;
+    // Determine title based on authentication status and strategy
+    let title = null;
+    if (req.query.strategy) {
+      if (auth_error) {
+        // Show failure title only when there's an actual error
+        title = req.query.strategy === "login" ? "Login Failed!" : "Signup Failed!";
+      } else if (req.isAuthenticated() && message) {
+        // Show success title when authenticated and there's a success message
+        title = req.query.strategy === "login" ? "Login Successful!" : "Signup Successful!";
+      }
+      // If no error and not authenticated, don't show any title (this might be a redirect without completion)
+    }

    if (req.user)
      req.user.build_v = FileConstants.getRelease();
--- a/worklenz-backend/src/controllers/home-page-controller.ts
+++ b/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;
  }
--- a/worklenz-backend/src/controllers/project-insights-controller.ts
+++ b/worklenz-backend/src/controllers/project-insights-controller.ts
@@ -322,7 +322,7 @@ export default class ProjectInsightsController extends WorklenzControllerBase {
             (SELECT get_task_assignees(tasks.id)) AS assignees
      FROM tasks
             JOIN work_log ON work_log.task_id = tasks.id
-      WHERE project_id = $1
+      WHERE project_id = $1 AND total_minutes <> 0 AND (total_minutes * 60) <> work_log.total_time_spent
        AND CASE
              WHEN ($2 IS TRUE) THEN project_id IS NOT NULL
              ELSE archived IS FALSE END
--- a/worklenz-backend/src/controllers/projects-controller.ts
+++ b/worklenz-backend/src/controllers/projects-controller.ts
@@ -408,6 +408,9 @@ export default class ProjectsController extends WorklenzControllerBase {
             sps.color_code AS status_color,
             sps.icon AS status_icon,
             (SELECT name FROM clients WHERE id = projects.client_id) AS client_name,
+             projects.use_manual_progress,
+             projects.use_weighted_progress,
+             projects.use_time_progress,

             (SELECT COALESCE(ROW_TO_JSON(pm), '{}'::JSON)
                    FROM (SELECT team_member_id AS id,
@@ -753,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: [] }));
+  }
+
 }
--- a/worklenz-backend/src/controllers/reporting/reporting-allocation-controller.ts
+++ b/worklenz-backend/src/controllers/reporting/reporting-allocation-controller.ts
@@ -408,6 +408,65 @@ export default class ReportingAllocationController extends ReportingControllerBa

    const { duration, date_range } = req.body;

+    // Calculate the date range (start and end)
+    let startDate: moment.Moment;
+    let endDate: moment.Moment;
+    if (date_range && date_range.length === 2) {
+      startDate = moment(date_range[0]);
+      endDate = moment(date_range[1]);
+    } else if (duration === DATE_RANGES.ALL_TIME) {
+      // Fetch the earliest start_date (or created_at if null) from selected projects
+      const minDateQuery = `SELECT MIN(COALESCE(start_date, created_at)) as min_date FROM projects WHERE id IN (${projectIds})`;
+      const minDateResult = await db.query(minDateQuery, []);
+      const minDate = minDateResult.rows[0]?.min_date;
+      startDate = minDate ? moment(minDate) : moment('2000-01-01');
+      endDate = moment();
+    } else {
+      switch (duration) {
+        case DATE_RANGES.YESTERDAY:
+          startDate = moment().subtract(1, "day");
+          endDate = moment().subtract(1, "day");
+          break;
+        case DATE_RANGES.LAST_WEEK:
+          startDate = moment().subtract(1, "week").startOf("isoWeek");
+          endDate = moment().subtract(1, "week").endOf("isoWeek");
+          break;
+        case DATE_RANGES.LAST_MONTH:
+          startDate = moment().subtract(1, "month").startOf("month");
+          endDate = moment().subtract(1, "month").endOf("month");
+          break;
+        case DATE_RANGES.LAST_QUARTER:
+          startDate = moment().subtract(3, "months").startOf("quarter");
+          endDate = moment().subtract(1, "quarter").endOf("quarter");
+          break;
+        default:
+          startDate = moment().startOf("day");
+          endDate = moment().endOf("day");
+      }
+    }
+
+    // Count only weekdays (Mon-Fri) in the period
+    let workingDays = 0;
+    let current = startDate.clone();
+    while (current.isSameOrBefore(endDate, 'day')) {
+      const day = current.isoWeekday();
+      if (day >= 1 && day <= 5) workingDays++;
+      current.add(1, 'day');
+    }
+
+    // Get hours_per_day for all selected projects
+    const projectHoursQuery = `SELECT id, hours_per_day FROM projects WHERE id IN (${projectIds})`;
+    const projectHoursResult = await db.query(projectHoursQuery, []);
+    const projectHoursMap: Record<string, number> = {};
+    for (const row of projectHoursResult.rows) {
+      projectHoursMap[row.id] = row.hours_per_day || 8;
+    }
+    // Sum total working hours for all selected projects
+    let totalWorkingHours = 0;
+    for (const pid of Object.keys(projectHoursMap)) {
+      totalWorkingHours += workingDays * projectHoursMap[pid];
+    }
+
    const durationClause = this.getDateRangeClause(duration || DATE_RANGES.LAST_WEEK, date_range);
    const archivedClause = archived
      ? ""
@@ -430,6 +489,12 @@ export default class ReportingAllocationController extends ReportingControllerBa
    for (const member of result.rows) {
      member.value = member.logged_time ? parseFloat(moment.duration(member.logged_time, "seconds").asHours().toFixed(2)) : 0;
      member.color_code = getColor(member.name);
+      member.total_working_hours = totalWorkingHours;
+      member.utilization_percent = (totalWorkingHours > 0 && member.logged_time) ? ((parseFloat(member.logged_time) / (totalWorkingHours * 3600)) * 100).toFixed(2) : '0.00';
+      member.utilized_hours = member.logged_time ? (parseFloat(member.logged_time) / 3600).toFixed(2) : '0.00';
+      // Over/under utilized hours: utilized_hours - total_working_hours
+      const overUnder = member.utilized_hours && member.total_working_hours ? (parseFloat(member.utilized_hours) - member.total_working_hours) : 0;
+      member.over_under_utilized_hours = overUnder.toFixed(2);
    }

    return res.status(200).send(new ServerResponse(true, result.rows));
--- a/worklenz-backend/src/controllers/task-phases-controller.ts
+++ b/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;
--- a/worklenz-backend/src/controllers/task-statuses-controller.ts
+++ b/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);`;
--- a/worklenz-backend/src/controllers/tasks-controller-base.ts
+++ b/worklenz-backend/src/controllers/tasks-controller-base.ts
@@ -1,6 +1,6 @@
 import WorklenzControllerBase from "./worklenz-controller-base";
-import {getColor} from "../shared/utils";
-import {PriorityColorCodes, TASK_PRIORITY_COLOR_ALPHA, TASK_STATUS_COLOR_ALPHA} from "../shared/constants";
+import { getColor } from "../shared/utils";
+import { PriorityColorCodes, TASK_PRIORITY_COLOR_ALPHA, TASK_STATUS_COLOR_ALPHA } from "../shared/constants";
 import moment from "moment/moment";

 export const GroupBy = {
@@ -32,10 +32,46 @@ export default class TasksControllerBase extends WorklenzControllerBase {
  }

  public static updateTaskViewModel(task: any) {
-    task.progress = ~~(task.total_minutes_spent / task.total_minutes * 100);
+    // For parent tasks (with subtasks), always use calculated progress from subtasks
+    if (task.sub_tasks_count > 0) {
+      // Ensure progress matches complete_ratio for consistency
+      task.progress = task.complete_ratio || 0;
+
+      // Important: Parent tasks should not have manual progress
+      // If they somehow do, reset it
+      if (task.manual_progress) {
+        task.manual_progress = false;
+        task.progress_value = null;
+      }
+    }
+    // For tasks without subtasks, respect manual progress if set
+    else if (task.manual_progress === true && task.progress_value !== null && task.progress_value !== undefined) {
+      // For manually set progress, use that value directly
+      task.progress = parseInt(task.progress_value);
+      task.complete_ratio = parseInt(task.progress_value);
+    }
+    // For tasks with no subtasks and no manual progress
+    else {
+      // Only calculate progress based on time if time-based progress is enabled for the project
+      if (task.project_use_time_progress && task.total_minutes_spent && task.total_minutes) {
+        // 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;
+    }
+
+    // Ensure numeric values
+    task.progress = parseInt(task.progress) || 0;
+    task.complete_ratio = parseInt(task.complete_ratio) || 0;
+
    task.overdue = task.total_minutes < task.total_minutes_spent;

-    task.time_spent = {hours: ~~(task.total_minutes_spent / 60), minutes: task.total_minutes_spent % 60};
+    task.time_spent = { hours: ~~(task.total_minutes_spent / 60), minutes: task.total_minutes_spent % 60 };

    task.comments_count = Number(task.comments_count) ? +task.comments_count : 0;
    task.attachments_count = Number(task.attachments_count) ? +task.attachments_count : 0;
@@ -73,9 +109,9 @@ export default class TasksControllerBase extends WorklenzControllerBase {
    if (task.timer_start_time)
      task.timer_start_time = moment(task.timer_start_time).valueOf();

+    // Set completed_count and total_tasks_count regardless of progress calculation method
    const totalCompleted = (+task.completed_sub_tasks + +task.parent_task_completed) || 0;
-    const totalTasks = +task.sub_tasks_count || 0; // if needed add +1 for parent
-    task.complete_ratio = TasksControllerBase.calculateTaskCompleteRatio(totalCompleted, totalTasks);
+    const totalTasks = +task.sub_tasks_count || 0;
    task.completed_count = totalCompleted;
    task.total_tasks_count = totalTasks;

--- a/worklenz-backend/src/controllers/tasks-controller-v2.ts
+++ b/worklenz-backend/src/controllers/tasks-controller-v2.ts
@@ -97,15 +97,19 @@ export default class TasksControllerV2 extends TasksControllerBase {
    try {
      const result = await db.query("SELECT get_task_complete_ratio($1) AS info;", [taskId]);
      const [data] = result.rows;
-      data.info.ratio = +data.info.ratio.toFixed();
-      return data.info;
+      if (data && data.info && data.info.ratio !== undefined) {
+        data.info.ratio = +((data.info.ratio || 0).toFixed());
+        return data.info;
+      }
+      return null;
    } catch (error) {
+      log_error(`Error in getTaskCompleteRatio: ${error}`);
      return null;
    }
  }

  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;
@@ -126,20 +130,20 @@ export default class TasksControllerV2 extends TasksControllerBase {
    const filterByAssignee = TasksControllerV2.getFilterByAssignee(options.filterBy as string);
    // Returns statuses of each task as a json array if filterBy === "member"
    const statusesQuery = TasksControllerV2.getStatusesQuery(options.filterBy as string);
-    
+
    // Custom columns data query
-    const customColumnsQuery = options.customColumns 
+    const customColumnsQuery = options.customColumns
      ? `, (SELECT COALESCE(
            jsonb_object_agg(
-              custom_cols.key, 
+              custom_cols.key,
              custom_cols.value
-            ), 
+            ),
            '{}'::JSONB
          )
          FROM (
-            SELECT 
+            SELECT
              cc.key,
-              CASE 
+              CASE
                WHEN ccv.text_value IS NOT NULL THEN to_jsonb(ccv.text_value)
                WHEN ccv.number_value IS NOT NULL THEN to_jsonb(ccv.number_value)
                WHEN ccv.boolean_value IS NOT NULL THEN to_jsonb(ccv.boolean_value)
@@ -192,6 +196,13 @@ export default class TasksControllerV2 extends TasksControllerBase {
             t.archived,
             t.description,
             t.sort_order,
+             t.progress_value,
+             t.manual_progress,
+             t.weight,
+             (SELECT use_manual_progress FROM projects WHERE id = t.project_id) AS project_use_manual_progress,
+             (SELECT use_weighted_progress FROM projects WHERE id = t.project_id) AS project_use_weighted_progress,
+             (SELECT use_time_progress FROM projects WHERE id = t.project_id) AS project_use_time_progress,
+             (SELECT get_task_complete_ratio(t.id)->>'ratio') AS complete_ratio,

             (SELECT phase_id FROM task_phase WHERE task_id = t.id) AS phase_id,
             (SELECT name
@@ -315,9 +326,23 @@ export default class TasksControllerV2 extends TasksControllerBase {

  @HandleExceptions()
  public static async getList(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    const startTime = performance.now();
+    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;
    const groupBy = (req.query.group || GroupBy.STATUS) as string;
-    
+
    // Add customColumns flag to query params
    req.query.customColumns = "true";

@@ -334,7 +359,7 @@ export default class TasksControllerV2 extends TasksControllerBase {
      return g;
    }, {});

-    this.updateMapByGroup(tasks, groupBy, map);
+    await this.updateMapByGroup(tasks, groupBy, map);

    const updatedGroups = Object.keys(map).map(key => {
      const group = map[key];
@@ -350,15 +375,31 @@ 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));
  }

-  public static updateMapByGroup(tasks: any[], groupBy: string, map: { [p: string]: ITaskGroup }) {
+  public static async updateMapByGroup(tasks: any[], groupBy: string, map: { [p: string]: ITaskGroup }) {
    let index = 0;
    const unmapped = [];
+
+    // PERFORMANCE OPTIMIZATION: Remove expensive individual DB calls for each task
+    // Progress values are already calculated and included in the main query
+    // No need to make additional database calls here
+
+    // Process tasks with their already-calculated progress values
    for (const task of tasks) {
      task.index = index++;
      TasksControllerV2.updateTaskViewModel(task);
+
      if (groupBy === GroupBy.STATUS) {
        map[task.status]?.tasks.push(task);
      } else if (groupBy === GroupBy.PRIORITY) {
@@ -394,11 +435,25 @@ export default class TasksControllerV2 extends TasksControllerBase {

  @HandleExceptions()
  public static async getTasksOnly(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    const startTime = performance.now();
+    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;
-    
+
    // Add customColumns flag to query params
    req.query.customColumns = "true";
-    
+
    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);
@@ -410,11 +465,25 @@ export default class TasksControllerV2 extends TasksControllerBase {
      [data] = result.rows;
    } else { // else we return a flat list of tasks
      data = [...result.rows];
+
+      // PERFORMANCE OPTIMIZATION: Remove expensive individual DB calls for each task
+      // Progress values are already calculated and included in the main query via get_task_complete_ratio
+      // The database query already includes complete_ratio, so no need for additional calls
+
      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));
  }

@@ -443,6 +512,53 @@ export default class TasksControllerV2 extends TasksControllerBase {
    return res.status(200).send(new ServerResponse(true, task));
  }

+  @HandleExceptions()
+  public static async resetParentTaskManualProgress(parentTaskId: string): Promise<void> {
+    try {
+      // Check if this task has subtasks
+      const subTasksResult = await db.query(
+        "SELECT COUNT(*) as subtask_count FROM tasks WHERE parent_task_id = $1 AND archived IS FALSE",
+        [parentTaskId]
+      );
+
+      const subtaskCount = parseInt(subTasksResult.rows[0]?.subtask_count || "0");
+
+      // If it has subtasks, reset the manual_progress flag to false
+      if (subtaskCount > 0) {
+        await db.query(
+          "UPDATE tasks SET manual_progress = false WHERE id = $1",
+          [parentTaskId]
+        );
+        console.log(`Reset manual progress for parent task ${parentTaskId} with ${subtaskCount} subtasks`);
+
+        // Get the project settings to determine which calculation method to use
+        const projectResult = await db.query(
+          "SELECT project_id FROM tasks WHERE id = $1",
+          [parentTaskId]
+        );
+
+        const projectId = projectResult.rows[0]?.project_id;
+
+        if (projectId) {
+          // Recalculate the parent task's progress based on its subtasks
+          const progressResult = await db.query(
+            "SELECT get_task_complete_ratio($1) AS ratio",
+            [parentTaskId]
+          );
+
+          const progressRatio = progressResult.rows[0]?.ratio?.ratio || 0;
+
+          // Emit the updated progress value to all clients
+          // Note: We don't have socket context here, so we can't directly emit
+          // This will be picked up on the next client refresh
+          console.log(`Recalculated progress for parent task ${parentTaskId}: ${progressRatio}%`);
+        }
+      }
+    } catch (error) {
+      log_error(`Error resetting parent task manual progress: ${error}`);
+    }
+  }
+
  @HandleExceptions()
  public static async convertToSubtask(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {

@@ -483,6 +599,11 @@ export default class TasksControllerV2 extends TasksControllerBase {
      : [req.body.id, req.body.project_id, req.body.parent_task_id, req.body.to_group_id];
    await db.query(q, params);

+    // Reset the parent task's manual progress when converting a task to a subtask
+    if (req.body.parent_task_id) {
+      await this.resetParentTaskManualProgress(req.body.parent_task_id);
+    }
+
    const result = await db.query("SELECT get_single_task($1) AS task;", [req.body.id]);
    const [data] = result.rows;
    const model = TasksControllerV2.updateTaskViewModel(data.task);
@@ -504,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(
@@ -633,27 +769,27 @@ export default class TasksControllerV2 extends TasksControllerBase {

    // Get column information
    const columnQuery = `
-      SELECT id, field_type 
-      FROM cc_custom_columns 
+      SELECT id, field_type
+      FROM cc_custom_columns
      WHERE project_id = $1 AND key = $2
    `;
    const columnResult = await db.query(columnQuery, [project_id, column_key]);
-    
+
    if (columnResult.rowCount === 0) {
      return res.status(404).send(new ServerResponse(false, "Custom column not found"));
    }
-    
+
    const column = columnResult.rows[0];
    const columnId = column.id;
    const fieldType = column.field_type;
-    
+
    // Determine which value field to use based on the field_type
    let textValue = null;
    let numberValue = null;
    let dateValue = null;
    let booleanValue = null;
    let jsonValue = null;
-    
+
    switch (fieldType) {
      case "number":
        numberValue = parseFloat(String(value));
@@ -670,58 +806,585 @@ export default class TasksControllerV2 extends TasksControllerBase {
      default:
        textValue = String(value);
    }
-    
+
    // Check if a value already exists
    const existingValueQuery = `
-      SELECT id 
-      FROM cc_column_values 
+      SELECT id
+      FROM cc_column_values
      WHERE task_id = $1 AND column_id = $2
    `;
    const existingValueResult = await db.query(existingValueQuery, [taskId, columnId]);
-    
+
    if (existingValueResult.rowCount && existingValueResult.rowCount > 0) {
      // Update existing value
      const updateQuery = `
-        UPDATE cc_column_values 
-        SET text_value = $1, 
-            number_value = $2, 
-            date_value = $3, 
-            boolean_value = $4, 
-            json_value = $5, 
-            updated_at = NOW() 
+        UPDATE cc_column_values
+        SET text_value = $1,
+            number_value = $2,
+            date_value = $3,
+            boolean_value = $4,
+            json_value = $5,
+            updated_at = NOW()
        WHERE task_id = $6 AND column_id = $7
      `;
      await db.query(updateQuery, [
-        textValue, 
-        numberValue, 
-        dateValue, 
-        booleanValue, 
-        jsonValue, 
-        taskId, 
+        textValue,
+        numberValue,
+        dateValue,
+        booleanValue,
+        jsonValue,
+        taskId,
        columnId
      ]);
    } else {
      // Insert new value
      const insertQuery = `
-        INSERT INTO cc_column_values 
-        (task_id, column_id, text_value, number_value, date_value, boolean_value, json_value, created_at, updated_at) 
+        INSERT INTO cc_column_values
+        (task_id, column_id, text_value, number_value, date_value, boolean_value, json_value, created_at, updated_at)
        VALUES ($1, $2, $3, $4, $5, $6, $7, NOW(), NOW())
      `;
      await db.query(insertQuery, [
-        taskId, 
-        columnId, 
-        textValue, 
-        numberValue, 
-        dateValue, 
-        booleanValue, 
+        taskId,
+        columnId,
+        textValue,
+        numberValue,
+        dateValue,
+        booleanValue,
        jsonValue
      ]);
    }

-    return res.status(200).send(new ServerResponse(true, { 
+    return res.status(200).send(new ServerResponse(true, {
      task_id: taskId,
      column_key,
      value
    }));
  }
+
+  public static async refreshProjectTaskProgressValues(projectId: string): Promise<void> {
+    try {
+      // Run the recalculate_all_task_progress function only for tasks in this project
+      const query = `
+      DO $$
+      BEGIN
+        -- First, reset manual_progress flag for all tasks that have subtasks within this project
+        UPDATE tasks AS t
+        SET manual_progress = FALSE
+        WHERE project_id = '${projectId}'
+        AND EXISTS (
+            SELECT 1
+            FROM tasks
+            WHERE parent_task_id = t.id
+            AND archived IS FALSE
+        );
+
+        -- Start recalculation from leaf tasks (no subtasks) and propagate upward
+        -- This ensures calculations are done in the right order
+        WITH RECURSIVE task_hierarchy AS (
+            -- Base case: Start with all leaf tasks (no subtasks) in this project
+            SELECT
+                id,
+                parent_task_id,
+                0 AS level
+            FROM tasks
+            WHERE project_id = '${projectId}'
+            AND NOT EXISTS (
+                SELECT 1 FROM tasks AS sub
+                WHERE sub.parent_task_id = tasks.id
+                AND sub.archived IS FALSE
+            )
+            AND archived IS FALSE
+
+            UNION ALL
+
+            -- Recursive case: Move up to parent tasks, but only after processing all their children
+            SELECT
+                t.id,
+                t.parent_task_id,
+                th.level + 1
+            FROM tasks t
+            JOIN task_hierarchy th ON t.id = th.parent_task_id
+            WHERE t.archived IS FALSE
+        )
+        -- Sort by level to ensure we calculate in the right order (leaves first, then parents)
+        UPDATE tasks
+        SET progress_value = (SELECT (get_task_complete_ratio(tasks.id)->>'ratio')::FLOAT)
+        FROM (
+            SELECT id, level
+            FROM task_hierarchy
+            ORDER BY level
+        ) AS ordered_tasks
+        WHERE tasks.id = ordered_tasks.id
+        AND tasks.project_id = '${projectId}'
+        AND (manual_progress IS FALSE OR manual_progress IS NULL);
+      END $$;
+      `;
+
+      await db.query(query);
+      console.log(`Finished refreshing progress values for project ${projectId}`);
+    } catch (error) {
+      log_error("Error refreshing project task progress values", error);
+    }
+  }
+
+  public static async updateTaskProgress(taskId: string): Promise<void> {
+    try {
+      // Calculate the task's progress using get_task_complete_ratio
+      const result = await db.query("SELECT get_task_complete_ratio($1) AS info;", [taskId]);
+      const [data] = result.rows;
+
+      if (data && data.info && data.info.ratio !== undefined) {
+        const progressValue = +((data.info.ratio || 0).toFixed());
+
+        // Update the task's progress_value in the database
+        await db.query(
+          "UPDATE tasks SET progress_value = $1 WHERE id = $2",
+          [progressValue, taskId]
+        );
+
+        console.log(`Updated progress for task ${taskId} to ${progressValue}%`);
+
+        // If this task has a parent, update the parent's progress as well
+        const parentResult = await db.query(
+          "SELECT parent_task_id FROM tasks WHERE id = $1",
+          [taskId]
+        );
+
+        if (parentResult.rows.length > 0 && parentResult.rows[0].parent_task_id) {
+          await this.updateTaskProgress(parentResult.rows[0].parent_task_id);
+        }
+      }
+    } catch (error) {
+      log_error(`Error updating task progress: ${error}`);
+    }
+  }
+
+  // Add this method to update progress when a task's weight is changed
+  public static async updateTaskWeight(taskId: string, weight: number): Promise<void> {
+    try {
+      // Update the task's weight
+      await db.query(
+        "UPDATE tasks SET weight = $1 WHERE id = $2",
+        [weight, taskId]
+      );
+
+      // Get the parent task ID
+      const parentResult = await db.query(
+        "SELECT parent_task_id FROM tasks WHERE id = $1",
+        [taskId]
+      );
+
+      // If this task has a parent, update the parent's progress
+      if (parentResult.rows.length > 0 && parentResult.rows[0].parent_task_id) {
+        await this.updateTaskProgress(parentResult.rows[0].parent_task_id);
+      }
+    } catch (error) {
+      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"));
+    }
+  }
 }
--- a/worklenz-backend/src/controllers/worklenz-controller-base.ts
+++ b/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
--- a/worklenz-backend/src/cron_jobs/index.ts
+++ b/worklenz-backend/src/cron_jobs/index.ts
@@ -1,11 +1,11 @@
 import {startDailyDigestJob} from "./daily-digest-job";
 import {startNotificationsJob} from "./notifications-job";
 import {startProjectDigestJob} from "./project-digest-job";
-import { startRecurringTasksJob } from "./recurring-tasks";
+import {startRecurringTasksJob} from "./recurring-tasks";

 export function startCronJobs() {
  startNotificationsJob();
  startDailyDigestJob();
  startProjectDigestJob();
-  // startRecurringTasksJob();
+  if (process.env.ENABLE_RECURRING_JOBS === "true") startRecurringTasksJob();
 }
--- a/worklenz-backend/src/cron_jobs/recurring-tasks.ts
+++ b/worklenz-backend/src/cron_jobs/recurring-tasks.ts
@@ -7,12 +7,90 @@ import TasksController from "../controllers/tasks-controller";

 // At 11:00+00 (4.30pm+530) on every day-of-month if it's on every day-of-week from Monday through Friday.
 // const TIME = "0 11 */1 * 1-5";
-const TIME = "*/2 * * * *";
+const TIME = process.env.RECURRING_JOBS_INTERVAL || "0 11 */1 * 1-5";
 const TIME_FORMAT = "YYYY-MM-DD";
 // const TIME = "0 0 * * *"; // Runs at midnight every day

 const log = (value: any) => console.log("recurring-task-cron-job:", value);

+// Define future limits for different schedule types
+// More conservative limits to prevent task list clutter
+const FUTURE_LIMITS = {
+  daily: moment.duration(3, "days"),
+  weekly: moment.duration(1, "week"),
+  monthly: moment.duration(1, "month"),
+  every_x_days: (interval: number) => moment.duration(interval, "days"),
+  every_x_weeks: (interval: number) => moment.duration(interval, "weeks"),
+  every_x_months: (interval: number) => moment.duration(interval, "months")
+};
+
+// Helper function to get the future limit based on schedule type
+function getFutureLimit(scheduleType: string, interval?: number): moment.Duration {
+  switch (scheduleType) {
+    case "daily":
+      return FUTURE_LIMITS.daily;
+    case "weekly":
+      return FUTURE_LIMITS.weekly;
+    case "monthly":
+      return FUTURE_LIMITS.monthly;
+    case "every_x_days":
+      return FUTURE_LIMITS.every_x_days(interval || 1);
+    case "every_x_weeks":
+      return FUTURE_LIMITS.every_x_weeks(interval || 1);
+    case "every_x_months":
+      return FUTURE_LIMITS.every_x_months(interval || 1);
+    default:
+      return moment.duration(3, "days"); // Default to 3 days
+  }
+}
+
+// Helper function to batch create tasks
+async function createBatchTasks(template: ITaskTemplate & IRecurringSchedule, endDates: moment.Moment[]) {
+  const createdTasks = [];
+  
+  for (const nextEndDate of endDates) {
+    const existingTaskQuery = `
+      SELECT id FROM tasks 
+      WHERE schedule_id = $1 AND end_date::DATE = $2::DATE;
+    `;
+    const existingTaskResult = await db.query(existingTaskQuery, [template.schedule_id, nextEndDate.format(TIME_FORMAT)]);
+
+    if (existingTaskResult.rows.length === 0) {
+      const createTaskQuery = `SELECT create_quick_task($1::json) as task;`;
+      const taskData = {
+        name: template.name,
+        priority_id: template.priority_id,
+        project_id: template.project_id,
+        reporter_id: template.reporter_id,
+        status_id: template.status_id || null,
+        end_date: nextEndDate.format(TIME_FORMAT),
+        schedule_id: template.schedule_id
+      };
+      const createTaskResult = await db.query(createTaskQuery, [JSON.stringify(taskData)]);
+      const createdTask = createTaskResult.rows[0].task;
+
+      if (createdTask) {
+        createdTasks.push(createdTask);
+
+        for (const assignee of template.assignees) {
+          await TasksController.createTaskBulkAssignees(assignee.team_member_id, template.project_id, createdTask.id, assignee.assigned_by); 
+        }
+
+        for (const label of template.labels) {
+          const q = `SELECT add_or_remove_task_label($1, $2) AS labels;`;
+          await db.query(q, [createdTask.id, label.label_id]);
+        }
+        
+        console.log(`Created task for template ${template.name} with end date ${nextEndDate.format(TIME_FORMAT)}`);
+      }
+    } else {
+      console.log(`Skipped creating task for template ${template.name} with end date ${nextEndDate.format(TIME_FORMAT)} - task already exists`);
+    }
+  }
+
+  return createdTasks;
+}
+
 async function onRecurringTaskJobTick() {
    try {
        log("(cron) Recurring tasks job started.");
@@ -33,65 +111,44 @@ async function onRecurringTaskJobTick() {
                ? moment(template.last_task_end_date)
                : moment(template.created_at);
            
-            const futureLimit = moment(template.last_checked_at || template.created_at).add(1, "week");
+            // Calculate future limit based on schedule type
+            const futureLimit = moment(template.last_checked_at || template.created_at)
+                .add(getFutureLimit(
+                    template.schedule_type,
+                    template.interval_days || template.interval_weeks || template.interval_months || 1
+                ));

            let nextEndDate = calculateNextEndDate(template, lastTaskEndDate);
+            const endDatesToCreate: moment.Moment[] = [];

-            // Find the next future occurrence
-            while (nextEndDate.isSameOrBefore(now)) {
+            // Find all future occurrences within the limit
+            while (nextEndDate.isSameOrBefore(futureLimit)) {
+                if (nextEndDate.isAfter(now)) {
+                    endDatesToCreate.push(moment(nextEndDate));
+                }
                nextEndDate = calculateNextEndDate(template, nextEndDate);
            }

-            // Only create a task if it's within the future limit
-            if (nextEndDate.isSameOrBefore(futureLimit)) {
-                const existingTaskQuery = `
-                    SELECT id FROM tasks 
-                    WHERE schedule_id = $1 AND end_date::DATE = $2::DATE;
+            // Batch create tasks for all future dates
+            if (endDatesToCreate.length > 0) {
+                const createdTasks = await createBatchTasks(template, endDatesToCreate);
+                createdTaskCount += createdTasks.length;
+
+                // Update the last_checked_at in the schedule
+                const updateScheduleQuery = `
+                    UPDATE task_recurring_schedules 
+                    SET last_checked_at = $1::DATE, 
+                        last_created_task_end_date = $2 
+                    WHERE id = $3;
                `;
-                const existingTaskResult = await db.query(existingTaskQuery, [template.schedule_id, nextEndDate.format(TIME_FORMAT)]);
-
-                if (existingTaskResult.rows.length === 0) {
-                    const createTaskQuery = `SELECT create_quick_task($1::json) as task;`;
-                    const taskData = {
-                        name: template.name,
-                        priority_id: template.priority_id,
-                        project_id: template.project_id,
-                        reporter_id: template.reporter_id,
-                        status_id: template.status_id || null,
-                        end_date: nextEndDate.format(TIME_FORMAT),
-                        schedule_id: template.schedule_id
-                    };
-                    const createTaskResult = await db.query(createTaskQuery, [JSON.stringify(taskData)]);
-                    const createdTask = createTaskResult.rows[0].task;
-
-                    if (createdTask) {
-                        createdTaskCount++;
-
-                        for (const assignee of template.assignees) {
-                            await TasksController.createTaskBulkAssignees(assignee.team_member_id, template.project_id, createdTask.id, assignee.assigned_by); 
-                        }
-    
-                        for (const label of template.labels) {
-                            const q = `SELECT add_or_remove_task_label($1, $2) AS labels;`;
-                            await db.query(q, [createdTask.id, label.label_id]);
-                        }
-                        
-                        console.log(`Created task for template ${template.name} with end date ${nextEndDate.format(TIME_FORMAT)}`);
-                    }
-                } else {
-                    console.log(`Skipped creating task for template ${template.name} with end date ${nextEndDate.format(TIME_FORMAT)} - task already exists`);
-                }
+                await db.query(updateScheduleQuery, [
+                    moment().format(TIME_FORMAT),
+                    endDatesToCreate[endDatesToCreate.length - 1].format(TIME_FORMAT),
+                    template.schedule_id
+                ]);
            } else {
-                console.log(`No task created for template ${template.name} - next occurrence is beyond the future limit`);
+                console.log(`No tasks created for template ${template.name} - next occurrence is beyond the future limit`);
            }
-
-            // Update the last_checked_at in the schedule
-            const updateScheduleQuery = `
-                UPDATE task_recurring_schedules 
-                SET last_checked_at = $1::DATE, last_created_task_end_date = $2 
-                WHERE id = $3;
-            `;
-            await db.query(updateScheduleQuery, [moment(template.last_checked_at || template.created_at).add(1, "day").format(TIME_FORMAT), nextEndDate.format(TIME_FORMAT), template.schedule_id]);
        }
        
        log(`(cron) Recurring tasks job ended with ${createdTaskCount} new tasks created.`);
--- a/worklenz-backend/src/passport/passport-strategies/passport-local-login.ts
+++ b/worklenz-backend/src/passport/passport-strategies/passport-local-login.ts
@@ -3,13 +3,16 @@ import { Strategy as LocalStrategy } from "passport-local";
 import { log_error } from "../../shared/utils";
 import db from "../../config/db";
 import { Request } from "express";
+import { ERROR_KEY, SUCCESS_KEY } from "./passport-constants";

 async function handleLogin(req: Request, email: string, password: string, done: any) {
-  console.log("Login attempt for:", email);
+  // Clear any existing flash messages
+  (req.session as any).flash = {};

  if (!email || !password) {
-    console.log("Missing credentials");
-    return done(null, false, { message: "Please enter both email and password" });
+    const errorMsg = "Please enter both email and password";
+    req.flash(ERROR_KEY, errorMsg);
+    return done(null, false);
  }

  try {
@@ -19,23 +22,27 @@ async function handleLogin(req: Request, email: string, password: string, done:
                 AND google_id IS NULL
                 AND is_deleted IS FALSE;`;
    const result = await db.query(q, [email]);
-    console.log("User query result count:", result.rowCount);
    
    const [data] = result.rows;

    if (!data?.password) {
-      console.log("No account found");
-      return done(null, false, { message: "No account found with this email" });
+      const errorMsg = "No account found with this email";
+      req.flash(ERROR_KEY, errorMsg);
+      return done(null, false);
    }

    const passwordMatch = bcrypt.compareSync(password, data.password);
-    console.log("Password match:", passwordMatch);
    
    if (passwordMatch && email === data.email) {
      delete data.password;
-      return done(null, data, {message: "User successfully logged in"});
+      const successMsg = "User successfully logged in";
+      req.flash(SUCCESS_KEY, successMsg);
+      return done(null, data);
    }
-    return done(null, false, { message: "Incorrect email or password" });
+    
+    const errorMsg = "Incorrect email or password";
+    req.flash(ERROR_KEY, errorMsg);
+    return done(null, false);
  } catch (error) {
    console.error("Login error:", error);
    log_error(error, req.body);
--- a/worklenz-backend/src/public/locales/alb/404-page.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/account-setup.json
+++ b/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)"
+}
--- a/worklenz-backend/src/public/locales/alb/admin-center/current-bill.json
+++ b/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}}"
+}
--- a/worklenz-backend/src/public/locales/alb/admin-center/overview.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/admin-center/projects.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/admin-center/sidebar.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/admin-center/teams.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/admin-center/users.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/all-project-list.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/auth/auth-common.json
+++ b/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..."
+}
--- a/worklenz-backend/src/public/locales/alb/auth/forgot-password.json
+++ b/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."
+}
--- a/worklenz-backend/src/public/locales/alb/auth/login.json
+++ b/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"
+  }
+}
--- a/worklenz-backend/src/public/locales/alb/auth/signup.json
+++ b/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."
+}
--- a/worklenz-backend/src/public/locales/alb/auth/verify-reset-email.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/common.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/create-first-project-form.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/create-first-tasks.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/home.json
+++ b/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"
+  }
+}
--- a/worklenz-backend/src/public/locales/alb/invite-initial-team-members.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/kanban-board.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/license-expired.json
+++ b/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..."
+}
--- a/worklenz-backend/src/public/locales/alb/navbar.json
+++ b/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"
+  }
+}
--- a/worklenz-backend/src/public/locales/alb/organization-name-form.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/phases-drawer.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/project-drawer.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/project-view-files.json
+++ b/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."
+}
--- a/worklenz-backend/src/public/locales/alb/project-view-insights.json
+++ b/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"
+  }
+}
--- a/worklenz-backend/src/public/locales/alb/project-view-members.json
+++ b/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."
+}
--- a/worklenz-backend/src/public/locales/alb/project-view-updates.json
+++ b/worklenz-backend/src/public/locales/alb/project-view-updates.json
@@ -0,0 +1,6 @@
+{
+  "inputPlaceholder": "Shto një koment..",
+  "addButton": "Shto",
+  "cancelButton": "Anulo",
+  "deleteButton": "Fshi"
+}
--- a/worklenz-backend/src/public/locales/alb/project-view.json
+++ b/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"
+} 
--- a/worklenz-backend/src/public/locales/alb/project-view/import-task-templates.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/project-view/project-member-drawer.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/project-view/project-view-header.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/project-view/save-as-template.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/reporting-members-drawer.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/reporting-members.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/reporting-overview-drawer.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/reporting-overview.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/reporting-projects-drawer.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/reporting-projects-filters.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/reporting-projects.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/reporting-sidebar.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/schedule.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/categories.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/change-password.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/clients.json
+++ b/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!"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/job-titles.json
+++ b/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!"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/labels.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/language.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/notifications.json
+++ b/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."
+}
--- a/worklenz-backend/src/public/locales/alb/settings/profile.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/project-templates.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/sidebar.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/task-templates.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/team-members.json
+++ b/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!"
+}
--- a/worklenz-backend/src/public/locales/alb/settings/teams.json
+++ b/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!"
+} 
--- a/worklenz-backend/src/public/locales/alb/task-drawer/task-drawer-info-tab.json
+++ b/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"
+  }
+}
--- a/worklenz-backend/src/public/locales/alb/task-drawer/task-drawer.json
+++ b/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\"?"
+  }
+}
--- a/worklenz-backend/src/public/locales/alb/task-list-filters.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/task-list-table.json
+++ b/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"
+    }
+  }
+}
--- a/worklenz-backend/src/public/locales/alb/task-management.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/task-template-drawer.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/tasks/task-table-bulk-actions.json
+++ b/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ë"
+}
--- a/worklenz-backend/src/public/locales/alb/template-drawer.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/templateDrawer.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/time-report.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/alb/unauthorized.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/de/404-page.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/de/account-setup.json
+++ b/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)"
+}
--- a/worklenz-backend/src/public/locales/de/admin-center/current-bill.json
+++ b/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}}"
+}
--- a/worklenz-backend/src/public/locales/de/admin-center/overview.json
+++ b/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"
+}
--- a/worklenz-backend/src/public/locales/de/admin-center/projects.json
+++ b/worklenz-backend/src/public/locales/de/admin-center/projects.json
@@ -0,0 +1,12 @@
+{
+  "membersCount": "Mitgliederanzahl",
+  "createdAt": "Erstellt am",
+  "projectName": "Projektname",
+  "teamName": "Teamname",
+  "refreshProjects": "Projekte aktualisieren",
+  "searchPlaceholder": "Nach Projektname suchen",
+  "deleteProject": "Sind Sie sicher, dass Sie dieses Projekt löschen möchten?",
+  "confirm": "Bestätigen",
+  "cancel": "Abbrechen",
+  "delete": "Projekt löschen"
+}
--- a/worklenz-backend/src/public/locales/de/admin-center/sidebar.json
+++ b/worklenz-backend/src/public/locales/de/admin-center/sidebar.json
@@ -0,0 +1,8 @@
+{
+  "overview": "Übersicht",
+  "users": "Benutzer",
+  "teams": "Teams",
+  "billing": "Abrechnung",
+  "projects": "Projekte",
+  "adminCenter": "Admin-Center"
+}
--- a/worklenz-backend/src/public/locales/de/admin-center/teams.json
+++ b/worklenz-backend/src/public/locales/de/admin-center/teams.json
@@ -0,0 +1,33 @@
+{
+  "title": "Teams",
+  "subtitle": "Teams",
+  "tooltip": "Teams aktualisieren",
+  "placeholder": "Nach Namen suchen",
+  "addTeam": "Team hinzufügen",
+  "team": "Team",
+  "membersCount": "Mitgliederanzahl",
+  "members": "Mitglieder",
+  "drawerTitle": "Neues Team erstellen",
+  "label": "Teamname",
+  "drawerPlaceholder": "Name",
+  "create": "Erstellen",
+  "delete": "Löschen",
+  "settings": "Einstellungen",
+  "popTitle": "Sind Sie sicher?",
+  "message": "Bitte geben Sie einen Namen ein",
+  "teamSettings": "Team-Einstellungen",
+  "teamName": "Teamname",
+  "teamDescription": "Teambeschreibung",
+  "teamMembers": "Teammitglieder",
+  "teamMembersCount": "Anzahl der Teammitglieder",
+  "teamMembersPlaceholder": "Nach Namen suchen",
+  "addMember": "Mitglied hinzufügen",
+  "add": "Hinzufügen",
+  "update": "Aktualisieren",
+  "teamNamePlaceholder": "Name des Teams",
+  "user": "Benutzer",
+  "role": "Rolle",
+  "owner": "Besitzer",
+  "admin": "Administrator",
+  "member": "Mitglied"
+}
--- a/worklenz-backend/src/public/locales/de/admin-center/users.json
+++ b/worklenz-backend/src/public/locales/de/admin-center/users.json
@@ -0,0 +1,9 @@
+{
+  "title": "Benutzer",
+  "subTitle": "Benutzer",
+  "placeholder": "Nach Namen suchen",
+  "user": "Benutzer",
+  "email": "E-Mail",
+  "lastActivity": "Letzte Aktivität",
+  "refresh": "Benutzer aktualisieren"
+}
--- a/worklenz-backend/src/public/locales/de/all-project-list.json
+++ b/worklenz-backend/src/public/locales/de/all-project-list.json
@@ -0,0 +1,34 @@
+{
+  "name": "Name",
+  "client": "Kunde",
+  "category": "Kategorie",
+  "status": "Status",
+  "tasksProgress": "Aufgabenfortschritt",
+  "updated_at": "Zuletzt aktualisiert",
+  "members": "Mitglieder",
+  "setting": "Einstellungen",
+  "projects": "Projekte",
+  "refreshProjects": "Projekte aktualisieren",
+  "all": "Alle",
+  "favorites": "Favoriten",
+  "archived": "Archiviert",
+  "placeholder": "Nach Namen suchen",
+  "archive": "Archivieren",
+  "unarchive": "Dearchivieren",
+  "archiveConfirm": "Sind Sie sicher, dass Sie dieses Projekt archivieren möchten?",
+  "unarchiveConfirm": "Sind Sie sicher, dass Sie dieses Projekt dearchivieren möchten?",
+  "yes": "Ja",
+  "no": "Nein",
+  "clickToFilter": "Zum Filtern klicken nach",
+  "noProjects": "Keine Projekte gefunden",
+  "addToFavourites": "Zu Favoriten hinzufügen",
+  "list": "Liste",
+  "group": "Gruppe",
+  "listView": "Listenansicht",
+  "groupView": "Gruppenansicht",
+  "groupBy": {
+    "category": "Kategorie",
+    "client": "Kunde"
+  },
+  "noPermission": "Sie haben keine Berechtigung, diese Aktion durchzuführen"
+}
--- a/worklenz-backend/src/public/locales/de/auth/auth-common.json
+++ b/worklenz-backend/src/public/locales/de/auth/auth-common.json
@@ -0,0 +1,5 @@
+{
+  "loggingOut": "Abmelden...",
+  "authenticating": "Authentifizierung läuft...",
+  "gettingThingsReady": "Bereite alles für Sie vor..."
+}
--- a/worklenz-backend/src/public/locales/de/auth/forgot-password.json
+++ b/worklenz-backend/src/public/locales/de/auth/forgot-password.json
@@ -0,0 +1,12 @@
+{
+  "headerDescription": "Passwort zurücksetzen",
+  "emailLabel": "E-Mail",
+  "emailPlaceholder": "Ihre E-Mail eingeben",
+  "emailRequired": "Bitte geben Sie Ihre E-Mail-Adresse ein!",
+  "resetPasswordButton": "Passwort zurücksetzen",
+  "returnToLoginButton": "Zurück zum Login",
+  "passwordResetSuccessMessage": "Ein Link zum Zurücksetzen des Passworts wurde an Ihre E-Mail gesendet.",
+  "orText": "ODER",
+  "successTitle": "Anweisung zum Zurücksetzen gesendet!",
+  "successMessage": "Die Informationen zum Zurücksetzen wurden an Ihre E-Mail gesendet. Bitte überprüfen Sie Ihr E-Mail-Postfach."
+}
--- a/worklenz-backend/src/public/locales/de/auth/login.json
+++ b/worklenz-backend/src/public/locales/de/auth/login.json
@@ -0,0 +1,27 @@
+{
+  "headerDescription": "Melden Sie sich an",
+  "emailLabel": "E-Mail",
+  "emailPlaceholder": "Ihre E-Mail-Adresse eingeben",
+  "emailRequired": "Bitte geben Sie Ihre E-Mail-Adresse ein!",
+  "passwordLabel": "Passwort",
+  "passwordPlaceholder": "Ihr Passwort eingeben",
+  "passwordRequired": "Bitte geben Sie Ihr Passwort ein!",
+  "rememberMe": "Erinnere dich an mich",
+  "loginButton": "Anmelden",
+  "signupButton": "Registrieren",
+  "forgotPasswordButton": "Passwort vergessen?",
+  "signInWithGoogleButton": "Mit Google anmelden",
+  "dontHaveAccountText": "Noch kein Konto?",
+  "orText": "ODER",
+  "successMessage": "Sie haben sich erfolgreich angemeldet!",
+  "loginError": "Anmeldung fehlgeschlagen",
+  "googleLoginError": "Google-Anmeldung fehlgeschlagen",
+  "validationMessages": {
+    "email": "Bitte geben Sie eine gültige E-Mail-Adresse ein",
+    "password": "Das Passwort muss mindestens 8 Zeichen lang sein"
+  },
+  "errorMessages": {
+    "loginErrorTitle": "Anmeldung fehlgeschlagen",
+    "loginErrorMessage": "Bitte überprüfen Sie Ihre E-Mail-Adresse und Ihr Passwort und versuchen Sie es erneut"
+  }
+}
--- a/worklenz-backend/src/public/locales/de/auth/signup.json
+++ b/worklenz-backend/src/public/locales/de/auth/signup.json
@@ -0,0 +1,29 @@
+{
+  "headerDescription": "Registrieren Sie sich, um loszulegen",
+  "nameLabel": "Vollständiger Name",
+  "namePlaceholder": "Ihren vollständigen Namen eingeben",
+  "nameRequired": "Bitte geben Sie Ihren vollständigen Namen ein!",
+  "nameMinCharacterRequired": "Der Name muss mindestens 4 Zeichen lang sein!",
+  "emailLabel": "E-Mail",
+  "emailPlaceholder": "Ihre E-Mail-Adresse eingeben",
+  "emailRequired": "Bitte geben Sie Ihre E-Mail-Adresse ein!",
+  "passwordLabel": "Passwort",
+  "passwordPlaceholder": "Ihr Passwort eingeben",
+  "passwordRequired": "Bitte geben Sie Ihr Passwort ein!",
+  "passwordMinCharacterRequired": "Das Passwort muss mindestens 8 Zeichen lang sein!",
+  "passwordPatternRequired": "Das Passwort erfüllt nicht die Anforderungen!",
+  "strongPasswordPlaceholder": "Ein stärkeres Passwort eingeben",
+  "passwordValidationAltText": "Das Passwort muss mindestens 8 Zeichen enthalten, mit Groß- und Kleinbuchstaben, einer Zahl und einem Sonderzeichen.",
+  "signupSuccessMessage": "Sie haben sich erfolgreich registriert!",
+  "privacyPolicyLink": "Datenschutzrichtlinie",
+  "termsOfUseLink": "Nutzungsbedingungen",
+  "bySigningUpText": "Mit der Registrierung stimmen Sie unseren",
+  "andText": "und",
+  "signupButton": "Registrieren",
+  "signInWithGoogleButton": "Mit Google anmelden",
+  "alreadyHaveAccountText": "Sie haben bereits ein Konto?",
+  "loginButton": "Anmelden",
+  "orText": "ODER",
+  "reCAPTCHAVerificationError": "reCAPTCHA-Verifizierungsfehler",
+  "reCAPTCHAVerificationErrorMessage": "Wir konnten Ihre reCAPTCHA nicht verifizieren. Bitte versuchen Sie es erneut."
+}
--- a/worklenz-backend/src/public/locales/de/auth/verify-reset-email.json
+++ b/worklenz-backend/src/public/locales/de/auth/verify-reset-email.json
@@ -0,0 +1,14 @@
+{
+  "title": "E-Mail zurücksetzen bestätigen",
+  "description": "Geben Sie Ihr neues Passwort ein",
+  "placeholder": "Neues Passwort eingeben",
+  "confirmPasswordPlaceholder": "Neues Passwort bestätigen",
+  "passwordHint": "Mindestens 8 Zeichen, mit Groß- und Kleinbuchstaben, einer Zahl und einem Sonderzeichen.",
+  "resetPasswordButton": "Passwort zurücksetzen",
+  "orText": "Oder",
+  "resendResetEmail": "Zurücksetz-E-Mail erneut senden",
+  "passwordRequired": "Bitte geben Sie Ihr neues Passwort ein",
+  "returnToLoginButton": "Zurück zur Anmeldung",
+  "confirmPasswordRequired": "Bitte bestätigen Sie Ihr neues Passwort",
+  "passwordMismatch": "Die beiden Passwörter stimmen nicht überein"
+}
--- a/worklenz-backend/src/public/locales/de/common.json
+++ b/worklenz-backend/src/public/locales/de/common.json
@@ -0,0 +1,9 @@
+{
+  "login-success": "Anmeldung erfolgreich!",
+  "login-failed": "Anmeldung fehlgeschlagen. Bitte überprüfen Sie Ihre Anmeldedaten und versuchen Sie es erneut.",
+  "signup-success": "Registrierung erfolgreich! Willkommen an Bord.",
+  "signup-failed": "Registrierung fehlgeschlagen. Bitte füllen Sie alle erforderlichen Felder aus und versuchen Sie es erneut.",
+  "reconnecting": "Vom Server getrennt.",
+  "connection-lost": "Verbindung zum Server fehlgeschlagen. Bitte überprüfen Sie Ihre Internetverbindung.",
+  "connection-restored": "Erfolgreich mit dem Server verbunden"
+}
--- a/worklenz-backend/src/public/locales/de/create-first-project-form.json
+++ b/worklenz-backend/src/public/locales/de/create-first-project-form.json
@@ -0,0 +1,13 @@
+{
+  "formTitle": "Erstellen Sie Ihr erstes Projekt",
+  "inputLabel": "An welchem Projekt arbeiten Sie gerade?",
+  "or": "oder",
+  "templateButton": "Aus Vorlage importieren",
+  "createFromTemplate": "Aus Vorlage erstellen",
+  "goBack": "Zurück",
+  "continue": "Weitermachen",
+  "cancel": "Abbrechen",
+  "create": "Erstellen",
+  "templateDrawerTitle": "Aus Vorlagen auswählen",
+  "createProject": "Projekt erstellen"
+}
--- a/worklenz-backend/src/public/locales/de/create-first-tasks.json
+++ b/worklenz-backend/src/public/locales/de/create-first-tasks.json
@@ -0,0 +1,7 @@
+{
+  "formTitle": "Erstellen Sie Ihre erste Aufgabe.",
+  "inputLabel": "Geben Sie einige Aufgaben ein, die Sie erledigen werden in",
+  "addAnother": "Einen weiteren hinzufügen",
+  "goBack": "Zurück",
+  "continue": "Weiter"
+}
--- a/worklenz-backend/src/public/locales/de/home.json
+++ b/worklenz-backend/src/public/locales/de/home.json
@@ -0,0 +1,46 @@
+{
+  "todoList": {
+    "title": "Aufgabenliste",
+    "refreshTasks": "Aufgaben aktualisieren",
+    "addTask": "+ Aufgabe hinzufügen",
+    "noTasks": "Keine Aufgaben",
+    "pressEnter": "Drücken Sie",
+    "toCreate": "zum Erstellen.",
+    "markAsDone": "Als erledigt markieren"
+  },
+  "projects": {
+    "title": "Projekte",
+    "refreshProjects": "Projekte aktualisieren",
+    "noRecentProjects": "Sie sind aktuell keinem Projekt zugewiesen.",
+    "noFavouriteProjects": "Keine Projekte als Favoriten markiert.",
+    "recent": "Kürzlich",
+    "favourites": "Favoriten"
+  },
+  "tasks": {
+    "assignedToMe": "Mir zugewiesen",
+    "assignedByMe": "Von mir zugewiesen",
+    "all": "Alle",
+    "today": "Heute",
+    "upcoming": "Bevorstehend",
+    "overdue": "Überfällig",
+    "noDueDate": "Kein Fälligkeitsdatum",
+    "noTasks": "Keine Aufgaben zum Anzeigen.",
+    "addTask": "+ Aufgabe hinzufügen",
+    "name": "Name",
+    "project": "Projekt",
+    "status": "Status",
+    "dueDate": "Fälligkeitsdatum",
+    "dueDatePlaceholder": "Fälligkeitsdatum festlegen",
+    "tomorrow": "Morgen",
+    "nextWeek": "Nächste Woche",
+    "nextMonth": "Nächster Monat",
+    "projectRequired": "Bitte wählen Sie ein Projekt aus",
+    "pressTabToSelectDueDateAndProject": "Drücken Sie Tab, um ein Fälligkeitsdatum und ein Projekt auszuwählen",
+    "dueOn": "Fällige Aufgaben am",
+    "taskRequired": "Bitte fügen Sie eine Aufgabe hinzu",
+    "list": "Liste",
+    "calendar": "Kalender",
+    "tasks": "Aufgaben",
+    "refresh": "Aktualisieren"
+  }
+}
--- a/Show More
+++ b/Show More