Merge pull request #256 from aliansoftwareteam/feat/sprint5-implementation

feat(sprint5): gantt/timeline view + recurring tasks

Author: parth0025

Config/collections.js

@@ -70,6 +70,7 @@ const dbCollections = {
     PUBLIC_SHARES: "publicShares",
     INTAKE_ITEMS: "intakeItems",
     PUBLIC_SHARE_INDEX: "publicShareIndex",
+    RECURRING_TASKS: "recurring_tasks",
 }
 
 /** DOCUMENT ID'S NAME WHICH IS USED IN THE "SETTINGS" COLLECTION NAME **/

Config/schemaType.js

@@ -69,6 +69,7 @@ const SCHEMA_TYPE = {
     PUBLIC_SHARES: "publicShares",
     INTAKE_ITEMS: "intakeItems",
     PUBLIC_SHARE_INDEX: "publicShareIndex",
+    RECURRING_TASKS: "recurring_tasks",
 }
 
 module.exports = {

Modules/RecurringTasks/controller.js

@@ -0,0 +1,181 @@
+// Recurring tasks — HTTP handlers. CRUD on definitions + a manual run-now /
+// run-due (the scheduled job in cron.js runs production-only, so these let the
+// feature be exercised in dev). Definitions and instances are company-scoped.
+const mongoose = require('mongoose');
+const helper = require('./helper');
+const { SCHEMA_TYPE } = require('../../Config/schemaType');
+const { MongoDbCrudOpration } = require('../../utils/mongo-handler/mongoQueries');
+const logger = require('../../Config/loggerConfig');
+
+// Build a valid task `data` template from the request (mirrors the defaults in
+// taskMongo.createSubTaskWithAi so taskMongo.create accepts it).
+function buildTemplateFromBody(body) {
+    const project = body.projectData || {};
+    return {
+        TaskName: body.taskName,
+        TaskKey: '-',
+        AssigneeUserId: Array.isArray(body.assignees) ? body.assignees : [],
+        watchers: [],
+        DueDate: '',
+        dueDateDeadLine: [],
+        TaskType: body.taskType || 'task',
+        TaskTypeKey: Number(body.taskTypeKey) || 1,
+        ParentTaskId: '',
+        ProjectID: project._id,
+        CompanyId: project.CompanyId,
+        status: { text: 'To Do', key: 1, type: 'default_active' },
+        isParentTask: true,
+        Task_Leader: (body.userData && body.userData.id) || '',
+        Task_Priority: body.priority || 'MEDIUM',
+        deletedStatusKey: 0,
+        statusType: 'default_active',
+        statusKey: 1,
+        points: (body.points === undefined || body.points === null || body.points === '') ? null : Number(body.points),
+        rawDescription: body.rawDescription || '',
+        descriptionBlock: body.descriptionBlock || {},
+    };
+}
+
+exports.createDefinition = async (req, res) => {
+    try {
+        const companyId = req.headers['companyid'];
+        const b = req.body || {};
+        if (!companyId || !b.name || !b.taskName || !b.projectData || !b.projectData._id || !b.freq) {
+            return res.send({ status: false, statusText: 'Missing required fields (name, taskName, projectData, freq)' });
+        }
+        const def = {
+            _id: new mongoose.Types.ObjectId(),
+            name: b.name,
+            ProjectID: new mongoose.Types.ObjectId(b.projectData._id),
+            sprintId: b.sprintId || (b.sprintArray && (b.sprintArray.id || b.sprintArray._id)) || '',
+            enabled: true,
+            freq: b.freq,
+            interval: Math.max(1, Number(b.interval) || 1),
+            byweekday: Array.isArray(b.byweekday) ? b.byweekday.map(Number) : [],
+            monthday: b.monthday ? Number(b.monthday) : undefined,
+            runHour: Number.isFinite(Number(b.runHour)) ? Number(b.runHour) : 9,
+            skipIfOpen: !!b.skipIfOpen,
+            until: b.until ? new Date(b.until) : undefined,
+            runCount: 0,
+            templateSnapshot: buildTemplateFromBody(b),
+            projectSnapshot: {
+                _id: b.projectData._id,
+                CompanyId: b.projectData.CompanyId,
+                ProjectCode: b.projectData.ProjectCode,
+                ProjectName: b.projectData.ProjectName,
+            },
+            userSnapshot: {
+                id: b.userData && b.userData.id,
+                Employee_Name: b.userData && b.userData.Employee_Name,
+                companyOwnerId: b.userData && b.userData.companyOwnerId,
+            },
+            sprintArray: b.sprintArray || {},
+            createdBy: (b.userData && b.userData.id) || '',
+            deletedStatusKey: 0,
+        };
+        def.nextRunAt = helper.computeNextRun(def, new Date());
+        const saved = await MongoDbCrudOpration(companyId, { type: SCHEMA_TYPE.RECURRING_TASKS, data: def }, 'save');
+        res.send({ status: true, statusText: 'Recurring task created', data: saved });
+    } catch (error) {
+        logger.error(`[recurringTasks] create failed: ${error.message}`);
+        res.send({ status: false, statusText: error.message });
+    }
+};
+
+exports.listByProject = async (req, res) => {
+    try {
+        const companyId = req.headers['companyid'];
+        const projectId = req.params.pid;
+        const defs = await MongoDbCrudOpration(companyId, {
+            type: SCHEMA_TYPE.RECURRING_TASKS,
+            data: [{ ProjectID: new mongoose.Types.ObjectId(projectId), deletedStatusKey: 0 }],
+        }, 'find');
+        res.send({ status: true, data: defs || [] });
+    } catch (error) {
+        logger.error(`[recurringTasks] list failed: ${error.message}`);
+        res.send({ status: false, statusText: error.message });
+    }
+};
+
+exports.updateDefinition = async (req, res) => {
+    try {
+        const companyId = req.headers['companyid'];
+        const id = req.params.id;
+        const b = req.body || {};
+        const patch = {};
+        ['name', 'enabled', 'freq', 'interval', 'byweekday', 'monthday', 'runHour', 'skipIfOpen'].forEach((k) => {
+            if (b[k] !== undefined) patch[k] = b[k];
+        });
+        if (b.until !== undefined) patch.until = b.until ? new Date(b.until) : null;
+
+        // If the schedule changed, recompute nextRunAt from the merged definition.
+        const scheduleChanged = ['freq', 'interval', 'byweekday', 'monthday', 'runHour'].some((k) => b[k] !== undefined);
+        if (scheduleChanged) {
+            const existing = await MongoDbCrudOpration(companyId, {
+                type: SCHEMA_TYPE.RECURRING_TASKS,
+                data: [{ _id: new mongoose.Types.ObjectId(id) }],
+            }, 'findOne');
+            if (existing) {
+                patch.nextRunAt = helper.computeNextRun(Object.assign({}, existing.toObject ? existing.toObject() : existing, patch), new Date());
+            }
+        }
+        await helper.updateDef(companyId, id, patch);
+        res.send({ status: true, statusText: 'Updated' });
+    } catch (error) {
+        logger.error(`[recurringTasks] update failed: ${error.message}`);
+        res.send({ status: false, statusText: error.message });
+    }
+};
+
+exports.deleteDefinition = async (req, res) => {
+    try {
+        const companyId = req.headers['companyid'];
+        const id = req.params.id;
+        await helper.updateDef(companyId, id, { deletedStatusKey: 1, enabled: false });
+        res.send({ status: true, statusText: 'Deleted' });
+    } catch (error) {
+        logger.error(`[recurringTasks] delete failed: ${error.message}`);
+        res.send({ status: false, statusText: error.message });
+    }
+};
+
+// Instantiate one task right now from a definition (testing / manual trigger).
+exports.runNow = async (req, res) => {
+    try {
+        const companyId = req.headers['companyid'];
+        const id = req.params.id;
+        const def = await MongoDbCrudOpration(companyId, {
+            type: SCHEMA_TYPE.RECURRING_TASKS,
+            data: [{ _id: new mongoose.Types.ObjectId(id) }],
+        }, 'findOne');
+        if (!def) return res.send({ status: false, statusText: 'Definition not found' });
+        const out = await helper.instantiateOne(companyId, def);
+        const patch = { lastRunAt: new Date(), runCount: (Number(def.runCount) || 0) + (out.created ? 1 : 0) };
+        if (out.id) patch.lastInstanceTaskId = String(out.id);
+        await helper.updateDef(companyId, id, patch);
+        res.send({
+            status: !!(out.created || out.skipped),
+            statusText: out.skipped ? 'Skipped — previous instance still open' : 'Task created',
+            data: { id: out.id || null, skipped: !!out.skipped },
+        });
+    } catch (error) {
+        logger.error(`[recurringTasks] runNow failed: ${error.message}`);
+        res.send({ status: false, statusText: error.message });
+    }
+};
+
+// Process all due definitions for the caller's company (manual trigger; the
+// cron does this for every company in production).
+exports.runDueForCompany = async (req, res) => {
+    try {
+        const companyId = req.headers['companyid'];
+        const result = await helper.processDueForCompany(companyId);
+        res.send({ status: true, statusText: 'Processed due recurring tasks', data: result });
+    } catch (error) {
+        logger.error(`[recurringTasks] runDue failed: ${error.message}`);
+        res.send({ status: false, statusText: error.message });
+    }
+};
+
+// Cron entry (all companies) — consumed by cron.js.
+exports.runRecurringForAllCompanies = helper.runRecurringForAllCompanies;

Modules/RecurringTasks/helper.js

@@ -0,0 +1,161 @@
+// Recurring task definitions — pure logic: schedule math + instantiation.
+// HTTP handlers live in controller.js; cron entry is runRecurringForAllCompanies().
+const mongoose = require('mongoose');
+const { SCHEMA_TYPE } = require('../../Config/schemaType');
+const { MongoDbCrudOpration } = require('../../utils/mongo-handler/mongoQueries');
+const { taskMongo } = require('../Tasks/helpers/task_class_Mongo');
+const logger = require('../../Config/loggerConfig');
+
+const COMPANY_CONCURRENCY = 5;
+const LOG_PREFIX = '[recurringTasks]';
+
+function atHour(year, month, day, hour) {
+    return new Date(year, month, day, hour, 0, 0, 0);
+}
+
+// The next run strictly after `fromDate`, per the definition's schedule.
+function computeNextRun(def, fromDate) {
+    const from = fromDate ? new Date(fromDate) : new Date();
+    const hour = Number.isFinite(Number(def.runHour)) ? Number(def.runHour) : 9;
+    const interval = Math.max(1, Number(def.interval) || 1);
+
+    if (def.freq === 'weekly') {
+        const days = (Array.isArray(def.byweekday) && def.byweekday.length) ? def.byweekday.map(Number) : [from.getDay()];
+        for (let i = 1; i <= 7 * interval + 7; i++) {
+            const c = atHour(from.getFullYear(), from.getMonth(), from.getDate() + i, hour);
+            if (days.includes(c.getDay())) return c;
+        }
+        return atHour(from.getFullYear(), from.getMonth(), from.getDate() + 7, hour);
+    }
+    if (def.freq === 'monthly') {
+        // cap at 28 so we never overflow into the next month on short months
+        const dom = Math.min(28, Math.max(1, Number(def.monthday) || from.getDate()));
+        let c = atHour(from.getFullYear(), from.getMonth(), dom, hour);
+        while (c <= from) {
+            c = atHour(c.getFullYear(), c.getMonth() + interval, dom, hour);
+        }
+        return c;
+    }
+    // daily (default)
+    return atHour(from.getFullYear(), from.getMonth(), from.getDate() + interval, hour);
+}
+
+// Clone the stored template into a fresh task `data` payload for taskMongo.create.
+function buildInstanceData(def, companyId) {
+    const t = Object.assign({}, def.templateSnapshot || {});
+    const projectId = (def.projectSnapshot && def.projectSnapshot._id) || def.ProjectID;
+    return Object.assign(t, {
+        _id: new mongoose.Types.ObjectId(),
+        TaskKey: '-',
+        ProjectID: projectId,
+        CompanyId: companyId,
+        sprintId: def.sprintId,
+        sprintArray: def.sprintArray || t.sprintArray,
+        deletedStatusKey: 0,
+        startDate: new Date(),
+    });
+}
+
+async function isPreviousInstanceOpen(companyId, taskId) {
+    if (!taskId) return false;
+    try {
+        const res = await MongoDbCrudOpration(companyId, {
+            type: SCHEMA_TYPE.TASKS,
+            data: [{ _id: new mongoose.Types.ObjectId(taskId) }, 'statusType deletedStatusKey'],
+        }, 'findOne');
+        if (!res) return false;
+        return res.deletedStatusKey !== 1 && res.statusType !== 'close';
+    } catch (e) {
+        return false;
+    }
+}
+
+// Create one task instance from a definition. Returns { created, id, skipped }.
+async function instantiateOne(companyId, def) {
+    if (def.skipIfOpen && await isPreviousInstanceOpen(companyId, def.lastInstanceTaskId)) {
+        return { created: false, skipped: true };
+    }
+    const data = buildInstanceData(def, companyId);
+    const indexObj = { indexName: 'groupByStatusIndex', searchKey: 'statusKey', searchValue: String(data.statusKey || 1) };
+    const result = await taskMongo.create({
+        data,
+        user: def.userSnapshot || { id: def.createdBy, Employee_Name: '', companyOwnerId: '' },
+        projectData: def.projectSnapshot || { _id: data.ProjectID, CompanyId: companyId },
+        indexObj,
+    });
+    return { created: !!(result && result.status), id: result && result.id, skipped: false };
+}
+
+// updateOne $set on a definition.
+async function updateDef(companyId, id, patch) {
+    return MongoDbCrudOpration(companyId, {
+        type: SCHEMA_TYPE.RECURRING_TASKS,
+        data: [{ _id: new mongoose.Types.ObjectId(id) }, { $set: patch }],
+    }, 'updateOne');
+}
+
+// Process every due, enabled definition for one company.
+async function processDueForCompany(companyId, now) {
+    const ref = now ? new Date(now) : new Date();
+    let defs = [];
+    try {
+        defs = await MongoDbCrudOpration(companyId, {
+            type: SCHEMA_TYPE.RECURRING_TASKS,
+            data: [{ enabled: true, deletedStatusKey: 0, nextRunAt: { $lte: ref } }],
+        }, 'find');
+    } catch (e) {
+        logger.error(`${LOG_PREFIX} find-due failed for ${companyId}: ${e.message}`);
+        return { processed: 0, created: 0 };
+    }
+    let created = 0;
+    for (const def of (defs || [])) {
+        try {
+            if (def.until && new Date(def.until) < ref) {
+                await updateDef(companyId, def._id, { enabled: false });
+                continue;
+            }
+            const out = await instantiateOne(companyId, def);
+            if (out.created) created++;
+            const next = computeNextRun(def, ref);
+            const patch = {
+                lastRunAt: ref,
+                runCount: (Number(def.runCount) || 0) + (out.created ? 1 : 0),
+                nextRunAt: next,
+            };
+            if (out.id) patch.lastInstanceTaskId = String(out.id);
+            if (def.until && next > new Date(def.until)) patch.enabled = false;
+            await updateDef(companyId, def._id, patch);
+        } catch (e) {
+            logger.error(`${LOG_PREFIX} instantiate failed (${companyId}/${def._id}): ${e.message}`);
+        }
+    }
+    return { processed: (defs || []).length, created };
+}
+
+// Cron entry: scan every company for due definitions (bounded concurrency).
+async function runRecurringForAllCompanies() {
+    let companies = [];
+    try {
+        companies = await MongoDbCrudOpration(SCHEMA_TYPE.GOLBAL, {
+            type: SCHEMA_TYPE.COMPANIES,
+            data: [{}, '_id'],
+        }, 'find');
+    } catch (e) {
+        logger.error(`${LOG_PREFIX} could not enumerate companies: ${e.message}`);
+        return;
+    }
+    for (let i = 0; i < (companies || []).length; i += COMPANY_CONCURRENCY) {
+        const slice = companies.slice(i, i + COMPANY_CONCURRENCY);
+        await Promise.allSettled(slice.map((c) => processDueForCompany(String(c._id))));
+    }
+    logger.info(`${LOG_PREFIX} run complete across ${(companies || []).length} companies`);
+}
+
+module.exports = {
+    computeNextRun,
+    buildInstanceData,
+    instantiateOne,
+    processDueForCompany,
+    updateDef,
+    runRecurringForAllCompanies,
+};

Modules/RecurringTasks/init.js

@@ -0,0 +1,3 @@
+const routes = require('./routes');
+
+exports.init = (app) => routes.init(app);

Modules/RecurringTasks/routes.js

@@ -0,0 +1,18 @@
+const controller = require('./controller');
+const logger = require('../../Config/loggerConfig');
+
+exports.init = (app) => {
+    // Create a recurring task definition for a project.
+    app.post('/api/v1/recurring-tasks', controller.createDefinition);
+    // List a project's recurring definitions.
+    app.get('/api/v1/recurring-tasks/project/:pid', controller.listByProject);
+    // Edit / pause / resume (PATCH { enabled, freq, ... }).
+    app.patch('/api/v1/recurring-tasks/:id', controller.updateDefinition);
+    // Soft-delete a definition.
+    app.delete('/api/v1/recurring-tasks/:id', controller.deleteDefinition);
+    // Instantiate one task immediately (manual / testing).
+    app.post('/api/v1/recurring-tasks/:id/run-now', controller.runNow);
+    // Process every due definition for the caller's company (manual; cron does this in prod).
+    app.post('/api/v1/recurring-tasks/run-due', controller.runDueForCompany);
+    logger.info('RecurringTasks routes initialised');
+};