From b85c8b0bc891289ac7580cde63a264ddd7bb44ae Mon Sep 17 00:00:00 2001 From: "Mac\\David" Date: Sat, 1 Jun 2024 18:57:45 +0800 Subject: [PATCH] update api --- .../modules/data/service/DashboardService.kt | 460 ++++++++++++++++++ .../modules/data/web/DashboardController.kt | 145 ++++++ 2 files changed, 605 insertions(+) diff --git a/src/main/java/com/ffii/tsms/modules/data/service/DashboardService.kt b/src/main/java/com/ffii/tsms/modules/data/service/DashboardService.kt index 91a963c..cddded1 100644 --- a/src/main/java/com/ffii/tsms/modules/data/service/DashboardService.kt +++ b/src/main/java/com/ffii/tsms/modules/data/service/DashboardService.kt @@ -1091,6 +1091,466 @@ open class DashboardService( + " ORDER BY ds.month" ) + return jdbcDao.queryForList(sql.toString(), args) + } + fun monthlyPlannedTeamTotalManhoursSpent(args: Map): List> { + val sql = StringBuilder( + "SELECT" + + " p.id as projectId," + + " p.name as projectName," + + " date_format(p.planStart, '%Y-%m') as planStart," + + " date_format(p.planEnd, '%Y-%m') as planEnd," + + " PERIOD_DIFF(DATE_FORMAT(:enddate, '%Y%m'),DATE_FORMAT(:startdate, '%Y%m'))+1 as searchDuration," + + " CASE" + + " when p.planStart < :startdate then 0" + + " when p.planStart >= :startdate then PERIOD_DIFF(DATE_FORMAT(p.planStart, '%Y%m'),DATE_FORMAT(:startdate, '%Y%m'))" + + " else 0" + + " END as startCount," + + " CASE" + + " when p.planEnd >= :enddate then PERIOD_DIFF(DATE_FORMAT(:enddate, '%Y%m'),DATE_FORMAT(:startdate, '%Y%m'))" + + " when p.planEnd < :enddate and p.planEnd > :startdate then PERIOD_DIFF(DATE_FORMAT(p.planEnd, '%Y%m'),DATE_FORMAT(:startdate, '%Y%m'))" + + " else 0" + + " END as endCount," + + " PERIOD_DIFF(DATE_FORMAT(p.planEnd, '%Y%m'), DATE_FORMAT(p.planStart, '%Y%m'))+1 as projectDuration," + + " ROUND(p.totalManhour / (PERIOD_DIFF(DATE_FORMAT(p.planEnd, '%Y%m'), DATE_FORMAT(p.planStart, '%Y%m'))+1), 2) AS 'AverageManhours'," + + " p.teamLead," + + " p.totalManhour" + + " FROM project p" + + " left join team t on p.teamLead = t.teamLead" + + " WHERE p.status = 'On-going'" + + " and t.id = :teamId" + + " and p.planEnd > :startdate" + + " and p.planStart < :enddate" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun weeklyActualTeamTotalManhoursSpent(args: Map): List> { + val sql = StringBuilder( + "WITH RECURSIVE date_series AS (" + + " SELECT DATE_FORMAT(:startdate, '%Y-%m-%d') AS day" + + " UNION ALL" + + " SELECT DATE_FORMAT(DATE_ADD(day, INTERVAL 1 DAY), '%Y-%m-%d')" + + " FROM date_series" + + " WHERE day < DATE_FORMAT(DATE_ADD(:startdate, INTERVAL 6 DAY), '%Y-%m-%d')" + + " )" + + " SELECT" + + " ds.day AS yearMonth," + + " IFNULL(SUM(IFNULL(ts.normalConsumed, 0) + IFNULL(ts.otConsumed, 0)), 0) AS 'TotalManhourConsumed'," + + " :teamId AS teamId" + + " FROM date_series ds" + + " LEFT JOIN staff st" + + " on st.teamId = :teamId" + + " LEFT JOIN timesheet ts" + + " ON DATE_FORMAT(ts.recordDate, '%m-%d') = DATE_FORMAT(ds.day, '%m-%d') and ts.staffID = st.id" + + " WHERE ds.day BETWEEN DATE_FORMAT(:startdate, '%Y-%m-%d') AND DATE_FORMAT(DATE_ADD(:startdate, INTERVAL 6 DAY), '%Y-%m-%d')" + + " GROUP BY ds.day, st.teamId" + + " ORDER BY ds.day" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun weeklyPlannedTeamTotalManhoursSpent(args: Map): List> { + val sql = StringBuilder( + "SELECT" + + " p.id as projectId," + + " p.name as projectName," + + " date_format(p.planStart, '%Y-%m-%d') as planStart," + + " date_format(p.planEnd, '%Y-%m-%d') as planEnd," + + " DATEDIFF(DATE_FORMAT(DATE_ADD(:startdate, INTERVAL 6 DAY), '%Y%m%d'),DATE_FORMAT(:startdate, '%Y%m%d'))+1 as searchDuration," + + " CASE" + + " when p.planStart < :startdate then 0" + + " when p.planStart >= :startdate then DATEDIFF(DATE_FORMAT(p.planStart, '%Y%m%d'),DATE_FORMAT(:startdate, '%Y%m%d'))" + + " else 0" + + " END as startCount," + + " CASE" + + " when p.planEnd >= DATE_ADD(:startdate, INTERVAL 6 DAY) then DATEDIFF(DATE_FORMAT(DATE_ADD(:startdate, INTERVAL 6 DAY), '%Y%m%d'),DATE_FORMAT(:startdate, '%Y%m%d'))" + + " when p.planEnd < DATE_ADD(:startdate, INTERVAL 6 DAY) and p.planEnd > :startdate then DATEDIFF(DATE_FORMAT(p.planEnd, '%Y%m%d'),DATE_FORMAT(:startdate, '%Y%m%d'))" + + " else 0" + + " END as endCount," + + " DATEDIFF(DATE_FORMAT(p.planEnd, '%Y%m%d'), DATE_FORMAT(p.planStart, '%Y%m%d'))+1 as projectDuration," + + " ROUND(p.totalManhour / (DATEDIFF(DATE_FORMAT(p.planEnd, '%Y%m%d'), DATE_FORMAT(p.planStart, '%Y%m%d'))+1), 2) AS 'AverageManhours'," + + " p.teamLead," + + " p.totalManhour" + + " FROM project p" + + " left join team t on p.teamLead = t.teamLead" + + " WHERE p.status = 'On-going'" + + " and t.id = :teamId" + + " and p.planEnd > :startdate" + + " and p.planStart < DATE_ADD(:startdate, INTERVAL 6 DAY)" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun weeklyUnsubmittedTimeSheet(args: Map): List> { + val sql = StringBuilder( + "SELECT" + + " st.id, st.name, st.teamId, count(dates.missing_date) as 'UnsubmittedCount'" + + " FROM" + + " tsmsdb.staff st" + + " CROSS JOIN" + + " (" + + " SELECT" + + " DATE(:startdate + INTERVAL numbers.num DAY) AS missing_date" + + " FROM" + + " (" + + " SELECT 0 AS num UNION ALL" + + " SELECT 1 AS num UNION ALL" + + " SELECT 2 AS num UNION ALL" + + " SELECT 3 AS num UNION ALL" + + " SELECT 4 AS num UNION ALL" + + " SELECT 5 as num" + + " ) numbers" + + " WHERE" + + " DATE(:startdate + INTERVAL numbers.num DAY) BETWEEN :startdate AND DATE_ADD(:startdate, INTERVAL 6 DAY)" + + " AND DAYOFWEEK(DATE(:startdate + INTERVAL numbers.num DAY)) BETWEEN 2 AND 6" + + " AND DATE(:startdate + INTERVAL numbers.num DAY) not in (select ch.date from company_holiday ch where ch.deleted = 0)" + + " AND DATE(:startdate + INTERVAL numbers.num DAY) not in (:publicHolidayList)" + + " ) dates" + + " LEFT JOIN" + + " (" + + " SELECT" + + " staffId, recordDate" + + " FROM" + + " tsmsdb.timesheet" + + " WHERE" + + " recordDate BETWEEN :startdate AND DATE_ADD(:startdate, INTERVAL 6 DAY)" + + " ) ts" + + " ON st.id = ts.staffId" + + " AND dates.missing_date = ts.recordDate" + + " WHERE" + + " st.teamId = :teamId" + + " AND ts.recordDate IS NULL" + + " GROUP BY st.id, st.name" + + " ORDER BY" + + " st.id" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun monthlyUnsubmittedTimeSheet(args: Map): List> { + val sql = StringBuilder( + "SELECT" + + " st.id," + + " st.name," + + " st.teamId," + + " :startdate AS 'month'," + + " COUNT(dates.missing_date) AS 'UnsubmittedCount'" + + " FROM" + + " tsmsdb.staff st" + + " CROSS JOIN" + + " (" + + " SELECT" + + " DATE(:startdate + INTERVAL numbers.num DAY) AS missing_date" + + " FROM" + + " (" + + " SELECT 0 AS num UNION ALL" + + " SELECT 1 AS num UNION ALL" + + " SELECT 2 AS num UNION ALL" + + " SELECT 3 AS num UNION ALL" + + " SELECT 4 AS num UNION ALL" + + " SELECT 5 as num UNION ALL" + + " SELECT 6 as num UNION ALL" + + " SELECT 7 as num UNION ALL" + + " SELECT 8 as num UNION ALL" + + " SELECT 9 as num UNION ALL" + + " SELECT 10 as num UNION ALL" + + " SELECT 11 as num UNION ALL" + + " SELECT 12 as num UNION ALL" + + " SELECT 13 as num UNION ALL" + + " SELECT 14 as num UNION ALL" + + " SELECT 15 as num UNION ALL" + + " SELECT 16 as num UNION ALL" + + " SELECT 17 as num UNION ALL" + + " SELECT 18 as num UNION ALL" + + " SELECT 19 as num UNION ALL" + + " SELECT 20 as num UNION ALL" + + " SELECT 21 as num UNION ALL" + + " SELECT 22 as num UNION ALL" + + " SELECT 23 as num UNION ALL" + + " SELECT 24 as num UNION ALL" + + " SELECT 25 as num UNION ALL" + + " SELECT 26 as num UNION ALL" + + " SELECT 27 as num UNION ALL" + + " SELECT 28 as num UNION ALL" + + " SELECT 29 as num UNION ALL" + + " SELECT 30 as num UNION ALL" + + " SELECT 31 as num" + + " ) numbers" + + " WHERE" + + " DATE(:startdate + INTERVAL numbers.num DAY) BETWEEN" + + " :startdate AND" + + " LAST_DAY(:startdate)" + + " AND DAYOFWEEK(DATE(:startdate + INTERVAL numbers.num DAY)) BETWEEN 2 AND 6" + + " AND DATE(:startdate + INTERVAL numbers.num DAY) not in (select ch.date from company_holiday ch where ch.deleted = 0)" + + " AND DATE(:startdate + INTERVAL numbers.num DAY) not in (:publicHolidayList)" + + " ) dates" + + " LEFT JOIN" + + " (" + + " SELECT" + + " staffId," + + " recordDate" + + " FROM" + + " tsmsdb.timesheet" + + " WHERE" + + " recordDate BETWEEN" + + " :startdate AND" + + " LAST_DAY(:startdate)" + + " ) ts" + + " ON st.id = ts.staffId" + + " AND dates.missing_date = ts.recordDate" + + " WHERE" + + " st.teamId = :teamId" + + " AND ts.recordDate IS NULL" + + " GROUP BY" + + " st.id," + + " st.name" + + " ORDER BY" + + " st.id" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun newMonthlyUnsubmittedTimeSheet(args: Map): List> { + val sql = StringBuilder( + "WITH RECURSIVE numbers AS (" + + " SELECT 0 AS num" + + " UNION ALL" + + " SELECT num + 1" + + " FROM numbers" + + " WHERE num < DATEDIFF(:enddate, :startdate)" + + " )" + + " SELECT" + + " st.id," + + " st.name," + + " st.teamId," + + " :startdate AS 'month'," + + " COUNT(dates.missing_date) AS 'UnsubmittedCount'" + + " FROM" + + " tsmsdb.staff st" + + " CROSS JOIN" + + " (" + + " SELECT" + + " DATE(:startdate + INTERVAL numbers.num DAY) AS missing_date" + + " FROM" + + " numbers" + + " WHERE" + + " DATE(:startdate + INTERVAL numbers.num DAY) BETWEEN :startdate AND :enddate" + + " AND DAYOFWEEK(DATE(:startdate + INTERVAL numbers.num DAY)) BETWEEN 2 AND 6" + + " AND DATE(:startdate + INTERVAL numbers.num DAY) NOT IN (" + + " SELECT ch.date FROM company_holiday ch WHERE ch.deleted = 0" + + " )" + + " AND DATE(:startdate + INTERVAL numbers.num DAY) NOT IN (:publicHolidayList)" + + " ) dates" + + " LEFT JOIN" + + " (" + + " SELECT" + + " staffId," + + " recordDate" + + " FROM" + + " tsmsdb.timesheet" + + " WHERE" + + " recordDate BETWEEN :startdate AND :enddate" + + " ) ts" + + " ON st.id = ts.staffId AND dates.missing_date = ts.recordDate" + + " WHERE" + + " st.teamId = :teamId" + + " AND ts.recordDate IS NULL" + + " GROUP BY" + + " st.id," + + " st.name" + + " ORDER BY" + + " st.id" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun staffGradeTotalManhours(args: Map): List> { + val sql = StringBuilder( + "select" + + " g.id as id," + + " g.name as gradeName," + + " coalesce(records.manhours,0) as manhours" + + " from grade g" + + " left join (" + + " select" + + " g.id as gid," + + " coalesce (sum(t.normalConsumed)+sum(t.otConsumed),0) as manhours" + + " from grade g" + + " left join staff s on g.id = s.gradeId" + + " left join timesheet t on s.id = t.staffId" + + " where g.deleted = 0" + + " and t.recordDate >= :startdate" + + " and t.recordDate < DATE_FORMAT(:enddate, '%Y-%m-%d 23:59:59')" + + " group by g.id" + + " ) as records on records.gid = g.id" + + " group by g.id, g.name,records.manhours" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun staffGradeTotalPlannedManhours(args: Map): List> { + val sql = StringBuilder( + "select" + + " g.id," + + " g.name," + + " p.name as projectName," + + " p.planStart as planStart," + + " p.planEnd as planEnd," + + " DATEDIFF(DATE_FORMAT(:enddate, '%Y%m%d'),DATE_FORMAT(:startdate, '%Y%m%d'))+1 as searchDuration," + + " case" + + " when DATEDIFF(DATE_FORMAT(p.planStart, '%Y%m%d'),DATE_FORMAT(:startdate, '%Y%m%d'))+1 < 0 then 0" + + " else DATEDIFF(DATE_FORMAT(p.planStart, '%Y%m%d'),DATE_FORMAT(:startdate, '%Y%m%d'))+1" + + " end as startDiff," + + " case" + + " when DATEDIFF(DATE_FORMAT(:enddate, '%Y%m%d'),DATE_FORMAT(p.planEnd, '%Y%m%d'))+1 < 0 then 0" + + " else DATEDIFF(DATE_FORMAT(:enddate, '%Y%m%d'),DATE_FORMAT(p.planEnd, '%Y%m%d'))+1" + + " end as endDiff," + + " DATEDIFF(DATE_FORMAT(p.planEnd, '%Y%m%d'), DATE_FORMAT(p.planStart, '%Y%m%d'))+1 as projectDuration," + + " ga.manhour as gradeManhour," + + " (ga.manhour/DATEDIFF(DATE_FORMAT(p.planEnd, '%Y%m%d'), DATE_FORMAT(p.planStart, '%Y%m%d'))+1) as avgGradeManhour" + + " from grade g" + + " left join grade_allocation ga on g.id = ga.gradeId" + + " left join project p on ga.projectId = p.id" + + " where p.status = 'On-going'" + + " and p.planEnd > :startdate" + + " and p.planStart < :enddate" + + " order by g.id" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun IndividualStaffManhoursSpentByMonth(args: Map): List> { + val sql = StringBuilder( + "select" + + " p2.id as id," + + " p2.name as projectName," + + " coalesce (result.manhours,0) as manhours," + + " coalesce (round((result.manhours/ sum(result.manhours))*100,2),0) as percentage" + + " from staff s2" + + " left join staff_allocation sa2 on sa2.staff_id = s2.id" + + " left join project p2 on sa2.project_id = p2.id" + + " left join (" + + " select" + + " p.id as pid," + + " p.name as projectName," + + " coalesce (sum(t.normalConsumed)+sum(t.otConsumed),0) as manhours" + + " from staff s" + + " left join staff_allocation sa on sa.staff_id = s.id" + + " left join project p on sa.project_id = p.id" + + " left join timesheet t on p.id = t.projectId" + + " where s.id = :staffId" + + " and t.recordDate >= :startdate" + + " and t.recordDate <= last_day(:startdate)" + + " group by p.id, p.name" + + " ) as result on result.pid = p2.id" + + " where s2.id = :staffId" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun IndividualStaffManhoursSpentWeekly(args: Map): List> { + val sql = StringBuilder( + "select" + + " p2.id as id," + + " p2.name as projectName," + + " coalesce (result.manhours,0) as manhours," + + " coalesce (round((result.manhours/ sum(result.manhours))*100,2),0) as percentage" + + " from staff s2" + + " left join staff_allocation sa2 on sa2.staff_id = s2.id" + + " left join project p2 on sa2.project_id = p2.id" + + " left join (" + + " select" + + " p.id as pid," + + " p.name as projectName," + + " coalesce (sum(t.normalConsumed)+sum(t.otConsumed),0) as manhours" + + " from staff s" + + " left join staff_allocation sa on sa.staff_id = s.id" + + " left join project p on sa.project_id = p.id" + + " left join timesheet t on p.id = t.projectId" + + " where s.id = :staffId" + + " and t.recordDate >= :startdate" + + " and t.recordDate <= :enddate" + + " group by p.id, p.name" + + " ) as result on result.pid = p2.id" + + " where s2.id = :staffId" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun IndividualStaffManhoursSpentByDay(args: Map): List> { + val sql = StringBuilder( + "select" + + " p2.id as id," + + " p2.name as projectName," + + " coalesce (result.manhours,0) as manhours," + + " coalesce (round((result.manhours/ sum(result.manhours))*100,2),0) as percentage" + + " from staff s2" + + " left join staff_allocation sa2 on sa2.staff_id = s2.id" + + " left join project p2 on sa2.project_id = p2.id" + + " left join (" + + " select" + + " p.id as pid," + + " p.name as projectName," + + " coalesce (sum(t.normalConsumed)+sum(t.otConsumed),0) as manhours" + + " from staff s" + + " left join staff_allocation sa on sa.staff_id = s.id" + + " left join project p on sa.project_id = p.id" + + " left join timesheet t on p.id = t.projectId" + + " where s.id = :staffId" + + " and t.recordDate >= :startdate" + + " group by p.id, p.name" + + " ) as result on result.pid = p2.id" + + " where s2.id = :staffId" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun IndividualStaffTotalManhoursSpentByDay(args: Map): List> { + val sql = StringBuilder( + "select" + + " coalesce (sum(t.normalConsumed),0) as normalManhours," + + " coalesce (sum(t.otConsumed),0) as otManhours" + + " from staff s" + + " left join staff_allocation sa on sa.staff_id = s.id" + + " left join project p on sa.project_id = p.id" + + " left join timesheet t on p.id = t.projectId" + + " where s.id = :staffId" + + " and t.recordDate = :startdate" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun IndividualStaffTotalManhoursSpentWeekly(args: Map): List> { + val sql = StringBuilder( + "select" + + " coalesce (sum(t.normalConsumed),0) as normalManhours," + + " coalesce (sum(t.otConsumed),0) as otManhours" + + " from staff s" + + " left join staff_allocation sa on sa.staff_id = s.id" + + " left join project p on sa.project_id = p.id" + + " left join timesheet t on p.id = t.projectId" + + " where s.id = :staffId" + + " and t.recordDate >= :startdate" + + " and t.recordDate <= :enddate" + ) + + return jdbcDao.queryForList(sql.toString(), args) + } + fun IndividualStaffTotalManhoursSpentByMonthly(args: Map): List> { + val sql = StringBuilder( + "select" + + " coalesce (sum(t.normalConsumed),0) as normalManhours," + + " coalesce (sum(t.otConsumed),0) as otManhours" + + " from staff s" + + " left join staff_allocation sa on sa.staff_id = s.id" + + " left join project p on sa.project_id = p.id" + + " left join timesheet t on p.id = t.projectId" + + " where s.id = :staffId" + + " and t.recordDate >= :startdate" + + " and t.recordDate <= last_day(:startdate)" + ) + return jdbcDao.queryForList(sql.toString(), args) } } diff --git a/src/main/java/com/ffii/tsms/modules/data/web/DashboardController.kt b/src/main/java/com/ffii/tsms/modules/data/web/DashboardController.kt index 70c2162..601e575 100644 --- a/src/main/java/com/ffii/tsms/modules/data/web/DashboardController.kt +++ b/src/main/java/com/ffii/tsms/modules/data/web/DashboardController.kt @@ -249,7 +249,152 @@ class DashboardController( } val result = mutableMapOf() val monthlyActualTeamTotalManhoursSpent = dashboardService.monthlyActualTeamTotalManhoursSpent(args) + val monthlyPlannedTeamTotalManhoursSpent = dashboardService.monthlyPlannedTeamTotalManhoursSpent(args) result["monthlyActualTeamTotalManhoursSpent"] = monthlyActualTeamTotalManhoursSpent + result["monthlyPlannedTeamTotalManhoursSpent"] = monthlyPlannedTeamTotalManhoursSpent + return listOf(result) + } + @GetMapping("/searchWeeklyActualTeamTotalManhoursSpent") + fun searchWeeklyActualTeamTotalManhoursSpent(request: HttpServletRequest?): List> { + val args = mutableMapOf() + val teamId = request?.getParameter("teamId") + val startdate = request?.getParameter("startdate") + val enddate = request?.getParameter("enddate") + if (teamId != null) { + args["teamId"] = teamId + } + if (startdate != null) { + args["startdate"] = startdate + } + if (enddate != null) { + args["enddate"] = enddate + } + val result = mutableMapOf() + val weeklyActualTeamTotalManhoursSpent = dashboardService.weeklyActualTeamTotalManhoursSpent(args) + val weeklyPlannedTeamTotalManhoursSpent = dashboardService.weeklyPlannedTeamTotalManhoursSpent(args) + result["weeklyActualTeamTotalManhoursSpent"] = weeklyActualTeamTotalManhoursSpent + result["weeklyPlannedTeamTotalManhoursSpent"] = weeklyPlannedTeamTotalManhoursSpent + return listOf(result) + } + @GetMapping("/searchWeeklyUnsubmittedTimeSheet") + fun searchWeeklyUnsubmittedTimeSheet(request: HttpServletRequest?): List> { + val args = mutableMapOf() + val teamId = request?.getParameter("teamId") + val startdate = request?.getParameter("startdate") + val enddate = request?.getParameter("enddate") + val publicHolidayListParam = request?.getParameter("publicHolidayList") + if (teamId != null) { + args["teamId"] = teamId + } + if (startdate != null) { + args["startdate"] = startdate + } + if (enddate != null) { + args["enddate"] = enddate + } + if (publicHolidayListParam != null) { + val publicHolidayList = publicHolidayListParam.split(",").map { it.trim() } + args["publicHolidayList"] = publicHolidayList + } + return dashboardService.weeklyUnsubmittedTimeSheet(args) + } + @GetMapping("/searchMonthlyUnsubmittedTimeSheet") + fun searchMonthlyUnsubmittedTimeSheet(request: HttpServletRequest?): List> { + val args = mutableMapOf() + val teamId = request?.getParameter("teamId") + val startdate = request?.getParameter("startdate") + val enddate = request?.getParameter("enddate") + val publicHolidayListParam = request?.getParameter("publicHolidayList") + if (teamId != null) { + args["teamId"] = teamId + } + if (startdate != null) { + args["startdate"] = startdate + } + if (enddate != null) { + args["enddate"] = enddate + } + if (publicHolidayListParam != null) { + val publicHolidayList = publicHolidayListParam.split(",").map { it.trim() } + args["publicHolidayList"] = publicHolidayList + } + return dashboardService.newMonthlyUnsubmittedTimeSheet(args) + } + @GetMapping("/searchTotalManhoursSpentByStaffGrade") + fun searchTotalManhoursSpentByStaffGrade(request: HttpServletRequest?): List> { + val args = mutableMapOf() + val startdate = request?.getParameter("startdate") + val enddate = request?.getParameter("enddate") + if (startdate != null) { + args["startdate"] = startdate + } + if (enddate != null) { + args["enddate"] = enddate + } + val result = mutableMapOf() + val staffGradeTotalManhours = dashboardService.staffGradeTotalManhours(args) + val staffGradeTotalPlannedManhours = dashboardService.staffGradeTotalPlannedManhours(args) + result["staffGradeTotalManhours"] = staffGradeTotalManhours + result["staffGradeTotalPlannedManhours"] = staffGradeTotalPlannedManhours + return listOf(result) + } + @GetMapping("/searchTotalManhoursSpentByStaffDaily") + fun searchTotalManhoursSpentByStaffDaily(request: HttpServletRequest?): List> { + val args = mutableMapOf() + val staffId = request?.getParameter("staffId") + val startdate = request?.getParameter("startdate") + + if (startdate != null) { + args["startdate"] = startdate + } + if (staffId != null) { + args["staff"] = staffId + } + val result = mutableMapOf() + val individualStaffManhoursSpentByDay = dashboardService.IndividualStaffManhoursSpentByDay(args) + val individualStaffTotalManhoursSpentByDay = dashboardService.IndividualStaffTotalManhoursSpentByDay(args) + result["individualStaffManhoursSpentByDay"] = individualStaffManhoursSpentByDay + result["individualStaffTotalManhoursSpentByDay"] = individualStaffTotalManhoursSpentByDay + return listOf(result) + } + @GetMapping("/searchTotalManhoursSpentByStaffWeekly") + fun searchTotalManhoursSpentByStaffWeekly(request: HttpServletRequest?): List> { + val args = mutableMapOf() + val staffId = request?.getParameter("staffId") + val startdate = request?.getParameter("startdate") + val enddate = request?.getParameter("enddate") + if (startdate != null) { + args["startdate"] = startdate + } + if (enddate != null) { + args["enddate"] = enddate + } + if (staffId != null) { + args["staff"] = staffId + } + val result = mutableMapOf() + val individualStaffManhoursSpentWeekly = dashboardService.IndividualStaffManhoursSpentWeekly(args) + val individualStaffTotalManhoursSpentWeekly = dashboardService.IndividualStaffTotalManhoursSpentWeekly(args) + result["individualStaffManhoursSpentWeekly"] = individualStaffManhoursSpentWeekly + result["individualStaffTotalManhoursSpentWeekly"] = individualStaffTotalManhoursSpentWeekly + return listOf(result) + } + @GetMapping("/searchTotalManhoursSpentByStaffByMonth") + fun searchTotalManhoursSpentByStaffByMonth(request: HttpServletRequest?): List> { + val args = mutableMapOf() + val staffId = request?.getParameter("staffId") + val startdate = request?.getParameter("startdate") + if (startdate != null) { + args["startdate"] = startdate + } + if (staffId != null) { + args["staff"] = staffId + } + val result = mutableMapOf() + val individualStaffManhoursSpentByMonth = dashboardService.IndividualStaffManhoursSpentByMonth(args) + val individualStaffTotalManhoursSpentByMonth = dashboardService.IndividualStaffTotalManhoursSpentByMonthly(args) + result["individualStaffManhoursSpentByMonth"] = individualStaffManhoursSpentByMonth + result["individualStaffTotalManhoursSpentByMonth"] = individualStaffTotalManhoursSpentByMonth return listOf(result) } } \ No newline at end of file