Merge pull request #255 from aliansoftwareteam/feat/sprint4-implementation

feat(sprint4): agile reports — burndown, velocity, CFD, PDF export

Author: parth0025

Modules/AgileReports/cfd.js

@@ -0,0 +1,98 @@
+// Cumulative flow diagram (S4-03). Task count per status-category per day at
+// project level, over a date range (default last 30 days). Computed on-the-fly:
+// a task's completion day comes from its latest Task_Status history entry (same
+// signal the burndown uses); before completion a task is attributed to its
+// current status-category band. Bands are statusType categories (open /
+// inprogress / onhold / close) — reliably reconstructable, unlike per-custom-
+// status history which the history log does not store structurally.
+const { SCHEMA_TYPE } = require('../../Config/schemaType');
+const { MongoDbCrudOpration } = require('../../utils/mongo-handler/mongoQueries');
+const mongoose = require('mongoose');
+const logger = require('../../Config/loggerConfig');
+
+const OBJECT_ID_PATTERN = /^[0-9a-fA-F]{24}$/;
+const MAX_DAYS = 120;
+const BANDS = ['open', 'inprogress', 'onhold', 'close'];
+
+const endOfDay = (date) => { const d = new Date(date); d.setHours(23, 59, 59, 999); return d; };
+const startOfDay = (date) => { const d = new Date(date); d.setHours(0, 0, 0, 0); return d; };
+const dayKey = (date) => {
+    const d = new Date(date);
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+};
+
+/* GET /api/v1/agile/cfd?projectId=&from=&to=  (companyId from header) */
+exports.getCFD = async (req, res) => {
+    try {
+        const companyId = req.headers['companyid'] || '';
+        const projectId = String((req.query && req.query.projectId) || '');
+        if (!companyId || !OBJECT_ID_PATTERN.test(projectId)) {
+            return res.send({ status: false, statusText: 'companyId and a valid projectId are required.' });
+        }
+        const projectObjId = new mongoose.Types.ObjectId(projectId);
+
+        const rangeEnd = endOfDay(req.query && req.query.to ? new Date(req.query.to) : new Date());
+        let rangeStart = startOfDay(req.query && req.query.from ? new Date(req.query.from) : new Date(rangeEnd.getTime() - 29 * 86400000));
+        let totalDays = Math.ceil((rangeEnd - rangeStart) / 86400000) + 1;
+        if (totalDays > MAX_DAYS) {
+            totalDays = MAX_DAYS;
+            rangeStart = startOfDay(new Date(rangeEnd.getTime() - (MAX_DAYS - 1) * 86400000));
+        }
+        if (totalDays < 1) totalDays = 1;
+
+        const tasks = await MongoDbCrudOpration(companyId, {
+            type: SCHEMA_TYPE.TASKS,
+            data: [
+                { projectId: projectObjId, deletedStatusKey: { $in: [0, 2, undefined] }, isParentTask: true },
+                '_id statusType createdAt updatedAt',
+            ],
+        }, 'find');
+
+        if (!tasks || !tasks.length) {
+            return res.send({ status: true, statusText: 'No tasks yet.', data: { days: [] } });
+        }
+
+        // Completion date for done tasks (latest Task_Status history; fallback updatedAt).
+        const doneTasks = tasks.filter((t) => t.statusType === 'close');
+        const lastStatusChange = new Map();
+        if (doneTasks.length) {
+            const idStrings = doneTasks.map((t) => String(t._id));
+            const idObjects = doneTasks.map((t) => t._id);
+            const historyRows = await MongoDbCrudOpration(companyId, {
+                type: SCHEMA_TYPE.HISTORY,
+                data: [{ Key: 'Task_Status', TaskId: { $in: [...idStrings, ...idObjects] } }, 'TaskId createdAt'],
+            }, 'find');
+            (historyRows || []).forEach((row) => {
+                const k = String(row.TaskId);
+                const cur = lastStatusChange.get(k);
+                if (!cur || new Date(row.createdAt) > cur) lastStatusChange.set(k, new Date(row.createdAt));
+            });
+        }
+
+        const enriched = tasks.map((t) => ({
+            createdAt: new Date(t.createdAt),
+            band: BANDS.includes(t.statusType) ? t.statusType : 'open',
+            completedAt: t.statusType === 'close' ? (lastStatusChange.get(String(t._id)) || new Date(t.updatedAt)) : null,
+        }));
+
+        const days = [];
+        for (let i = 0; i < totalDays; i++) {
+            const cursor = endOfDay(new Date(rangeStart.getTime() + i * 86400000));
+            const counts = { open: 0, inprogress: 0, onhold: 0, close: 0 };
+            enriched.forEach((t) => {
+                if (t.createdAt > cursor) return; // not created yet on this day
+                if (t.completedAt && t.completedAt <= cursor) { counts.close += 1; return; }
+                // Not yet done as of this day: attribute to current band (a task that
+                // is now 'close' but wasn't done yet is shown as in-progress).
+                const band = t.band === 'close' ? 'inprogress' : t.band;
+                counts[band] += 1;
+            });
+            days.push({ date: dayKey(cursor), ...counts });
+        }
+
+        return res.send({ status: true, statusText: 'CFD computed.', data: { days } });
+    } catch (error) {
+        logger.error(`ERROR in agile cfd: ${error.message}`);
+        return res.send({ status: false, statusText: error.message });
+    }
+};

Modules/AgileReports/init.js

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

Modules/AgileReports/routes.js

@@ -0,0 +1,12 @@
+const { getSprintBurndown } = require('../Sprints/burndown');
+const velocity = require('./velocity');
+const cfd = require('./cfd');
+
+exports.init = (app) => {
+    // Unified agile-reports read API (S4). Burndown reuses the existing Sprints
+    // handler (now query-param aware); velocity + CFD are computed in this module.
+    // All read-only; auth/companyId come from the global middleware like other routes.
+    app.get('/api/v1/agile/burndown', getSprintBurndown);
+    app.get('/api/v1/agile/velocity', velocity.getVelocity);
+    app.get('/api/v1/agile/cfd', cfd.getCFD);
+};

Modules/AgileReports/velocity.js

@@ -0,0 +1,80 @@
+// Sprint velocity (S4-02). Completed story points per sprint for the most
+// recent N sprints of a project, plus a rolling-3 average. Computed on-the-fly
+// from current task state — committed = total points in the sprint, completed =
+// points of tasks currently in a done-category status (statusType 'close').
+// Read-only; no new collections or cron.
+const { SCHEMA_TYPE } = require('../../Config/schemaType');
+const { MongoDbCrudOpration } = require('../../utils/mongo-handler/mongoQueries');
+const mongoose = require('mongoose');
+const logger = require('../../Config/loggerConfig');
+
+const OBJECT_ID_PATTERN = /^[0-9a-fA-F]{24}$/;
+const DONE_TYPE = 'close';
+
+/* GET /api/v1/agile/velocity?projectId=&limit=10  (companyId from header) */
+exports.getVelocity = async (req, res) => {
+    try {
+        const companyId = req.headers['companyid'] || '';
+        const projectId = String((req.query && req.query.projectId) || '');
+        const limit = Math.min(50, Math.max(1, Number(req.query && req.query.limit) || 10));
+        if (!companyId || !OBJECT_ID_PATTERN.test(projectId)) {
+            return res.send({ status: false, statusText: 'companyId and a valid projectId are required.' });
+        }
+        const projectObjId = new mongoose.Types.ObjectId(projectId);
+
+        // All non-deleted sprints for this project.
+        const sprints = await MongoDbCrudOpration(companyId, {
+            type: SCHEMA_TYPE.SPRINTS,
+            data: [
+                { projectId: projectObjId, deletedStatusKey: { $ne: 1 } },
+                '_id name createdAt deletedStatusKey',
+            ],
+        }, 'find');
+
+        if (!sprints || !sprints.length) {
+            return res.send({ status: true, statusText: 'No sprints yet.', data: { sprints: [] } });
+        }
+
+        // Oldest-first, then keep the most recent `limit`.
+        const ordered = sprints
+            .slice()
+            .sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt))
+            .slice(-limit);
+
+        const sprintIds = ordered.map((s) => s._id);
+        const tasks = await MongoDbCrudOpration(companyId, {
+            type: SCHEMA_TYPE.TASKS,
+            data: [
+                { sprintId: { $in: sprintIds }, deletedStatusKey: { $in: [0, 2, undefined] }, isParentTask: true },
+                '_id sprintId points statusType',
+            ],
+        }, 'find');
+
+        const bySprint = new Map();
+        ordered.forEach((s) => bySprint.set(String(s._id), { committed: 0, completed: 0 }));
+        (tasks || []).forEach((t) => {
+            const bucket = bySprint.get(String(t.sprintId));
+            if (!bucket) return;
+            const pts = Number(t.points) || 0;
+            bucket.committed += pts;
+            if (t.statusType === DONE_TYPE) bucket.completed += pts;
+        });
+
+        const rows = ordered.map((s) => {
+            const b = bySprint.get(String(s._id)) || { committed: 0, completed: 0 };
+            return { sprintId: String(s._id), name: s.name || 'Sprint', committed: b.committed, completed: b.completed };
+        });
+
+        // Rolling-3 average of completed points.
+        const withAvg = rows.map((row, i) => {
+            const window = rows.slice(Math.max(0, i - 2), i + 1);
+            const avg = window.reduce((sum, r) => sum + r.completed, 0) / window.length;
+            return { ...row, rollingAvg: Math.round(avg * 10) / 10 };
+        });
+
+        return res.send({ status: true, statusText: 'Velocity computed.', data: { sprints: withAvg } });
+    } catch (error) {
+        logger.error(`ERROR in agile velocity: ${error.message}`);
+        return res.send({ status: false, statusText: error.message });
+    }
+};

Modules/Export/init.js

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

Modules/Export/pdf.js

@@ -0,0 +1,140 @@
+// PDF export (S4-04). A general "render this payload as a branded PDF" endpoint.
+// The client sends what it already displays — table rows for timesheets, and
+// client-rendered chart images (ApexCharts dataURI) for the agile reports — so
+// the PDF always matches the on-screen data and we avoid server-side chart
+// rendering and date/unit guesswork. Uses pdfmake with the standard PDF
+// Helvetica font (no embedded font files / headless browser — light Docker image).
+const path = require('path');
+const fs = require('fs');
+const logger = require('../../Config/loggerConfig');
+
+// pdfmake is loaded lazily so a missing install never breaks app startup — only
+// this endpoint errors (with a clear message) until `npm install` brings it in.
+let _printer = null;
+function getPrinter() {
+    if (_printer) return _printer;
+    const PdfPrinter = require('pdfmake');
+    _printer = new PdfPrinter({
+        Helvetica: {
+            normal: 'Helvetica',
+            bold: 'Helvetica-Bold',
+            italics: 'Helvetica-Oblique',
+            bolditalics: 'Helvetica-BoldOblique',
+        },
+    });
+    return _printer;
+}
+
+const BRAND_COLOR = '#2F3990';
+
+function productName() {
+    try {
+        const p = path.join(__dirname, '../../brandSettings.json');
+        if (fs.existsSync(p)) {
+            const data = JSON.parse(fs.readFileSync(p, 'utf8'));
+            return data.productName || 'AlianHub';
+        }
+    } catch (e) { /* fall through to default */ }
+    return 'AlianHub';
+}
+
+function sanitizeFilename(name) {
+    return String(name || 'export').replace(/[^a-z0-9-_]+/gi, '_').slice(0, 60) || 'export';
+}
+
+const STYLES = {
+    brand: { fontSize: 16, bold: true, color: BRAND_COLOR },
+    h1: { fontSize: 18, bold: true, margin: [0, 6, 0, 0] },
+    sub: { fontSize: 10, color: '#666666', margin: [0, 2, 0, 0] },
+    th: { bold: true, fontSize: 10, color: '#ffffff' },
+    meta: { fontSize: 10, color: '#444444', margin: [0, 1, 0, 1] },
+    total: { bold: true, fontSize: 10 },
+};
+
+function headerBlocks(title, subtitle) {
+    const blocks = [
+        { text: productName(), style: 'brand' },
+        { text: title || 'Report', style: 'h1' },
+    ];
+    if (subtitle) blocks.push({ text: subtitle, style: 'sub' });
+    blocks.push({ canvas: [{ type: 'line', x1: 0, y1: 4, x2: 515, y2: 4, lineWidth: 1, lineColor: '#dddddd' }], margin: [0, 6, 0, 10] });
+    return blocks;
+}
+
+function tableBlock(tableHead, tableRows, totalRow) {
+    const body = [];
+    if (Array.isArray(tableHead) && tableHead.length) {
+        body.push(tableHead.map((h) => ({ text: String(h), style: 'th', fillColor: BRAND_COLOR, margin: [0, 4, 0, 4] })));
+    }
+    (tableRows || []).forEach((row) => {
+        body.push((row || []).map((cell) => ({ text: cell == null ? '' : String(cell), fontSize: 9, margin: [0, 2, 0, 2] })));
+    });
+    if (Array.isArray(totalRow) && totalRow.length) {
+        body.push(totalRow.map((cell) => ({ text: cell == null ? '' : String(cell), style: 'total', fillColor: '#f0f1f7', margin: [0, 4, 0, 4] })));
+    }
+    if (!body.length) return { text: 'No data for this selection.', italics: true, color: '#888888' };
+    const colCount = (tableHead && tableHead.length) || (body[0] && body[0].length) || 1;
+    return {
+        table: { headerRows: tableHead && tableHead.length ? 1 : 0, widths: Array(colCount).fill('*'), body },
+        layout: { hLineColor: () => '#e6e6e6', vLineColor: () => '#e6e6e6' },
+        margin: [0, 4, 0, 12],
+    };
+}
+
+function streamPdf(res, docDefinition, filename) {
+    const pdfDoc = getPrinter().createPdfKitDocument(docDefinition);
+    res.setHeader('Content-Type', 'application/pdf');
+    res.setHeader('Content-Disposition', `attachment; filename="${sanitizeFilename(filename)}.pdf"`);
+    pdfDoc.pipe(res);
+    pdfDoc.end();
+}
+
+/* POST /api/v1/export/pdf  body: { type, params }  (companyId from header)
+ * params: { title, subtitle?, filename?, meta?: string[], image?|images?: base64 dataURI,
+ *           tableHead?: string[], tableRows?: any[][], totalRow?: any[] } */
+exports.exportPdf = (req, res) => {
+    try {
+        const companyId = req.headers['companyid'] || '';
+        const { type, params = {} } = req.body || {};
+        if (!companyId || !type) {
+            return res.status(400).send({ status: false, statusText: 'companyId and type are required.' });
+        }
+
+        const content = headerBlocks(params.title, params.subtitle);
+
+        if (Array.isArray(params.meta) && params.meta.length) {
+            params.meta.forEach((line) => content.push({ text: String(line), style: 'meta' }));
+            content.push({ text: ' ', margin: [0, 0, 0, 6] });
+        }
+
+        const images = params.images || (params.image ? [params.image] : []);
+        images.forEach((img) => {
+            if (typeof img === 'string' && img.startsWith('data:image')) {
+                content.push({ image: img, width: 515, margin: [0, 4, 0, 12] });
+            }
+        });
+
+        if ((Array.isArray(params.tableHead) && params.tableHead.length) || (Array.isArray(params.tableRows) && params.tableRows.length)) {
+            content.push(tableBlock(params.tableHead, params.tableRows, params.totalRow));
+        }
+
+        const docDefinition = {
+            pageSize: 'A4',
+            pageMargins: [40, 40, 40, 50],
+            defaultStyle: { font: 'Helvetica', fontSize: 10 },
+            styles: STYLES,
+            content,
+            footer: (currentPage, pageCount) => ({
+                columns: [
+                    { text: `Generated ${new Date().toISOString().slice(0, 10)}`, fontSize: 8, color: '#999999', margin: [40, 0, 0, 0] },
+                    { text: `${currentPage} / ${pageCount}`, alignment: 'right', fontSize: 8, color: '#999999', margin: [0, 0, 40, 0] },
+                ],
+            }),
+        };
+
+        streamPdf(res, docDefinition, params.filename || type);
+    } catch (error) {
+        logger.error(`ERROR in export pdf: ${error.message}`);
+        if (!res.headersSent) res.status(500).send({ status: false, statusText: error.message });
+    }
+};

Modules/Export/routes.js

@@ -0,0 +1,6 @@
+const pdf = require('./pdf');
+
+exports.init = (app) => {
+    // Client-shareable PDF export (S4-04). Auth/companyId via global middleware.
+    app.post('/api/v1/export/pdf', pdf.exportPdf);
+};