bo/worklenz
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
87bd1b88018f2e5d7d2c9a76098647025035e5c4
worklenz/worklenz-backend/src/controllers/reporting-controller.ts

1845 lines
89 KiB
TypeScript
Raw Blame History

import moment from "moment";
import Excel from "exceljs";
import { IWorkLenzRequest } from "../interfaces/worklenz-request";
import { IWorkLenzResponse } from "../interfaces/worklenz-response";
import db from "../config/db";
import HandleExceptions from "../decorators/handle-exceptions";
import { formatDuration, getColor, log_error } from "../shared/utils";
import { ServerResponse } from "../models/server-response";
import WorklenzControllerBase from "./worklenz-controller-base";
import { TASK_STATUS_COLOR_ALPHA } from "../shared/constants";
const YESTERDAY = "YESTERDAY";
const LAST_WEEK = "LAST_WEEK";
const LAST_MONTH = "LAST_MONTH";
const LAST_QUARTER = "LAST_QUARTER";
export default class ReportingController extends WorklenzControllerBase {
@HandleExceptions()
public static async create(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const q = ``;
const result = await db.query(q, []);
const [data] = result.rows;
return res.status(200).send(new ServerResponse(true, data));
}
@HandleExceptions()
public static async getEstimatedVsActualTime(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const teams = (req.body.teams || []) as string[]; // ids
const teamIds = teams.map(id => `'${id}'`).join(",");
const projectStatus = (req.body.projectStatus || []) as string[]; // ids
const projectStatusIds = projectStatus.map(id => `'${id}'`).join(",");
if (!teams.length || !projectStatus.length) {
return res.status(200).send(new ServerResponse(true, {}));
}
const q = `SELECT id,
name,
(SELECT SUM(time_spent)
FROM task_work_log
WHERE task_id IN (SELECT id
FROM tasks
WHERE project_id = projects.id))::INT AS total_logged_time,
(SELECT SUM(total_minutes * 60)
FROM tasks
WHERE project_id = projects.id)::INT AS total_estimated_time,
(SELECT COUNT(*) FROM tasks WHERE project_id = projects.id)
FROM projects
WHERE team_id IN (${teamIds})
AND status_id IN (${projectStatusIds})
ORDER BY name;`;
const result = await db.query(q, []);
const selectedProjects: any = [];
const estimated: any = [];
const estimated_string: any = [];
const logged: any = [];
const logged_string: any = [];
if (result.rows.length) {
result.rows.forEach((element: { name: string; total_estimated_time: string; total_logged_time: string }) => {
selectedProjects.push(element.name);
estimated.push(element.total_estimated_time ? parseFloat(moment.duration(element.total_estimated_time, "seconds").asHours().toFixed(2)) : 0);
logged.push(element.total_logged_time ? parseFloat(moment.duration(element.total_logged_time, "seconds").asHours().toFixed(2)) : 0);
estimated_string.push(formatDuration(moment.duration(element.total_logged_time || "0", "seconds")));
logged_string.push(formatDuration(moment.duration(element.total_logged_time || "0", "seconds")));
});
}
return res.status(200).send(new ServerResponse(true, {
projects: selectedProjects,
estimated,
logged,
estimated_string,
logged_string
}));
}
private static getDateRangeClause(key: string, dateRange: string[]) {
if (dateRange.length === 2) {
const start = moment(dateRange[0]).format("YYYY-MM-DD");
const end = moment(dateRange[1]).format("YYYY-MM-DD");
if (start === end) {
return `task_work_log.created_at::DATE = '${start}'::DATE`;
}
return `task_work_log.created_at::DATE >= '${start}'::DATE AND task_work_log.created_at < '${end}'::DATE + INTERVAL '1 day'`;
}
if (key === YESTERDAY)
return "task_work_log.created_at >= (CURRENT_DATE - INTERVAL '1 day')::DATE AND task_work_log.created_at < CURRENT_DATE::DATE";
if (key === LAST_WEEK)
return "task_work_log.created_at >= (CURRENT_DATE - INTERVAL '1 week')::DATE AND task_work_log.created_at < CURRENT_DATE::DATE";
if (key === LAST_MONTH)
return "task_work_log.created_at >= (CURRENT_DATE - INTERVAL '1 month')::DATE AND task_work_log.created_at < CURRENT_DATE::DATE";
if (key === LAST_QUARTER)
return "task_work_log.created_at >= (CURRENT_DATE - INTERVAL '3 months')::DATE AND task_work_log.created_at < CURRENT_DATE::DATE";
return null;
}
private static async getTimeLoggesByProjects(projects: string[], users: string[], key: string, dateRange: string[], archived = false) {
try {
const projectIds = projects.map(p => `'${p}'`).join(",");
const userIds = users.map(u => `'${u}'`).join(",");
const duration = ReportingController.getDateRangeClause(key || LAST_WEEK, dateRange);
const q = `
SELECT projects.name,
projects.color_code,
sps.name AS status_name,
sps.color_code AS status_color_code,
sps.icon AS status_icon,
(SELECT COUNT(*)
FROM tasks
WHERE CASE WHEN ($1 IS TRUE) THEN project_id IS NOT NULL ELSE archived = FALSE END
AND project_id = projects.id) AS all_tasks_count,
(SELECT COUNT(*)
FROM tasks
WHERE CASE WHEN ($1 IS TRUE) THEN project_id IS NOT NULL ELSE archived = FALSE END
AND project_id = projects.id
AND status_id IN (SELECT id
FROM task_statuses
WHERE project_id = projects.id
AND category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS TRUE))) AS completed_tasks_count,
(
--
SELECT COALESCE(JSON_AGG(r), '[]'::JSON)
FROM (
--
SELECT name,
(SELECT COALESCE(SUM(time_spent), 0)
FROM task_work_log
LEFT JOIN tasks t ON task_work_log.task_id = t.id
WHERE user_id = users.id
AND CASE WHEN ($1 IS TRUE) THEN t.project_id IS NOT NULL ELSE t.archived = FALSE END
AND t.project_id = projects.id
AND ${duration}) AS time_logged
FROM users
WHERE id IN (${userIds})
ORDER BY name
--
) r
--
) AS time_logs
FROM projects
LEFT JOIN sys_project_statuses sps ON projects.status_id = sps.id
WHERE projects.id IN (${projectIds})
AND EXISTS(SELECT 1
FROM task_work_log
LEFT JOIN tasks t ON task_work_log.task_id = t.id
WHERE CASE WHEN ($1 IS TRUE) THEN t.project_id IS NOT NULL ELSE t.archived = FALSE END
AND t.project_id = projects.id
AND ${duration});
`;
const result = await db.query(q, [archived]);
const format = (seconds: number) => {
const duration = moment.duration(seconds, "seconds");
const formattedDuration = `${~~(duration.asHours())}h ${duration.minutes()}m ${duration.seconds()}s`;
return formattedDuration;
};
for (const project of result.rows) {
if (project.all_tasks_count > 0) {
project.progress = Math.round((project.completed_tasks_count / project.all_tasks_count) * 100);
} else {
project.progress = 0;
}
let total = 0;
for (const log of project.time_logs) {
total += log.time_logged;
log.time_logged = format(log.time_logged);
}
project.total = format(total);
}
return result.rows;
} catch (error) {
log_error(error);
}
return [];
}
@HandleExceptions()
public static async getReportingOverviewStats(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { includeArchived } = req.query;
const q = `SELECT get_reporting_overview_stats($1, $2);`;
const result = await db.query(q, [req.user?.id, includeArchived]);
const [data] = result.rows;
return res.status(200).send(new ServerResponse(true, data.get_reporting_overview_stats || {}));
}
@HandleExceptions()
public static async getReportingProjectStats(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { includeArchived } = req.query;
const q = `SELECT get_reporting_projects_stats($1, $2) AS stats;`;
const result = await db.query(q, [req.user?.id, includeArchived]);
const [data] = result.rows;
const { total_estimated, total_logged } = data.stats;
data.stats.progress = data.stats.all_tasks_count > 0
? ((data.stats.completed_tasks_count / data.stats.all_tasks_count) * 100).toFixed(0) : 0;
const totalMinutes = moment.duration(total_estimated, "seconds");
const totalSeconds = moment.duration(total_logged, "seconds");
data.stats.total_estimated_hours_string = formatDuration(totalMinutes);
data.stats.total_logged_hours_string = formatDuration(totalSeconds);
data.stats.overlogged_hours = formatDuration(totalMinutes.subtract(totalSeconds));
return res.status(200).send(new ServerResponse(true, data.stats || {}));
}
@HandleExceptions()
public static async getReportingTeams(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { includeArchived } = req.query;
const q = `SELECT t.id,
t.name,
(SELECT COUNT(*)
FROM projects
WHERE projects.team_id = tm.team_id
AND CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS(SELECT project_id
FROM archived_projects
WHERE project_id = projects.id
AND user_id = $1) END) AS projects_count,
(SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(rec))), '[]'::JSON)
FROM (SELECT CASE
WHEN u.name IS NOT NULL THEN u.name
ELSE (SELECT name
FROM email_invitations
WHERE team_member_id = team_members.id) END,
avatar_url
FROM team_members
LEFT JOIN users u ON team_members.user_id = u.id
WHERE team_id = t.id) rec) AS team_members
FROM teams t
CROSS JOIN team_members tm
WHERE tm.team_id = t.id
AND tm.user_id = $1
AND role_id IN
(SELECT id FROM roles WHERE roles.team_id = t.id AND (admin_role IS TRUE OR owner IS TRUE))
ORDER BY t.name;`;
const result = await db.query(q, [req.user?.id, includeArchived]);
for (const team of result.rows) {
team.names = this.createTagList(team?.team_members);
team.names.map((a: any) => a.color_code = getColor(a.name));
}
return res.status(200).send(new ServerResponse(true, result.rows || []));
}
@HandleExceptions()
public static async getProjectsByTeam(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { id, includeArchived } = req.query;
const q = `SELECT p.name,
sps.name AS status,
sps.icon AS status_icon,
sps.color_code AS status_color,
p.color_code,
end_date AS due_date,
(SELECT SUM(time_spent)
FROM task_work_log
WHERE task_id IN (SELECT id FROM tasks WHERE project_id = p.id))::INT AS total_spent,
(SELECT SUM(total_minutes * 60) FROM tasks WHERE project_id = p.id)::INT AS total_estimated,
(SELECT get_project_members(p.id)) AS project_members,
(SELECT (SELECT CASE
WHEN (end_date::DATE < NOW()::DATE AND p.status_id NOT IN (SELECT ID
FROM sys_project_statuses
WHERE sys_project_statuses.name IN ('Completed', 'Cancelled')))
THEN NOW()::DATE - end_date::DATE
ELSE 0 END)) AS overdue
FROM projects p
LEFT JOIN sys_project_statuses sps ON p.status_id = sps.id
WHERE team_id = $1
AND CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS(SELECT project_id
FROM archived_projects
WHERE project_id = p.id
AND user_id = $3) END
ORDER BY p.name`;
const result = await db.query(q, [id, includeArchived, req.user?.id]);
for (const project of result.rows) {
project.total_spent_string = formatDuration(moment.duration(project.total_spent || "0", "seconds"));
project.total_allocation = formatDuration(moment.duration(project.total_estimated || "0", "seconds"));
const overlogged = project.total_estimated - project.total_spent;
project.overlogged = formatDuration(moment.duration((overlogged < 0 ? overlogged : 0) || "0", "seconds"));
project.project_member_names = this.createTagList(project?.project_members);
project.project_member_names.map((a: any) => a.color_code = getColor(a.name));
}
return res.status(200).send(new ServerResponse(true, result.rows || []));
}
@HandleExceptions()
public static async getEstimatedVsLogged(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { includeArchived } = req.query;
const q = `SELECT t.id,
t.name,
(SELECT SUM(time_spent)
FROM task_work_log
WHERE task_id IN (SELECT id
FROM tasks
WHERE project_id IN (SELECT id
FROM projects
WHERE team_id = t.id
AND CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS(SELECT project_id
FROM archived_projects
WHERE project_id = projects.id
AND user_id = $1) END)))::INT AS total_logged,
(SELECT SUM(total_minutes * 60)
FROM tasks
WHERE project_id IN (SELECT id
FROM projects
WHERE team_id = t.id
AND CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS(SELECT project_id
FROM archived_projects
WHERE project_id = projects.id
AND user_id = $1) END))::INT AS total_estimated
FROM teams t
LEFT JOIN team_members tm ON t.id = tm.team_id
WHERE tm.user_id = $1
AND role_id IN (SELECT id
FROM roles
WHERE (admin_role IS TRUE OR owner IS TRUE))
ORDER BY name;`;
const result = await db.query(q, [req.user?.id, includeArchived]);
const total_logged: { name: string, y: number }[] = [];
const total_estimated: { name: string, y: number }[] = [];
result.rows.forEach((element: { name: string; total_logged: number; total_estimated: number; }) => {
total_logged.push({ name: element.name, y: element.total_logged || 0 });
total_estimated.push({ name: element.name, y: element.total_estimated || 0 });
});
return res.status(200).send(new ServerResponse(true, { total_estimated, total_logged }));
}
@HandleExceptions()
public static async getById(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { id, includeArchived } = req.query;
const q = `SELECT p.name,
sps.name,
sps.icon,
sps.color_code AS status_color,
p.color_code,
end_date AS due_date,
(SELECT SUM(time_spent)
FROM task_work_log
WHERE task_id IN (SELECT id FROM tasks WHERE project_id = p.id)),
(SELECT SUM(total_minutes * 60) FROM tasks WHERE project_id = p.id)
FROM projects p
LEFT JOIN sys_project_statuses sps ON p.status_id = sps.id
WHERE team_id = $1
AND CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS(SELECT project_id
FROM archived_projects
WHERE project_id = p.id
AND user_id = $3) END`;
const result = await db.query(q, [id, includeArchived, req.user?.id]);
for (const team of result.rows) {
team.names = this.createTagList(team?.team_members);
team.names.map((a: any) => a.color_code = getColor(a.name));
}
return res.status(200).send(new ServerResponse(true, result.rows || []));
}
@HandleExceptions()
public static async getAllocation(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const teams = (req.body.teams || []) as string[]; // ids
const teamIds = teams.map(id => `'${id}'`).join(",");
const projectIds = (req.body.projects || []) as string[];
if (!teamIds || !projectIds.length)
return res.status(200).send(new ServerResponse(true, { users: [], projects: [] }));
const q = `SELECT id, (SELECT name)
FROM users
WHERE id IN (SELECT user_id
FROM team_members
WHERE team_id IN (${teamIds}))
GROUP BY id
ORDER BY name`;
const result = await db.query(q, []);
const users = result.rows;
const userIds = users.map((u: any) => u.id);
const projects = await ReportingController.getTimeLoggesByProjects(projectIds, userIds, req.body.duration, req.body.date_range, (req.query.archived === "true"));
return res.status(200).send(new ServerResponse(true, { users, projects }));
}
@HandleExceptions()
public static async getMyTeams(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const q = `SELECT team_id AS id, name
FROM team_members tm
LEFT JOIN teams ON teams.id = tm.team_id
WHERE tm.user_id = $1
AND role_id IN (SELECT id
FROM roles
WHERE (admin_role IS TRUE OR owner IS TRUE))
ORDER BY name;`;
const result = await db.query(q, [req.user?.id]);
result.rows.forEach((team: any) => team.selected = true);
return res.status(200).send(new ServerResponse(true, result.rows));
}
@HandleExceptions()
public static async getCategoriesByTeams(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const selectedTeams = (req.body || []) as string[]; // ids
const ids = selectedTeams.map(id => `'${id}'`).join(",");
if (!ids)
return res.status(200).send(new ServerResponse(true, []));
const q = `SELECT id, name, color_code FROM project_categories WHERE team_id IN (${ids}) ORDER BY name`;
const result = await db.query(q, []);
result.rows.forEach((team: any) => team.selected = true);
return res.status(200).send(new ServerResponse(true, result.rows));
}
@HandleExceptions()
public static async getProjectsByTeams(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const selectedTeams = (req.body.selectedTeams || []) as string[];
const selectedCategories = (req.body.selectedCategories || []) as string[];
const isNoCategorySelected = req.body.noCategoryIncluded;
const ids = selectedTeams.map(id => `'${id}'`).join(",");
const categories = selectedCategories.map(id => `'${id}'`).join(",");
let categoryQ = "";
let noCategoryQ = "";
if (!ids || (!categories && !isNoCategorySelected))
return res.status(200).send(new ServerResponse(true, []));
if (categories && isNoCategorySelected) {
categoryQ = `AND (category_id IS NULL OR category_id IN (${categories}))`;
} else if (!categories && isNoCategorySelected) {
noCategoryQ = `AND category_id IS NULL`;
} else if (categories && !isNoCategorySelected) {
categoryQ = `AND category_id IN (${categories})`;
}
// if (categories)
// categoryQ = `AND category_id IN (${categories})`;
// if (isNoCategorySelected === true)
// noCategoryQ = `OR (team_id IN (${ids}) AND category_id IS NULL)`;
const q = `SELECT id, name
FROM projects
WHERE team_id IN (${ids})
${categoryQ}
${noCategoryQ}
ORDER BY name;`;
const result = await db.query(q, []);
result.rows.forEach((team: any) => team.selected = true);
return res.status(200).send(new ServerResponse(true, result.rows));
}
public static async getReportingTeamsExport(userId: string, include_archived: boolean) {
if (!userId) return [];
const q = `
SELECT t.id,
t.name,
(SELECT COUNT(*)
FROM projects
WHERE projects.team_id = tm.team_id
AND CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS(SELECT 1
FROM archived_projects
WHERE project_id = projects.id
AND user_id = $1) END) AS projects_count,
(SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(rec))), '[]'::JSON)
FROM (SELECT COALESCE(u.name, (SELECT name
FROM email_invitations
WHERE team_member_id = team_members.id)),
avatar_url
FROM team_members
LEFT JOIN users u ON team_members.user_id = u.id
WHERE team_id = t.id) rec) AS team_members,
(SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(rec))), '[]'::JSON)
FROM (SELECT p.name,
sps.name AS status,
end_date AS due_date,
(SELECT SUM(time_spent)
FROM task_work_log
WHERE task_id IN (SELECT id FROM tasks WHERE project_id = p.id))::INT AS total_spent,
(SELECT SUM(total_minutes * 60) FROM tasks WHERE project_id = p.id)::INT AS total_estimated,
(SELECT get_project_members(p.id)) AS project_members,
(SELECT (SELECT CASE
WHEN (end_date::DATE < NOW()::DATE AND p.status_id NOT IN (SELECT ID
FROM sys_project_statuses
WHERE sys_project_statuses.name IN ('Completed', 'Cancelled')))
THEN NOW()::DATE - end_date::DATE
ELSE 0 END)) AS overdue
FROM projects p
LEFT JOIN sys_project_statuses sps ON p.status_id = sps.id
WHERE team_id = t.id
AND (CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS(SELECT 1
FROM archived_projects
WHERE project_id = p.id
AND user_id = $1) END)
ORDER BY p.name) rec) AS projects
FROM teams t
CROSS JOIN team_members tm
WHERE tm.team_id = t.id
AND tm.user_id = $1
AND role_id IN (SELECT id FROM roles WHERE roles.team_id = t.id AND (admin_role IS TRUE OR owner IS TRUE))
ORDER BY t.name;
`;
const result = await db.query(q, [userId, include_archived]);
return result.rows;
}
@HandleExceptions()
public static async exportOverviewExcel(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<void> {
const includeArchived = req.query.includeArchived == "true";
const results = await this.getReportingTeamsExport(req.user?.id as string, includeArchived);
const exportDate = moment().format("MMM-DD-YYYY");
const fileName = `${exportDate} - Reporting Overview`;
const workbook = new Excel.Workbook();
for (const item of results) {
const sheet = workbook.addWorksheet(item.name.replace(/[&\/\\#,+()$~%.'":*?<>{}]/g, "_"));
sheet.columns = [
{ header: "Project", key: "project", width: 30 },
{ header: "Status", key: "status", width: 20 },
{ header: "Due Date", key: "due_date", width: 20 },
{ header: "Overdue", key: "overdue", width: 20 },
{ header: "Total Allocation", key: "total_allocation", width: 20 },
{ header: "Over Logged Time", key: "over_logged_time", width: 20 },
{ header: "Members", key: "members", width: 30 },
];
sheet.getCell("A1").value = `Team : ${item.name}`;
sheet.mergeCells("A1:G1");
sheet.getCell("A1").alignment = { horizontal: "center" };
sheet.getCell("A1").style.fill = {
type: "pattern",
pattern: "solid",
fgColor: { argb: "D9D9D9" }
};
sheet.getCell("A1").font = {
size: 16
};
sheet.getCell("A2").value = `Exported on : ${exportDate}`;
sheet.mergeCells("A2:G2");
sheet.getCell("A2").alignment = { horizontal: "center" };
sheet.getCell("A2").style.fill = {
type: "pattern",
pattern: "solid",
fgColor: { argb: "F2F2F2" }
};
sheet.getCell("A2").font = {
size: 12
};
sheet.getRow(4).values = [
"Project",
"Status",
"Due Date",
"Overdue",
"Total Allocation",
"Over Logged Time",
"Members",
];
sheet.getRow(4).font = {
bold: true
};
for (const project of item.projects) {
const overlogged = project.total_estimated - project.total_spent;
const overloggedTime = formatDuration(moment.duration((overlogged < 0 ? overlogged : 0) || "0", "seconds"));
sheet.addRow({
project: project.name,
status: project.status,
due_date: project.due_date ? moment(project.due_date).format("MMM DD,YYYY") : "-",
overdue: project.overdue ? `${project.overdue} days` : "-",
total_allocation: formatDuration(moment.duration(project.total_estimated || "0", "seconds")),
over_logged_time: overloggedTime,
members: this.getMembers(project)
});
}
}
res.setHeader("Content-Type", "application/vnd.openxmlformats");
res.setHeader("Content-Disposition", `attachment; filename=${fileName}.xlsx`);
await workbook.xlsx.write(res)
.then(() => {
res.end();
});
}
private static getMembers(project: any) {
return project.project_members.length > 0 ? project.project_members.map((member: {
name: any;
}) => member.name).join(", ") : "-";
}
public static async getAllocationExport(include_archived: string, teamIds: string, projectIds: string[], duration: string, date_range: string[]) {
if (!teamIds || !projectIds.length)
return { users: [], projects: [] };
const q = `SELECT id, (SELECT name)
FROM users
WHERE id IN (SELECT user_id
FROM team_members
WHERE team_id IN (${teamIds}))
GROUP BY id
ORDER BY name`;
const result = await db.query(q, []);
const users = result.rows;
const userIds = users.map((u: any) => u.id);
const projects = await ReportingController.getTimeLoggesByProjects(projectIds, userIds, duration, date_range, (include_archived === "true"));
const dataReturn = { users, projects };
return dataReturn;
}
@HandleExceptions()
public static async exportAllocation(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<void> {
const { includeArchived } = req.query;
const teams = (req.query.teams as string)?.split(",");
const teamIds = teams.map(t => `'${t}'`).join(",");
const projectIds = (req.query.projects as string)?.split(",");
const { duration } = req.query;
const dateRange = (req.query.date_range as string)?.split(",");
const results = await this.getAllocationExport(includeArchived as string, teamIds, projectIds, duration as string, dateRange);
const exportDate = moment().format("MMM-DD-YYYY");
const fileName = `${exportDate} - Reporting Allocation`;
const workbook = new Excel.Workbook();
const sheet = workbook.addWorksheet("Allocation");
sheet.columns = [
{ header: "Project", key: "project", width: 25 },
{ header: "Logged Time", key: "logged_time", width: 20 },
{ header: "Total", key: "total", width: 25 },
];
sheet.getCell("A1").value = `Allocation`;
sheet.mergeCells("A1:G1");
sheet.getCell("A1").alignment = { horizontal: "center" };
sheet.getCell("A1").style.fill = {
type: "pattern",
pattern: "solid",
fgColor: { argb: "D9D9D9" }
};
sheet.getCell("A1").font = {
size: 16
};
sheet.getCell("A2").value = `Exported on : ${exportDate}`;
sheet.mergeCells("A2:G2");
sheet.getCell("A2").alignment = { horizontal: "center" };
sheet.getCell("A2").style.fill = {
type: "pattern",
pattern: "solid",
fgColor: { argb: "F2F2F2" }
};
sheet.getCell("A2").font = {
size: 12
};
if (results.projects.length > 0) {
const rowTop = sheet.getRow(4);
rowTop.getCell(1).value = "";
results.users.forEach((user: any, index: any) => {
rowTop.getCell(index + 2).value = user.name;
});
rowTop.getCell(results.users.length + 2).value = "Total";
// rowTop.getCell(results.users.length + 2).fill = {
// type: "pattern",
// pattern: "solid",
// fgColor: { argb: "F8F7F9" }
// };
rowTop.font = {
bold: true
};
for (const project of results.projects) {
const rowValues = [];
rowValues[1] = project.name;
project.time_logs.forEach((log: any, index: any) => {
rowValues[index + 2] = log.time_logged === "0h 0m 0s" ? "-" : log.time_logged;
});
rowValues[project.time_logs.length + 2] = project.total;
sheet.addRow(rowValues);
const { lastRow } = sheet;
if (lastRow) {
const totalCell = lastRow.getCell(project.time_logs.length + 2);
totalCell.style.font = { bold: true };
}
}
}
res.setHeader("Content-Type", "application/vnd.openxmlformats");
res.setHeader("Content-Disposition", `attachment; filename=${fileName}.xlsx`);
await workbook.xlsx.write(res)
.then(() => {
res.end();
});
}
@HandleExceptions()
public static async getActiveProjects(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { includeArchived } = req.query;
const q = `SELECT id,
name,
updated_at,
end_date,
(SELECT name FROM sys_project_statuses WHERE status_id = sys_project_statuses.id) AS status
FROM projects
WHERE team_id IN (SELECT team_id
FROM team_members
WHERE user_id = $1
AND role_id IN (SELECT id
FROM roles
WHERE (admin_role IS TRUE OR owner IS TRUE)))
AND CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS(SELECT project_id
FROM archived_projects
WHERE project_id = projects.id
AND user_id = $1) END
AND status_id IN (SELECT ID
FROM sys_project_statuses
WHERE sys_project_statuses.name NOT IN ('Completed', 'Cancelled'))
ORDER BY updated_at DESC
LIMIT 10`;
const result = await db.query(q, [req.user?.id, includeArchived]);
for (const project of result.rows) {
project.updated_at_string = moment(project.updated_at).fromNow();
}
return res.status(200).send(new ServerResponse(true, result.rows || []));
}
@HandleExceptions()
public static async getOverdueProjects(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { includeArchived } = req.query;
const q = `SELECT id,
name,
updated_at,
end_date,
(SELECT name FROM sys_project_statuses WHERE status_id = sys_project_statuses.id) AS status,
(SELECT SUM(time_spent)
FROM tasks t
RIGHT JOIN task_work_log twl ON t.id = twl.task_id
WHERE project_id = p.id
AND end_date::DATE < twl.created_at::DATE) AS overlogged_hours
FROM projects p
WHERE team_id IN (SELECT team_id
FROM team_members
WHERE user_id = $1
AND role_id IN (SELECT id
FROM roles
WHERE (admin_role IS TRUE OR owner IS TRUE)))
AND end_date::DATE < CURRENT_DATE::DATE
AND CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS(SELECT project_id
FROM archived_projects
WHERE project_id = p.id
AND user_id = $1) END
AND status_id IN (SELECT ID
FROM sys_project_statuses
WHERE sys_project_statuses.name NOT IN ('Completed', 'Cancelled'))
ORDER BY updated_at DESC
LIMIT 10;`;
const result = await db.query(q, [req.user?.id, includeArchived]);
for (const project of result.rows) {
project.overlogged_hours = formatDuration(moment.duration(project.overlogged_hours, "seconds"));
}
return res.status(200).send(new ServerResponse(true, result.rows || []));
}
@HandleExceptions()
public static async getReportingCustom(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { includeArchived } = req.query;
const { searchQuery, size, offset } = this.toPaginationOptions(req.query, "name");
const teams = (req.body.teams || []) as string[]; // ids
const teamIds = teams.map(id => `'${id}'`).join(",");
const status = (req.body.status || []) as string[];
const statusIds = status.map(p => `'${p}'`).join(",");
if (!teams.length || !status.length)
return res.status(200).send(new ServerResponse(true, { users: [], projects: [] }));
const q = `SELECT COUNT(*) AS total,
(SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(t))), '[]'::JSON)
FROM (SELECT id,
name,
(SELECT name FROM sys_project_statuses WHERE id = status_id) AS status,
(SELECT color_code FROM sys_project_statuses WHERE id = status_id) AS status_color,
(SELECT icon FROM sys_project_statuses WHERE id = status_id) AS status_icon,
(SELECT name FROM teams WHERE team_id = teams.id) AS team_name,
color_code,
start_date,
end_date,
(SELECT COUNT(*)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id) AS all_tasks_count,
(SELECT COUNT(*)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id
AND status_id IN (SELECT id
FROM task_statuses
WHERE project_id = projects.id
AND category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS TRUE))) AS completed_tasks_count,
(SELECT COUNT(*)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id
AND status_id IN (SELECT id
FROM task_statuses
WHERE project_id = projects.id
AND category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_doing IS TRUE))) AS is_doing_tasks_count,
(SELECT COUNT(*)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id
AND status_id IN (SELECT id
FROM task_statuses
WHERE project_id = projects.id
AND category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_todo IS TRUE))) AS is_todo_tasks_count,
(SELECT COUNT(*) FROM project_members WHERE project_id = projects.id) AS members_count,
(SELECT get_project_members(projects.id)) AS names,
(SELECT name FROM clients WHERE id = projects.client_id) AS client_name,
(SELECT name FROM users WHERE id = projects.owner_id) AS project_owner,
(SELECT CASE
WHEN ((SELECT MAX(updated_at)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id) > updated_at)
THEN (SELECT MAX(updated_at)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id)
ELSE updated_at END) AS updated_at
FROM projects
WHERE team_id IN (${teamIds}) ${searchQuery}
AND status_id IN (${statusIds})
AND NOT EXISTS (SELECT user_id
FROM archived_projects
WHERE user_id = $1
AND project_id = projects.id)
AND CASE
WHEN ($4 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS (SELECT project_id
FROM archived_projects
WHERE project_id = projects.id) END
ORDER BY NAME ASC
LIMIT $2 OFFSET $3) t) AS DATA
FROM projects
WHERE team_id IN (${teamIds}) ${searchQuery}
AND status_id IN (${statusIds})
AND NOT EXISTS (SELECT user_id
FROM archived_projects
WHERE user_id = $1
AND project_id = projects.id)
AND CASE
WHEN ($4 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS (SELECT project_id
FROM archived_projects
WHERE project_id = projects.id)
END;`;
const result = await db.query(q, [req.user?.id, size, offset, includeArchived]);
const [obj] = result.rows;
for (const project of obj.data) {
project.completed_percentage = Math.round((project.completed_tasks_count / project.all_tasks_count) * 100);
project.doing_percentage = Math.round((project.is_doing_tasks_count / project.all_tasks_count) * 100);
project.todo_percentage = 100 - (project.completed_percentage + project.doing_percentage);
}
return res.status(200).send(new ServerResponse(true, obj || []));
}
@HandleExceptions()
public static async getProjectDetailsById(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const q = `SELECT name, (SELECT name FROM teams WHERE teams.id = team_id) AS team_name
FROM projects
WHERE id = $1;`;
const result = await db.query(q, [req.params?.id]);
const [data] = result.rows;
return res.status(200).send(new ServerResponse(true, data || { name: "", team_name: "" }));
}
public static async getReportingCustomExport(user_id: string, includeArchived: string, teams: string[], status: string[], searchQuery: string) {
if (!teams.length || !status.length || !user_id)
return { users: [], projects: [] };
const teamIds = teams.map(id => `'${id}'`).join(",");
const statusIds = status.map(s => `'${s}'`).join(",");
const q = `SELECT id,
name,
(SELECT name FROM sys_project_statuses WHERE id = status_id) AS status,
(SELECT color_code FROM sys_project_statuses WHERE id = status_id) AS status_color,
(SELECT icon FROM sys_project_statuses WHERE id = status_id) AS status_icon,
(SELECT name FROM teams WHERE team_id = teams.id) AS team_name,
color_code,
start_date,
end_date,
(SELECT COUNT(*)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id) AS all_tasks_count,
(SELECT COUNT(*)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id
AND status_id IN (SELECT id
FROM task_statuses
WHERE project_id = projects.id
AND category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS TRUE))) AS completed_tasks_count,
(SELECT COUNT(*)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id
AND status_id IN (SELECT id
FROM task_statuses
WHERE project_id = projects.id
AND category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_doing IS TRUE))) AS is_doing_tasks_count,
(SELECT COUNT(*)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id
AND status_id IN (SELECT id
FROM task_statuses
WHERE project_id = projects.id
AND category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_todo IS TRUE))) AS is_todo_tasks_count,
(SELECT COUNT(*) FROM project_members WHERE project_id = projects.id) AS members_count,
(SELECT get_project_members(projects.id)) AS names,
(SELECT name FROM clients WHERE id = projects.client_id) AS client_name,
(SELECT name FROM users WHERE id = projects.owner_id) AS project_owner,
(SELECT CASE
WHEN ((SELECT MAX(updated_at)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id) > updated_at)
THEN (SELECT MAX(updated_at)
FROM tasks
WHERE archived IS FALSE
AND project_id = projects.id)
ELSE updated_at END) AS updated_at
FROM projects
WHERE team_id IN (${teamIds}) ${searchQuery}
AND status_id IN (${statusIds})
AND NOT EXISTS (SELECT user_id
FROM archived_projects
WHERE user_id = $1
AND project_id = projects.id)
AND CASE
WHEN ($2 IS TRUE) THEN team_id IS NOT NULL
ELSE NOT EXISTS (SELECT project_id
FROM archived_projects
WHERE project_id = projects.id)
END ORDER BY NAME ASC;`;
const result = await db.query(q, [user_id, includeArchived]);
return result.rows;
}
@HandleExceptions()
public static async exportProjects(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<void> {
const { includeArchived } = req.query;
const { searchQuery } = this.toPaginationOptions(req.query, "name");
const teams = (req.query.teams as string)?.split(",");
const status = (req.query.status as string)?.split(",");
const results = await this.getReportingCustomExport(req.user?.id as string, includeArchived as string, teams, status, searchQuery) as any;
const exportDate = moment().format("MMM-DD-YYYY");
const fileName = `${exportDate} - Reporting Projects`;
const workbook = new Excel.Workbook();
const sheet = workbook.addWorksheet("Projects");
sheet.columns = [
{ header: "Name", key: "name", width: 25 },
{ header: "Client", key: "client", width: 20 },
{ header: "Status", key: "status", width: 25 },
{ header: "Team", key: "team", width: 25 },
{ header: "Progress", key: "progress", width: 25 },
{ header: "Last Update", key: "updated", width: 25 },
{ header: "Members", key: "members", width: 25 },
];
sheet.getCell("A1").value = `Projects`;
sheet.mergeCells("A1:G1");
sheet.getCell("A1").alignment = { horizontal: "center" };
sheet.getCell("A1").style.fill = {
type: "pattern",
pattern: "solid",
fgColor: { argb: "D9D9D9" }
};
sheet.getCell("A1").font = {
size: 16
};
sheet.getCell("A2").value = `Exported on : ${exportDate}`;
sheet.mergeCells("A2:G2");
sheet.getCell("A2").alignment = { horizontal: "center" };
sheet.getCell("A2").style.fill = {
type: "pattern",
pattern: "solid",
fgColor: { argb: "F2F2F2" }
};
sheet.getCell("A2").font = {
size: 12
};
sheet.getRow(4).values = [
"Name",
"Client",
"Status",
"Team",
"Progress (%)",
"Last Update",
"Members",
];
sheet.getRow(4).font = {
bold: true
};
for (const item of results || []) {
let progressPercentage = "0";
if (item.all_tasks_count > 0) {
progressPercentage = ((item.completed_tasks_count / item.all_tasks_count) * 100).toFixed();
}
sheet.addRow({
name: item.name,
client: item.client_name ? item.client_name : "-",
status: item.status,
team: item.team_name,
progress: progressPercentage,
updated: moment(item.updated_at).format("MMM DD, YYYY"),
members: item.members_count,
});
}
res.setHeader("Content-Type", "application/vnd.openxmlformats");
res.setHeader("Content-Disposition", `attachment; filename=${fileName}.xlsx`);
await workbook.xlsx.write(res)
.then(() => {
res.end();
});
}
@HandleExceptions()
public static async getUnAssignedUsers(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const q = `SELECT DISTINCT user_id, (SELECT name FROM team_member_info_view tmiv WHERE tmiv.team_member_id = tm.id)
FROM team_members tm
LEFT JOIN email_invitations ei ON tm.id = ei.team_member_id
WHERE tm.team_id IN (SELECT team_id
FROM team_members
WHERE user_id = $1
AND role_id IN (SELECT id
FROM roles
WHERE (admin_role IS TRUE OR owner IS TRUE)))
AND team_member_id NOT IN
(SELECT team_member_id
FROM project_members pm
WHERE pm.project_id IN
(SELECT id FROM projects WHERE projects.team_id = tm.team_id));`;
const result = await db.query(q, [req.user?.id]);
return res.status(200).send(new ServerResponse(true, result.rows || []));
}
@HandleExceptions()
public static async getMembersWithOverDueTasks(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const q = `SELECT DISTINCT tm.user_id,
tm.id AS id,
tmiv.name,
(SELECT COUNT(DISTINCT task_id)
FROM tasks_assignees ta
CROSS JOIN tasks t
WHERE ta.team_member_id = tm.id
AND t.id = ta.task_id
AND ((t.end_date::DATE < NOW()::DATE) OR
((t.total_minutes * 60) <
(SELECT SUM(time_spent)
FROM task_work_log twl
WHERE twl.task_id = t.id
AND tm.user_id = tm.user_id)))
AND t.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS FALSE)))::INT AS overdue_tasks,
(SELECT COUNT(DISTINCT project_id)
FROM tasks_assignees ta
CROSS JOIN tasks t
WHERE ta.team_member_id = tm.id
AND t.id = ta.task_id
AND ((t.end_date::DATE < NOW()::DATE) OR
((t.total_minutes * 60) <
(SELECT SUM(time_spent)
FROM task_work_log twl
WHERE twl.task_id = t.id
AND tm.user_id = tm.user_id)))
AND t.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS FALSE)))::INT AS projects,
(SELECT SUM(t.total_minutes * 60) - SUM(twl.time_spent)
FROM tasks_assignees ta
CROSS JOIN tasks t,
task_work_log twl
WHERE ta.team_member_id = tm.id
AND twl.task_id = t.id
AND twl.user_id = tm.user_id
AND t.id = ta.task_id
AND ((t.end_date::DATE < NOW()::DATE) OR
((t.total_minutes * 60) <
(SELECT SUM(time_spent)
FROM task_work_log twl
WHERE twl.task_id = t.id
AND tm.user_id = tm.user_id)))
AND t.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS FALSE))) AS overdue_time
FROM team_members tm
LEFT JOIN team_member_info_view tmiv ON tm.id = tmiv.team_member_id
WHERE tm.team_id = $1
AND tm.id IN (SELECT ta.team_member_id
FROM tasks_assignees ta
LEFT JOIN tasks t
ON t.id = ta.task_id
WHERE ((t.end_date::DATE < NOW()::DATE) OR
((t.total_minutes * 60) <
(SELECT SUM(time_spent)
FROM task_work_log twl
WHERE twl.task_id = t.id
AND tm.user_id = tm.user_id)))
AND t.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS FALSE)))
ORDER BY tmiv.name;`;
const result = await db.query(q, [req.params?.id]);
for (const member of result.rows) {
member.overdue_time = formatDuration(moment.duration(member.overdue_time || "0", "seconds"));
}
return res.status(200).send(new ServerResponse(true, result.rows || []));
}
@HandleExceptions()
public static async getReportingMemberStats(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { includeArchived } = req.query;
const q = `SELECT get_reporting_members_stats($1, $2, $3) AS stats;`;
const result = await db.query(q, [req.params.id, includeArchived, req.user?.id]);
const [data] = result.rows;
const { total_estimated, total_logged } = data.stats;
data.stats.progress = data.stats.total_tasks > 0
? ((data.stats.total_tasks_completed / data.stats.total_tasks) * 100).toFixed(0) : 0;
data.stats.log_progress = data.stats.total_tasks > 0
? ((data.stats.overdue_tasks / data.stats.total_tasks) * 100).toFixed(0) : 0;
const totalMinutes = moment.duration(total_estimated, "seconds");
const totalSeconds = moment.duration(total_logged, "seconds");
data.stats.total_estimated_hours_string = formatDuration(totalMinutes);
data.stats.total_logged_hours_string = formatDuration(totalSeconds);
data.stats.overlogged_hours = formatDuration(totalMinutes.subtract(totalSeconds));
return res.status(200).send(new ServerResponse(true, data.stats || {}));
}
@HandleExceptions()
public static async getReportingMemberOverview(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { includeArchived } = req.query;
// recently logged
const logged_q = `SELECT get_reporting_member_recently_logged_tasks($1, $2, $3) AS recently_logged_tasks;`;
const loggedResult = await db.query(logged_q, [req.params.id, req.user?.id, includeArchived]);
const [loggedData] = loggedResult.rows;
// currently doing tasks
const current_q = `SELECT get_reporting_member_current_doing_tasks($1, $2, $3, $4, $5) AS current_tasks;`;
const currentResult = await db.query(current_q, [req.params.id, req.user?.id, includeArchived, 10, 0]);
const [currentData] = currentResult.rows;
// overdue tasks
const overdue_q = `SELECT get_reporting_member_current_doing_tasks($1, $2, $3, $4, $5) AS overdue_tasks;`;
const overdueResult = await db.query(overdue_q, [req.params.id, req.user?.id, includeArchived, 10, 0]);
const [overdueData] = overdueResult.rows;
for (const task of loggedData.recently_logged_tasks) {
task.logged_time = formatDuration(moment.duration(task.logged_time, "seconds"));
task.status_color = task.status_color + TASK_STATUS_COLOR_ALPHA;
}
for (const task of currentData.current_tasks.data) {
task.status_color = task.status_color + TASK_STATUS_COLOR_ALPHA;
}
for (const task of overdueData.overdue_tasks.data) {
task.status_color = task.status_color + TASK_STATUS_COLOR_ALPHA;
task.overdue = task.end_date ? moment(task.end_date).from(moment()) : "-";
}
return res.status(200).send(new ServerResponse(true,
{
logged_tasks: loggedData.recently_logged_tasks,
current_tasks: currentData.current_tasks.data,
overdue_tasks: overdueData.overdue_tasks.data
}));
}
@HandleExceptions()
public static async getMemberProjects(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { memberId, teamId } = req.query;
if (!teamId || !memberId) return res.status(200).send(new ServerResponse(true, []));
const q = `SELECT p.id,
p.name,
(SELECT name FROM teams WHERE teams.id = p.team_id) AS team,
(SELECT COUNT(*)
FROM tasks_assignees ta
LEFT JOIN tasks t ON ta.task_id = t.id
WHERE ta.team_member_id = pm.team_member_id
AND t.project_id = p.id)::INT AS assigned_task_count,
(SELECT COUNT(*) FROM tasks WHERE tasks.project_id = pm.project_id)::INT AS total_task_count,
(SELECT COUNT(*)
FROM tasks
LEFT JOIN tasks_assignees ta ON tasks.id = ta.task_id
WHERE tasks.project_id = pm.project_id
AND ta.team_member_id = pm.team_member_id
AND tasks.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS TRUE)))::INT AS completed_tasks,
(SELECT COUNT(*)
FROM tasks
LEFT JOIN tasks_assignees ta ON tasks.id = ta.task_id
WHERE tasks.project_id = pm.project_id
AND ta.team_member_id = pm.team_member_id
AND tasks.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS FALSE)))::INT AS incompleted_tasks,
(SELECT COUNT(*)
FROM tasks
LEFT JOIN tasks_assignees ta ON tasks.id = ta.task_id
WHERE tasks.project_id = pm.project_id
AND ta.team_member_id = pm.team_member_id
AND tasks.end_date::DATE < NOW()::DATE
AND tasks.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS FALSE)))::INT AS overdue_tasks
FROM projects p
LEFT JOIN project_members pm ON p.id = pm.project_id
WHERE pm.team_member_id = (SELECT id
FROM team_members
WHERE team_members.team_id = $1
AND user_id = (SELECT user_id FROM team_members WHERE team_members.id = $2));`;
const result = await db.query(q, [teamId, memberId]);
for (const project of result.rows) {
project.contribution = ((project.assigned_task_count / project.total_task_count) * 100).toFixed(1);
}
return res.status(200).send(new ServerResponse(true, result.rows || []));
}
@HandleExceptions()
public static async getTasksByProject(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { memberId, projectId } = req.query;
if (!projectId || !memberId) return res.status(200).send(new ServerResponse(true, []));
const q = `SELECT name,
(SELECT name
FROM task_statuses
WHERE id = t.status_id) AS status,
(SELECT color_code
FROM sys_task_status_categories
WHERE id =
(SELECT category_id FROM task_statuses WHERE id = t.status_id)) AS status_color,
end_date AS due_date,
completed_at AS completed_date,
(total_minutes * 60)::INT AS toal_estimated,
(SELECT SUM(time_spent)
FROM task_work_log
WHERE task_work_log.task_id = t.id)::INT AS total_logged,
(t.end_date::DATE < NOW()::DATE AND t.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS FALSE))) AS is_overdue
FROM tasks t
LEFT JOIN tasks_assignees ta
ON t.id = ta.task_id
WHERE ta.team_member_id = $1
AND t.project_id = $2
ORDER BY name;`;
const result = await db.query(q, [memberId, projectId]);
for (const task of result.rows) {
task.overlogged_time = (task.toal_estimated && task.total_logged && task.toal_estimated < task.total_logged) ? formatDuration(moment.duration((task.toal_estimated - task.total_logged), "seconds")) : "-";
task.toal_estimated = formatDuration(moment.duration(task.toal_estimated, "seconds"));
task.total_logged = formatDuration(moment.duration(task.total_logged, "seconds"));
task.status_color = task.status_color + TASK_STATUS_COLOR_ALPHA;
}
return res.status(200).send(new ServerResponse(true, result.rows || []));
}
@HandleExceptions()
public static async getReportingMembersTasks(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { memberId, teamId } = req.query;
if (!teamId || !memberId) return res.status(200).send(new ServerResponse(true, []));
const overloggedQ = `SELECT t.id,
t.name,
(SELECT name
FROM task_statuses
WHERE id = t.status_id) AS status,
(SELECT color_code
FROM sys_task_status_categories
WHERE id =
(SELECT category_id FROM task_statuses WHERE id = t.status_id)) AS status_color,
(SELECT ABS((total_minutes * 60) -
(SELECT SUM(time_spent) FROM task_work_log WHERE task_id = t.id))) AS overlogged_time,
(SELECT get_task_assignees(t.id)) AS assignees
FROM tasks t
LEFT JOIN projects p ON t.project_id = p.id
LEFT JOIN tasks_assignees ta ON t.id = ta.task_id
WHERE p.team_id = $1
AND ta.team_member_id = $2
AND ((total_minutes * 60) < (SELECT SUM(time_spent) FROM task_work_log WHERE task_id = t.id))
ORDER BY name
LIMIT 10;`;
const earlyQ = `SELECT t.id,
t.name,
(SELECT name
FROM task_statuses
WHERE id = t.status_id) AS status,
completed_at AS completed_at,
t.end_date,
(SELECT color_code
FROM sys_task_status_categories
WHERE id =
(SELECT category_id FROM task_statuses WHERE id = t.status_id)) AS status_color
FROM tasks t
LEFT JOIN projects p ON t.project_id = p.id
LEFT JOIN tasks_assignees ta ON t.id = ta.task_id
WHERE p.team_id = $1
AND ta.team_member_id = $2
AND t.end_date::DATE > completed_at::DATE
AND t.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS TRUE))
ORDER BY name
LIMIT 10;`;
const lateQ = `SELECT t.id,
t.name,
(SELECT name
FROM task_statuses
WHERE id = t.status_id) AS status,
completed_at AS completed_at,
t.end_date,
(SELECT color_code
FROM sys_task_status_categories
WHERE id =
(SELECT category_id FROM task_statuses WHERE id = t.status_id)) AS status_color
FROM tasks t
LEFT JOIN projects p ON t.project_id = p.id
LEFT JOIN tasks_assignees ta ON t.id = ta.task_id
WHERE p.team_id = $1
AND ta.team_member_id = $2
AND t.end_date::DATE < completed_at::DATE
AND t.status_id IN
(SELECT id
FROM task_statuses
WHERE category_id IN
(SELECT id FROM sys_task_status_categories WHERE is_done IS TRUE))
ORDER BY name
LIMIT 10;`;
const overloggedResult = await db.query(overloggedQ, [teamId, memberId]);
const earlyResult = await db.query(earlyQ, [teamId, memberId]);
const lateResult = await db.query(lateQ, [teamId, memberId]);
for (const task of overloggedResult.rows) {
task.overlogged_time = formatDuration(moment.duration((task.overlogged_time), "seconds"));
task.status_color = task.status_color + TASK_STATUS_COLOR_ALPHA;
task.assignees?.forEach((a: any) => a.color_code = getColor(a.name));
task.names = this.createTagList(task.assignees);
}
for (const task of earlyResult.rows) {
task.status_color = task.status_color + TASK_STATUS_COLOR_ALPHA;
}
for (const task of lateResult.rows) {
task.status_color = task.status_color + TASK_STATUS_COLOR_ALPHA;
}
return res.status(200).send(new ServerResponse(true, {
overloggedTasks: overloggedResult.rows,
earlyTasks: earlyResult.rows,
lateTasks: lateResult.rows
}));
}
@HandleExceptions()
public static async getProjectsByTeamId(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const q = `SELECT id, name, FALSE AS selected
FROM projects
WHERE team_id = $1
ORDER BY name;`;
const result = await db.query(q, [req.params.id]);
result.rows.forEach((team: any) => team.selected = true);
return res.status(200).send(new ServerResponse(true, result.rows));
}
public static async getTeamMemberInsightData(team_id: string | undefined, projects: string, status: string, search: string, duration: string, userId: string | undefined) {
const searchQuery = search ? `AND TO_TSVECTOR(tmiv.name || ' ' || tmiv.email || ' ' || u.name) @@ TO_TSQUERY('${search}:*')` : "";
const q = `SELECT ROW_TO_JSON(rec) AS team_members
FROM (SELECT COUNT(*) AS total,
(SELECT COALESCE(ARRAY_TO_JSON(ARRAY_AGG(ROW_TO_JSON(t))), '[]'::JSON)
FROM (SELECT team_members.id,
(SELECT name
FROM team_member_info_view
WHERE team_member_info_view.team_member_id = team_members.id),
u.avatar_url,
(u.socket_id IS NOT NULL) AS is_online,
(SELECT COUNT(DISTINCT project_id)
FROM tasks
WHERE id IN (SELECT task_id
FROM task_work_log
WHERE ${duration}
AND task_work_log.user_id = tmiv.user_id
AND task_id IN (SELECT id
FROM tasks
WHERE project_id IN (${projects})
AND project_id IN (SELECT id
FROM projects
WHERE team_id = $1)))) AS projects_count,
(SELECT COUNT(DISTINCT task_id)
FROM task_work_log
WHERE ${duration}
AND task_work_log.user_id = tmiv.user_id
AND task_id IN (SELECT id
FROM tasks
WHERE project_id IN (${projects})
AND project_id IN (SELECT id
FROM projects
WHERE team_id = $1))) AS task_count,
(SELECT SUM(time_spent)
FROM task_work_log
WHERE ${duration}
AND task_work_log.user_id = tmiv.user_id
AND task_id IN (SELECT id
FROM tasks
WHERE project_id IN (${projects})
AND project_id IN (SELECT id
FROM projects
WHERE team_id = $1))) AS total_logged_time_seconds,
(SELECT name FROM job_titles WHERE id = team_members.job_title_id) AS job_title,
(SELECT name FROM roles WHERE id = team_members.role_id) AS role_name,
EXISTS(SELECT id
FROM roles
WHERE id = team_members.role_id
AND admin_role IS TRUE) AS is_admin,
(CASE
WHEN team_members.user_id =
(SELECT user_id FROM teams WHERE id = $1)
THEN TRUE
ELSE FALSE END) AS is_owner,
(SELECT email
FROM team_member_info_view
WHERE team_member_info_view.team_member_id = team_members.id),
EXISTS(SELECT email
FROM email_invitations
WHERE team_member_id = team_members.id
AND email_invitations.team_id = team_members.team_id) AS pending_invitation,
(SELECT (ARRAY(SELECT NAME
FROM teams
WHERE id IN (SELECT team_id
FROM team_members
WHERE team_members.user_id = tmiv.user_id)
AND id IN (SELECT team_id
FROM team_members
WHERE user_id = $2
AND role_id IN (SELECT id
FROM roles
WHERE (admin_role IS TRUE OR owner IS TRUE)))))) AS member_teams
FROM team_members
LEFT JOIN users u ON team_members.user_id = u.id
LEFT JOIN team_member_info_view tmiv ON team_members.id = tmiv.team_member_id
WHERE team_members.team_id = $1
${searchQuery}
AND team_members.id IN
(SELECT team_member_id FROM project_members WHERE project_id IN (${projects}))
AND team_members.id IN (SELECT team_member_id
FROM project_members
WHERE project_id IN (SELECT id
FROM projects
WHERE projects.team_id = $1
AND status_id IN (${status})))
AND EXISTS(SELECT id
FROM task_work_log
WHERE ${duration}
AND task_work_log.user_id = u.id
AND EXISTS(SELECT 1
FROM tasks
WHERE task_id = tasks.id
AND tasks.project_id IN (${projects})
AND tasks.project_id IN (SELECT id
FROM projects
WHERE projects.team_id = $1
AND status_id IN
(${status}))))
ORDER BY tmiv.name, tmiv.email, u.name ASC) t) AS team_members
FROM team_members
LEFT JOIN users u ON team_members.user_id = u.id
LEFT JOIN team_member_info_view tmiv ON team_members.id = tmiv.team_member_id
WHERE team_members.team_id = $1
${searchQuery}
AND team_members.id IN
(SELECT team_member_id FROM project_members WHERE project_id IN (${projects}))
AND team_members.id IN (SELECT team_member_id
FROM project_members
WHERE project_id IN (SELECT id
FROM projects
WHERE projects.team_id = $1
AND status_id IN (${status})))
AND EXISTS(SELECT id
FROM task_work_log
WHERE ${duration}
AND task_work_log.user_id = u.id
AND EXISTS(SELECT 1
FROM tasks
WHERE task_id = tasks.id
AND tasks.project_id IN (${projects})
AND tasks.project_id IN (SELECT id
FROM projects
WHERE projects.team_id = $1
AND status_id IN
(${status}))))) rec;`;
const result = await db.query(q, [team_id, userId]);
const [data] = result.rows;
return data.team_members;
}
@HandleExceptions()
public static async getReportingMembers(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { search, dateRange, projects, status, duration, teamId } = req.body;
if (!projects.length || !status.length || !duration || !teamId) {
return res.status(200).send(new ServerResponse(true, { total: 0, data: [] }));
}
const projectIds = projects.map((p: any) => `'${p}'`).join(",");
const statusIds = status.map((u: any) => `'${u}'`).join(",");
const dateRangeClause = ReportingController.getDateRangeClause(duration || LAST_WEEK, dateRange);
const result = await this.getTeamMemberInsightData(teamId, projectIds, statusIds, search, dateRangeClause || "", req.user?.id);
result.team_members.map((a: any) => {
a.color_code = getColor(a.name);
a.total_logged_time = formatDuration(moment.duration(a.total_logged_time_seconds || "0", "seconds"));
});
result.data = result.team_members;
delete result.team_members;
return res.status(200).send(new ServerResponse(true, result));
}
public static async getProjectsOfMember(projectIds: string, statusIds: string, dateRangeClause: string | null, memberId: string) {
const q = `SELECT p.name,
COUNT(*) AS logged_task_count,
SUM(time_spent) AS total_logged_time,
p.id,
color_code,
(SELECT name FROM teams WHERE teams.id = p.team_id) AS team
FROM task_work_log
LEFT JOIN tasks t ON task_work_log.task_id = t.id
LEFT JOIN projects p ON t.project_id = p.id
WHERE task_work_log.user_id = (SELECT user_id
FROM team_members
WHERE id = $1
AND team_members.team_id = p.team_id)
AND p.id IN (${projectIds})
AND p.status_id IN (${statusIds})
AND ${dateRangeClause}
GROUP BY p.id;`;
const result = await db.query(q, [memberId,]);
result.rows.forEach((element: { total_logged_time: string; }) => {
element.total_logged_time = formatDuration(moment.duration(element.total_logged_time || "0", "seconds"));
});
return result.rows;
}
@HandleExceptions()
public static async getProjectsByMember(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const { dateRange, projects, status, duration, memberId } = req.body;
const projectIds = projects.map((p: any) => `'${p}'`).join(",");
const statusIds = status.map((u: any) => `'${u}'`).join(",");
const dateRangeClause = ReportingController.getDateRangeClause(duration || LAST_WEEK, dateRange);
const data = await this.getProjectsOfMember(projectIds, statusIds, dateRangeClause, memberId);
return res.status(200).send(new ServerResponse(true, data));
}
@HandleExceptions()
public static async exportMembers(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<void> {
const { duration, team, start, end } = req.query;
const { searchQuery } = this.toPaginationOptions(req.query, "name");
const projects = (req.query.projects as string)?.split(",");
const status = (req.query.status as string)?.split(",");
const projectIds = projects.map((p: any) => `'${p}'`).join(",");
const statusIds = status.map((u: any) => `'${u}'`).join(",");
const dateRange: string[] = [];
if (start && end) {
dateRange.push(start as string, end as string);
}
const dateRangeClause = ReportingController.getDateRangeClause(duration as string || LAST_WEEK, dateRange);
const data = await this.getTeamMemberInsightData(team as string, projectIds, statusIds, searchQuery, dateRangeClause || "", req.user?.id);
for (const teamMember of data.team_members) {
teamMember.color_code = getColor(teamMember.name);
teamMember.total_logged_time = formatDuration(moment.duration(teamMember.total_logged_time_seconds || "0", "seconds"));
teamMember.projects = await this.getProjectsOfMember(projectIds, statusIds, dateRangeClause, teamMember.id);
}
const exportDate = moment().format("MMM-DD-YYYY");
const fileName = `Team Member Reporting - ${exportDate} `;
const workbook = new Excel.Workbook();
for (const item of data.team_members) {
const sheet = workbook.addWorksheet(item.name.replace(/[&\/\\#,+()$~%.'":*?<>{}]/g, "_"));
sheet.columns = [
{ header: "Project", key: "project", width: 30 },
{ header: "Team", key: "team", width: 20 },
{ header: "Logged Task Count", key: "task_count", width: 20 },
{ header: "Total Logged Time", key: "logged_time", width: 20 },
];
sheet.getCell("A1").value = `Team Member : ${item.name}`;
sheet.mergeCells("A1:D1");
sheet.getCell("A1").alignment = { horizontal: "center" };
sheet.getCell("A1").style.fill = {
type: "pattern",
pattern: "solid",
fgColor: { argb: "D9D9D9" }
};
sheet.getCell("A1").font = {
size: 16
};
sheet.getCell("A2").value = `Exported on : ${exportDate}`;
sheet.mergeCells("A2:D2");
sheet.getCell("A2").alignment = { horizontal: "center" };
sheet.getCell("A2").style.fill = {
type: "pattern",
pattern: "solid",
fgColor: { argb: "F2F2F2" }
};
sheet.getCell("A2").font = {
size: 12
};
const start = dateRange[0] ? moment(dateRange[0]).format("YYYY-MM-DD") : "-";
const end = dateRange[1] ? moment(dateRange[1]).format("YYYY-MM-DD") : "-";
sheet.getCell("A3").value = `From : ${start} To : ${end}`;
sheet.mergeCells("A3:D3");
sheet.getRow(4).values = [
"Project",
"Team",
"Logged Task Count",
"Total Logged Time"
];
sheet.getRow(4).font = {
bold: true
};
for (const project of item.projects) {
sheet.addRow({
project: project.name,
team: project.team,
task_count: project.logged_task_count,
logged_time: project.total_logged_time
});
}
}
res.setHeader("Content-Type", "application/vnd.openxmlformats");
res.setHeader("Content-Disposition", `attachment; filename=${fileName}.xlsx`);
await workbook.xlsx.write(res)
.then(() => {
res.end();
});
}
@HandleExceptions()
public static async getHoursLoggedForProject(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
const q = `SELECT twl.user_id,
(SELECT SUM(time_spent)) AS logged_time,
(SELECT name FROM users WHERE id = twl.user_id)
FROM task_work_log twl
LEFT JOIN tasks t ON twl.task_id = t.id
LEFT JOIN projects p ON t.project_id = p.id
WHERE p.id = $1
GROUP BY twl.user_id;`;
const result = await db.query(q, [req.params?.id]);
const obj: string[] = [];
const names: string[] = [];
for (const member of result.rows) {
const memberLog: any = [];
memberLog.push(member.name, member.logged_time ? parseFloat(moment.duration(member.logged_time, "seconds").asHours().toFixed(2)) : 0);
names.push(member.name);
obj.push(memberLog);
}
return res.status(200).send(new ServerResponse(true, { names, data: obj }));
}
}
Reference in New Issue View Git Blame Copy Permalink