mirror of
https://github.com/wekan/wekan.git
synced 2026-11-20 09:45:04 -05:00
Added after comparing WeKan's charts with the reports of Jira, Azure
DevOps, Nave, ActionableAgile and the Flow Framework: Created vs.
Resolved, Net Flow, Time in List, Average Age, Throughput Run Chart and
Due Date Performance under Kanban flow; Release Burndown and Epic
Progress under Scrum; Workload, Distribution, Dependency Map and Activity
Heatmap under Overview. Each opens like the other charts, with the export
bar at its top, a Chart.js chart and its data table, which is also what
its PDF and Excel export write.
The calculations are pure (models/lib/boardReports.js) and answer one
shape, { bars, table }, so the chart view and both exports read every
report the same way; the server loads only what a report reads. A member
who may see only their assigned cards gets none of them, as with the
other charts. The report names and table headings are translated into
every language.
Thanks to xet7 !
244 lines
13 KiB
JavaScript
244 lines
13 KiB
JavaScript
// Loads the plain records one board report chart needs and hands them to the
|
|
// pure calculations in models/lib/chartCalculations.js. Shared by the
|
|
// `boardChartData` Meteor method (server/publications/boards.js) and the
|
|
// chart PDF/Excel export routes (models/exportCharts.js) so the two answer
|
|
// with the same numbers. Callers are responsible for the authorization check
|
|
// (board.isVisibleBy) - this module only reads data.
|
|
import { ReactiveCache } from '/imports/reactiveCache';
|
|
import Cards from '/models/cards';
|
|
import Activities from '/models/activities';
|
|
|
|
const {
|
|
computeCumulativeFlow,
|
|
computeWipRun,
|
|
computeControlChart,
|
|
computeLeadCycleTime,
|
|
computeBurndown,
|
|
computeBurnup,
|
|
computeThroughput,
|
|
computeCompletionForecast,
|
|
computeFlowEfficiency,
|
|
computeActivityPulse,
|
|
computeDashboardGroups,
|
|
NO_ASSIGNEE_GROUP,
|
|
NO_LABEL_GROUP,
|
|
computeTimeByGroup,
|
|
computeTimeByCard,
|
|
computeCardsByAssigneeGroup,
|
|
computeRemainingTimeSum,
|
|
} = require('/models/lib/chartCalculations');
|
|
|
|
async function loadBoardReport(board, lists, report, options, computeBoardReport) {
|
|
const boardId = board._id;
|
|
const needs = new Set(report.needs || []);
|
|
const cards = await Cards.find({ boardId, type: { $ne: 'template-container' } }, { fields: {
|
|
title: 1, listId: 1, swimlaneId: 1, createdAt: 1, archivedAt: 1, archived: 1, endAt: 1, dueAt: 1,
|
|
assignees: 1, members: 1, labelIds: 1, parentId: 1, cardDependencies: 1, scrum: 1,
|
|
} }).fetchAsync();
|
|
const input = { cards, lists, labels: board.labels || [], now: new Date() };
|
|
if (needs.has('history')) {
|
|
input.history = await require('/models/changeHistory').default.find(
|
|
{ boardId, entityType: 'card', group: 'position' },
|
|
{ fields: { entityId: 1, previousContent: 1, newContent: 1, createdAt: 1 } },
|
|
).fetchAsync();
|
|
}
|
|
if (needs.has('releases')) {
|
|
input.releases = await require('/models/scrumReleases').default.find(
|
|
{ boardId }, { fields: { _id: 1, name: 1 }, sort: { plannedEnd: 1, name: 1 } }).fetchAsync();
|
|
}
|
|
if (needs.has('activities')) {
|
|
const since = new Date(Date.now() - 365 * 86400000);
|
|
input.activities = await Activities.find({ boardId, createdAt: { $gte: since } }, { fields: { createdAt: 1 } }).fetchAsync();
|
|
}
|
|
if (needs.has('users')) {
|
|
const ids = [...new Set(cards.flatMap(c => [...(c.assignees || []), ...(c.members || [])]))];
|
|
const users = ids.length ? await ReactiveCache.getUsers({ _id: { $in: ids } }, { fields: { username: 1, 'profile.fullname': 1 } }) : [];
|
|
// An export follows Admin Panel / Anonymize export users, as every export does.
|
|
if (options.forExport) await require('/models/lib/importExportSecurity').anonymizeExportIdentities({ boardId, users, cards });
|
|
const byId = new Map(users.map(u => [u._id, u]));
|
|
input.nameOf = id => (byId.get(id) && ((byId.get(id).profile || {}).fullname || byId.get(id).username)) || id;
|
|
}
|
|
return computeBoardReport(report.key, input);
|
|
}
|
|
|
|
export async function loadBoardChartData(boardId, chartKey, options = {}) {
|
|
const board = await ReactiveCache.getBoard(boardId);
|
|
if (!board) return null;
|
|
|
|
const lists = await ReactiveCache.getLists({ boardId, archived: false }, { sort: { sort: 1 } });
|
|
// The reports of 2026-11-20 (models/lib/boardReports.js): each loads only
|
|
// what it reads, and every one answers { bars, table }.
|
|
const { reportByKey, computeBoardReport } = require('/models/lib/boardReports');
|
|
const report = reportByKey(chartKey);
|
|
if (report) return loadBoardReport(board, lists, report, options, computeBoardReport);
|
|
const { FLOW_CHART_KEYS, computeFlowAnalytics } = require('/models/lib/flowAnalytics');
|
|
const advanced = FLOW_CHART_KEYS.includes(chartKey);
|
|
const cardFields = {
|
|
fields: {
|
|
title: 1, listId: 1, createdAt: 1, archivedAt: 1, archived: 1,
|
|
startAt: 1, endAt: 1, dueAt: 1, spentTime: 1, isOvertime: 1,
|
|
assignees: 1, members: 1, labelIds: 1,
|
|
...(advanced ? { boardId: 1, poker: 1, customFields: 1, cardDependencies: 1, deletedAt: 1 } : {}),
|
|
},
|
|
};
|
|
const rawCards = await Cards.find({ boardId }, cardFields).fetchAsync();
|
|
const { fieldReadContext } = require('/server/lib/adminFieldReadContext');
|
|
const { redact } = require('/models/lib/adminOnlyCustomFields');
|
|
const policy = fieldReadContext.getStore();
|
|
const allCards = policy ? redact(rawCards, policy.definitions, policy.adminBoards, boardId) : rawCards;
|
|
if (advanced) {
|
|
const ChangeHistory = require('/models/changeHistory').default;
|
|
const [events, history, fields] = await Promise.all([
|
|
['agingWip', 'blockerAnalysis'].includes(chartKey) ? Activities.find(
|
|
{ boardId, activityType: { $in: ['createCard', 'moveCard', 'moveCardBoard', 'archivedCard', 'restoredCard'] } },
|
|
{ fields: { cardId: 1, listId: 1, oldListId: 1, createdAt: 1, activityType: 1 } },
|
|
).fetchAsync() : [],
|
|
ChangeHistory.find(
|
|
{ boardId, entityType: 'card', group: { $in: ['position', 'dates', 'lifecycle', 'dependencies'] } },
|
|
{ fields: { entityType: 1, entityId: 1, group: 1, previousContent: 1, newContent: 1, createdAt: 1 } },
|
|
).fetchAsync(),
|
|
chartKey === 'sizeCycleTime' ? ReactiveCache.getCustomFields({ boardIds: boardId, type: 'number' }) : [],
|
|
]);
|
|
// Universal position history also covers restores. Its newer position
|
|
// wins over an earlier activity; same-list records do not reset age.
|
|
for (const row of history.filter(row => row.group === 'position')) {
|
|
events.push({ cardId: row.entityId, listId: row.newContent?.listId,
|
|
oldListId: row.previousContent?.listId, createdAt: row.createdAt, activityType: 'moveCard' });
|
|
}
|
|
const { withRemovedCards } = require('/models/lib/timeHistory');
|
|
return computeFlowAnalytics(chartKey, withRemovedCards(allCards, history, boardId), lists, events, fields, options, new Date(), history);
|
|
}
|
|
|
|
const firstCreatedAt = allCards.reduce(
|
|
(min, card) => (!min || card.createdAt < min ? card.createdAt : min), null);
|
|
const fromDate = firstCreatedAt || new Date();
|
|
const toDate = new Date();
|
|
|
|
if (chartKey === 'pulse') {
|
|
// #1292 ("GitHub Pulse-like graph"): total board activity per day over a
|
|
// fixed recent window, independent of allCards' fromDate (a quiet board
|
|
// with old cards should still show a 30-day-wide, mostly-zero chart
|
|
// rather than one card's creation date away).
|
|
const pulseToDate = new Date();
|
|
const pulseFromDate = new Date(pulseToDate);
|
|
pulseFromDate.setUTCDate(pulseFromDate.getUTCDate() - 29);
|
|
const pulseActivities = await Activities.find(
|
|
{ boardId, createdAt: { $gte: pulseFromDate, $lte: pulseToDate } },
|
|
{ fields: { createdAt: 1 } },
|
|
).fetchAsync();
|
|
return {
|
|
series: computeActivityPulse(pulseActivities, pulseFromDate, pulseToDate, 'day'),
|
|
};
|
|
}
|
|
|
|
if (chartKey === 'cumulativeFlow' || chartKey === 'wipRun') {
|
|
const events = await Activities.find(
|
|
{ boardId, activityType: { $in: ['createCard', 'moveCard', 'archivedCard', 'restoredCard'] } },
|
|
{ fields: { activityType: 1, cardId: 1, listId: 1, createdAt: 1 }, sort: { createdAt: 1 } },
|
|
).fetchAsync();
|
|
|
|
if (chartKey === 'cumulativeFlow') {
|
|
return {
|
|
lists: lists.map(list => ({ _id: list._id, title: list.title })),
|
|
series: computeCumulativeFlow(lists, events, fromDate, toDate),
|
|
};
|
|
}
|
|
const wipListIds = lists.length > 2 ? lists.slice(1, -1).map(l => l._id) : lists.map(l => l._id);
|
|
const wipLimit = lists.length > 2
|
|
? lists.slice(1, -1).reduce((sum, list) =>
|
|
(list.wipLimit && list.wipLimit.enabled) ? sum + (list.wipLimit.value || 0) : sum, 0) || null
|
|
: null;
|
|
return { series: computeWipRun(wipListIds, events, fromDate, toDate, wipLimit) };
|
|
}
|
|
|
|
if (chartKey === 'controlChart') return { points: computeControlChart(allCards) };
|
|
if (chartKey === 'leadTime' || chartKey === 'cycleTime') return { points: computeLeadCycleTime(allCards) };
|
|
if (chartKey === 'burndown') return { series: computeBurndown(allCards, fromDate, toDate) };
|
|
if (chartKey === 'burnup') return { series: computeBurnup(allCards, fromDate, toDate) };
|
|
if (chartKey === 'throughputHistogram') {
|
|
const series = computeThroughput(allCards, 'week');
|
|
// #1476 ("completion estimates based on velocity"): a forward-looking
|
|
// projection alongside the histogram itself - at the recent weekly
|
|
// completion rate, when the cards still open would be done.
|
|
return { series, forecast: computeCompletionForecast(allCards, series, 7, 4) };
|
|
}
|
|
if (chartKey === 'flowEfficiency') return { points: computeFlowEfficiency(allCards) };
|
|
|
|
if (chartKey === 'gantt') {
|
|
return {
|
|
cards: allCards
|
|
.filter(card => card.startAt || card.dueAt || card.endAt || card.createdAt)
|
|
.sort((a, b) => new Date(a.startAt || a.createdAt) - new Date(b.startAt || b.createdAt))
|
|
.map(card => ({
|
|
title: card.title, startAt: card.startAt || null, dueAt: card.dueAt || null, endAt: card.endAt || null,
|
|
})),
|
|
};
|
|
}
|
|
|
|
if (chartKey === 'dashboard' || chartKey === 'time' || chartKey === 'groupByAssignee') {
|
|
const usersById = {};
|
|
const adjustmentsHistory = chartKey === 'time'
|
|
? await require('/models/changeHistory').default.find({ boardId, entityType: 'card',
|
|
$or: [{ 'newContent.field': 'spentTime' }, { 'previousContent.field': 'spentTime' }, { group: 'lifecycle' }] }).fetchAsync() : [];
|
|
const userIds = new Set(adjustmentsHistory.map(row => row.userId).filter(Boolean));
|
|
allCards.forEach(card => (card.assignees || []).forEach(id => userIds.add(id)));
|
|
await Promise.all([...userIds].map(async id => {
|
|
usersById[id] = await ReactiveCache.getUser({ _id: id });
|
|
}));
|
|
// A chart EXPORT (PDF / Excel) follows Admin Panel / Anonymize export
|
|
// users like every other export; the chart views keep the names
|
|
// (CrossBoardExportBleed - only the JSON export anonymized).
|
|
if (options.forExport) {
|
|
await require('/models/lib/importExportSecurity').anonymizeExportIdentities({
|
|
boardId, users: Object.values(usersById).filter(Boolean), cards: allCards });
|
|
}
|
|
const nameOf = id => (usersById[id] && (usersById[id].profile?.fullname || usersById[id].username)) || id;
|
|
|
|
if (chartKey === 'time') {
|
|
// #812 ("reporting total hours by resource and task type"): who logged
|
|
// how many hours, and which cards those hours went to. Matches the
|
|
// Time view's own "archived: false" summary above it.
|
|
const activeCards = allCards.filter(card => !card.archived);
|
|
const { timeAdjustments, withRemovedCards } = require('/models/lib/timeHistory');
|
|
const titles = new Map(withRemovedCards(allCards, adjustmentsHistory, boardId).map(card => [card._id, card.title]));
|
|
return {
|
|
adjustments: timeAdjustments(adjustmentsHistory, nameOf, id => titles.get(id) || id),
|
|
byAssignee: computeTimeByGroup(activeCards, card =>
|
|
(card.assignees || []).map(id => ({ key: id, label: nameOf(id) })), NO_ASSIGNEE_GROUP),
|
|
byCard: computeTimeByCard(activeCards),
|
|
// #1121 ("show the SUM of remaining time until due date"): the same
|
|
// activeCards set as above (archived cards excluded); a card also
|
|
// needs an unset completion date and a dueAt to count - see
|
|
// computeRemainingTimeSum's own comment for why an overdue card
|
|
// still counts, as a negative amount.
|
|
remaining: computeRemainingTimeSum(activeCards),
|
|
};
|
|
}
|
|
|
|
if (chartKey === 'groupByAssignee') {
|
|
// #4688 ("grouping cards by assignee"): the same "which cards count
|
|
// under which assignee" fold the Dashboard/Time views already use,
|
|
// but returning the cards themselves rather than a count/hours total,
|
|
// for a team-meeting-friendly read-only overview. Archived cards are
|
|
// excluded, matching the Time view's own "archived: false" summary.
|
|
const activeCards = allCards.filter(card => !card.archived);
|
|
return {
|
|
groups: computeCardsByAssigneeGroup(activeCards, card =>
|
|
(card.assignees || []).map(id => ({ key: id, label: nameOf(id) })), NO_ASSIGNEE_GROUP),
|
|
};
|
|
}
|
|
|
|
const labelById = Object.fromEntries((board.labels || []).map(l => [l._id, l.name || l.color]));
|
|
return {
|
|
byAssignee: computeDashboardGroups(allCards, card =>
|
|
(card.assignees || []).map(id => ({ key: id, label: nameOf(id) })), NO_ASSIGNEE_GROUP),
|
|
byLabel: computeDashboardGroups(allCards, card =>
|
|
(card.labelIds || []).map(id => ({ key: id, label: labelById[id] || id })), NO_LABEL_GROUP),
|
|
byList: computeDashboardGroups(allCards, card =>
|
|
[{ key: card.listId, label: (lists.find(l => l._id === card.listId) || {}).title || card.listId }]),
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|