feat(recurring-tasks): enhance recurring task functionality and documentation

- Expanded schedule options for recurring tasks, including new intervals for every X days, weeks, and months. - Added future task creation logic to ensure tasks are created within defined limits based on their schedule type. - Updated user guide to reflect new scheduling options and future task creation details. - Improved backend logic for recurring task creation, including batch processing and future limit calculations. - Added environment configuration for enabling recurring jobs. - Enhanced frontend localization for recurring task configuration labels.
2025-05-21 08:07:59 +05:30
parent a568ee808f
commit 84c7428fed
10 changed files with 255 additions and 129 deletions
--- 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,23 +32,14 @@ export default class TasksControllerBase extends WorklenzControllerBase {
  }

  public static updateTaskViewModel(task: any) {
-    console.log(`Processing task ${task.id} (${task.name})`);
-    console.log(`  manual_progress: ${task.manual_progress}, progress_value: ${task.progress_value}`);
-    console.log(`  project_use_manual_progress: ${task.project_use_manual_progress}, project_use_weighted_progress: ${task.project_use_weighted_progress}`);
-    console.log(`  has subtasks: ${task.sub_tasks_count > 0}`);
-    
    // For parent tasks (with subtasks), always use calculated progress from subtasks
    if (task.sub_tasks_count > 0) {
-      // For parent tasks without manual progress, calculate from subtasks (already done via db function)
-      console.log(`  Parent task with subtasks: complete_ratio=${task.complete_ratio}`);
-      
      // 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) {
-        console.log(`  WARNING: Parent task ${task.id} had manual_progress set to true, resetting`);
        task.manual_progress = false;
        task.progress_value = null;
      }
@@ -58,28 +49,24 @@ export default class TasksControllerBase extends WorklenzControllerBase {
      // For manually set progress, use that value directly
      task.progress = parseInt(task.progress_value);
      task.complete_ratio = parseInt(task.progress_value);
-      
-      console.log(`  Using manual progress: progress=${task.progress}, complete_ratio=${task.complete_ratio}`);
-    } 
+    }
    // For tasks with no subtasks and no manual progress, calculate based on time
    else {
-      task.progress = task.total_minutes_spent && task.total_minutes 
-        ? ~~(task.total_minutes_spent / task.total_minutes * 100) 
+      task.progress = task.total_minutes_spent && task.total_minutes
+        ? ~~(task.total_minutes_spent / task.total_minutes * 100)
        : 0;
-        
+
      // Set complete_ratio to match progress
      task.complete_ratio = task.progress;
-      
-      console.log(`  Calculated time-based progress: progress=${task.progress}, complete_ratio=${task.complete_ratio}`);
    }
-    
+
    // 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;
--- a/worklenz-backend/src/controllers/tasks-controller-v2.ts
+++ b/worklenz-backend/src/controllers/tasks-controller-v2.ts
@@ -97,7 +97,6 @@ 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;
-      console.log("data", data);
      if (data && data.info && data.info.ratio !== undefined) {
        data.info.ratio = +((data.info.ratio || 0).toFixed());
        return data.info;
--- 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 * * * *"; // runs every 2 minutes - for testing purposes
+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.`);