feature/IO-1054-ScoreBoard-WorkingDays - Fix

client/src/components/bill-enter-modal/bill-enter-modal.container.jsx

@@ -25,7 +25,6 @@ import BillFormContainer from "../bill-form/bill-form.container";
 import { CalculateBillTotal } from "../bill-form/bill-form.totals.utility";
 import { handleUpload as handleLocalUpload } from "../documents-local-upload/documents-local-upload.utility";
 import { handleUpload } from "../documents-upload/documents-upload.utility";
-import { handleUpload as handleUploadToImageProxy } from "../documents-upload-imgproxy/documents-upload-imgproxy.utility";
 
 const mapStateToProps = createStructuredSelector({
   billEnterModal: selectBillEnterModal,
@@ -54,10 +53,10 @@ function BillEnterModalContainer({ billEnterModal, toggleModalVisible, bodyshop,
   const notification = useNotification();
 
   const {
-    treatments: { Enhanced_Payroll, Imgproxy }
+    treatments: { Enhanced_Payroll }
   } = useSplitTreatments({
     attributes: {},
-    names: ["Enhanced_Payroll", "Imgproxy"],
+    names: ["Enhanced_Payroll"],
     splitKey: bodyshop.imexshopid
   });
 
@@ -299,39 +298,20 @@ function BillEnterModalContainer({ billEnterModal, toggleModalVisible, bodyshop,
           });
         });
       } else {
-        //Check if using Imgproxy or cloudinary
-
-        if (Imgproxy.treatment === "on") {
-          upload.forEach((u) => {
-            handleUploadToImageProxy(
-              { file: u.originFileObj },
-              {
-                bodyshop: bodyshop,
-                uploaded_by: currentUser.email,
-                jobId: values.jobid,
-                billId: billId,
-                tagsArray: null,
-                callback: null
-              },
-              notification
-            );
-          });
-        } else {
-          upload.forEach((u) => {
-            handleUpload(
-              { file: u.originFileObj },
-              {
-                bodyshop: bodyshop,
-                uploaded_by: currentUser.email,
-                jobId: values.jobid,
-                billId: billId,
-                tagsArray: null,
-                callback: null
-              },
-              notification
-            );
-          });
-        }
+        upload.forEach((u) => {
+          handleUpload(
+            { file: u.originFileObj },
+            {
+              bodyshop: bodyshop,
+              uploaded_by: currentUser.email,
+              jobId: values.jobid,
+              billId: billId,
+              tagsArray: null,
+              callback: null
+            },
+            notification
+          );
+        });
       }
     }
     ///////////////////////////

client/src/components/jobs-documents-imgproxy-gallery/jobs-document-imgproxy-gallery.download.component.jsx

@@ -3,7 +3,6 @@ import axios from "axios";
 import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { logImEXEvent } from "../../firebase/firebase.utils";
-import cleanAxios from "../../utils/CleanAxios";
 import formatBytes from "../../utils/formatbytes";
 import { connect } from "react-redux";
 import { createStructuredSelector } from "reselect";
@@ -12,7 +11,7 @@ import { selectBodyshop } from "../../redux/user/user.selectors";
 const mapStateToProps = createStructuredSelector({
   bodyshop: selectBodyshop
 });
-const mapDispatchToProps = (dispatch) => ({
+const mapDispatchToProps = () => ({
   //setUserLanguage: language => dispatch(setUserLanguage(language))
 });
 
@@ -26,7 +25,7 @@ const mapDispatchToProps = (dispatch) => ({
 
 export default connect(mapStateToProps, mapDispatchToProps)(JobsDocumentsImgproxyDownloadButton);
 
-export function JobsDocumentsImgproxyDownloadButton({ bodyshop, galleryImages, identifier, jobId }) {
+export function JobsDocumentsImgproxyDownloadButton({ galleryImages, identifier, jobId }) {
   const { t } = useTranslation();
   const [download, setDownload] = useState(null);
   const [loading, setLoading] = useState(false);

client/src/components/schedule-calendar-wrapper/schedule-calendar-header.component.jsx

@@ -1,9 +1,9 @@
 import Icon from "@ant-design/icons";
 import { Card, Popover, Space } from "antd";
-import _ from "lodash";
+import { groupBy } from "lodash";
 import dayjs from "../../utils/day";
 
-import React, { useMemo } from "react";
+import { useMemo } from "react";
 import { useTranslation } from "react-i18next";
 import { MdFileDownload, MdFileUpload } from "react-icons/md";
 import { connect } from "react-redux";
@@ -26,21 +26,12 @@ const mapStateToProps = createStructuredSelector({
   calculating: selectScheduleLoadCalculating
 });
 
-const mapDispatchToProps = (dispatch) => ({});
+const mapDispatchToProps = () => ({});
 
-export function ScheduleCalendarHeaderComponent({
-  bodyshop,
-  label,
-  refetch,
-  date,
-  load,
-  calculating,
-  events,
-  ...otherProps
-}) {
+export function ScheduleCalendarHeaderComponent({ bodyshop, label, refetch, date, load, calculating, events }) {
   const ATSToday = useMemo(() => {
     if (!events) return [];
-    return _.groupBy(
+    return groupBy(
       events.filter((e) => !e.vacation && e.isintake && dayjs(date).isSame(dayjs(e.start), "day")),
       "job.alt_transport"
     );
@@ -155,7 +146,11 @@ export function ScheduleCalendarHeaderComponent({
           <Space size="small">
             <Icon component={MdFileDownload} style={{ color: "green" }} />
             <BlurWrapper featureName="smartscheduling">
-              <span>{`${(loadData.allHoursInBody || 0) && loadData.allHoursInBody.toFixed(1)}/${(loadData.allHoursInRefinish || 0) && loadData.allHoursInRefinish.toFixed(1)}/${(loadData.allHoursIn || 0) && loadData.allHoursIn.toFixed(1)}`}</span>
+              <span>
+                {`${(loadData.allHoursInBody || 0) && loadData.allHoursInBody.toFixed(1)}/${
+                  (loadData.allHoursInRefinish || 0) && loadData.allHoursInRefinish.toFixed(1)
+                }/${(loadData.allHoursIn || 0) && loadData.allHoursIn.toFixed(1)}`}
+              </span>
             </BlurWrapper>
           </Space>
         </Popover>

client/src/components/scoreboard-chart/scoreboard-chart.component.jsx

@@ -1,8 +1,7 @@
 import { Card } from "antd";
 import Dinero from "dinero.js";
-import _ from "lodash";
+import { round } from "lodash";
 import dayjs from "../../utils/day";
-import React from "react";
 import { connect } from "react-redux";
 import {
   Area,
@@ -29,7 +28,7 @@ const mapStateToProps = createStructuredSelector({
   bodyshop: selectBodyshop
 });
 
-const mapDispatchToProps = (dispatch) => ({
+const mapDispatchToProps = () => ({
   //setUserLanguage: language => dispatch(setUserLanguage(language))
 });
 export default connect(mapStateToProps, mapDispatchToProps)(ScoreboardChart);
@@ -40,7 +39,7 @@ export function ScoreboardChart({ sbEntriesByDate, bodyshop }) {
   const data = listOfBusDays.reduce((acc, val) => {
     //Sum up the current day.
     let dayhrs;
-    if (!!sbEntriesByDate[val]) {
+    if (sbEntriesByDate[val]) {
       dayhrs = sbEntriesByDate[val].reduce(
         (dayAcc, dayVal) => {
           return {
@@ -61,9 +60,9 @@ export function ScoreboardChart({ sbEntriesByDate, bodyshop }) {
 
     const theValue = {
       date: dayjs(val).format("D ddd"),
-      paintHrs: _.round(dayhrs.painthrs, 1),
-      bodyHrs: _.round(dayhrs.bodyhrs, 1),
-      accTargetHrs: _.round(
+      paintHrs: round(dayhrs.painthrs, 1),
+      bodyHrs: round(dayhrs.bodyhrs, 1),
+      accTargetHrs: round(
         Utils.AsOfDateTargetHours(
           bodyshop.scoreboard_target.dailyBodyTarget + bodyshop.scoreboard_target.dailyPaintTarget,
           val
@@ -72,14 +71,14 @@ export function ScoreboardChart({ sbEntriesByDate, bodyshop }) {
           bodyshop.scoreboard_target.dailyPaintTarget,
         1
       ),
-      accHrs: _.round(
+      accHrs: round(
         acc.length > 0
           ? acc[acc.length - 1].accHrs + dayhrs.painthrs + dayhrs.bodyhrs
           : dayhrs.painthrs + dayhrs.bodyhrs,
         1
       ),
-      sales: _.round(dayhrs.sales, 2),
-      accSales: _.round(acc.length > 0 ? acc[acc.length - 1].accSales + dayhrs.sales : dayhrs.sales, 2)
+      sales: round(dayhrs.sales, 2),
+      accSales: round(acc.length > 0 ? acc[acc.length - 1].accSales + dayhrs.sales : dayhrs.sales, 2)
     };
 
     return [...acc, theValue];

client/src/components/scoreboard-display/scoreboard-display.component.jsx

@@ -1,23 +1,25 @@
-import { Col, Row } from "antd";
-import { useEffect } from "react";
+import { Col, Row, Spin } from "antd";
+import { useEffect, useState } from "react";
 import ScoreboardChart from "../scoreboard-chart/scoreboard-chart.component";
 import ScoreboardLastDays from "../scoreboard-last-days/scoreboard-last-days.component";
 import ScoreboardTargetsTable from "../scoreboard-targets-table/scoreboard-targets-table.component";
-
 import { useApolloClient, useQuery } from "@apollo/client";
 import { connect } from "react-redux";
 import { createStructuredSelector } from "reselect";
 import { GET_BLOCKED_DAYS, QUERY_SCOREBOARD } from "../../graphql/scoreboard.queries";
 import { selectBodyshop } from "../../redux/user/user.selectors";
 import dayjs from "../../utils/day";
+import {
+  clearHolidays,
+  clearWorkingWeekdays,
+  setHolidays,
+  setWorkingWeekdays
+} from "../scoreboard-targets-table/scoreboard-targets-table.util";
 
 const mapStateToProps = createStructuredSelector({
-  //currentUser: selectCurrentUser
   bodyshop: selectBodyshop
 });
-const mapDispatchToProps = (dispatch) => ({
-  //setUserLanguage: language => dispatch(setUserLanguage(language))
-});
+const mapDispatchToProps = () => ({});
 export default connect(mapStateToProps, mapDispatchToProps)(ScoreboardDisplayComponent);
 
 export function ScoreboardDisplayComponent({ bodyshop }) {
@@ -32,7 +34,6 @@ export function ScoreboardDisplayComponent({ bodyshop }) {
   const { data } = scoreboardSubscription;
   const client = useApolloClient();
   const scoreBoardlist = data?.scoreboard || [];
-
   const sbEntriesByDate = {};
 
   scoreBoardlist.forEach((i) => {
@@ -43,35 +44,52 @@ export function ScoreboardDisplayComponent({ bodyshop }) {
     sbEntriesByDate[entryDate].push(i);
   });
 
-  useEffect(() => {
-    //Update the locals.
-    async function setDayJSSettings() {
-      let appointments;
+  const [loading, setLoading] = useState(true); // Loading state
 
-      if (!bodyshop.scoreboard_target.ignoreblockeddays) {
-        const { data } = await client.query({
-          query: GET_BLOCKED_DAYS,
-          variables: {
-            start: dayjs().startOf("month"),
-            end: dayjs().endOf("month")
-          }
-        });
-        appointments = data.appointments;
-      }
-      dayjs.updateLocale(dayjs.locale(), {
-        workingWeekdays: translateSettingsToWorkingDays(bodyshop.workingdays),
-        ...(appointments?.length
-          ? {
-              holidays: appointments.map((h) => dayjs(h.start).format("MM-DD-YYYY"))
+  useEffect(() => {
+    async function setDayJSSettings() {
+      try {
+        let appointments;
+
+        if (!bodyshop.scoreboard_target.ignoreblockeddays) {
+          const { data } = await client.query({
+            query: GET_BLOCKED_DAYS,
+            variables: {
+              start: dayjs().startOf("month"),
+              end: dayjs().endOf("month")
             }
-          : {}),
-        holidayFormat: "MM-DD-YYYY"
-      });
+          });
+          appointments = data.appointments;
+        }
+
+        const holidays = appointments ? appointments.map((h) => dayjs(h.start).format("MM-DD-YYYY")) : [];
+        const workingWeekdays = translateSettingsToWorkingDays(bodyshop.workingdays);
+
+        // Set holidays and working weekdays
+        setHolidays(holidays);
+        setWorkingWeekdays(workingWeekdays);
+      } finally {
+        setLoading(false); // Set loading to false after processing
+      }
     }
 
     setDayJSSettings();
+
+    // Cleanup on unmount
+    return () => {
+      clearHolidays();
+      clearWorkingWeekdays();
+    };
   }, [client, bodyshop]);
 
+  if (loading) {
+    return (
+      <Row justify="center" align="middle" style={{ minHeight: "100vh" }}>
+        <Spin size="large" />
+      </Row>
+    );
+  }
+
   return (
     <Row gutter={[16, 16]}>
       <Col span={24}>
@@ -89,27 +107,12 @@ export function ScoreboardDisplayComponent({ bodyshop }) {
 
 function translateSettingsToWorkingDays(workingdays) {
   const days = [];
-
-  if (workingdays.monday) {
-    days.push(1);
-  }
-  if (workingdays.tuesday) {
-    days.push(2);
-  }
-  if (workingdays.wednesday) {
-    days.push(3);
-  }
-  if (workingdays.thursday) {
-    days.push(4);
-  }
-  if (workingdays.friday) {
-    days.push(5);
-  }
-  if (workingdays.saturday) {
-    days.push(6);
-  }
-  if (workingdays.sunday) {
-    days.push(0);
-  }
+  if (workingdays.monday) days.push(1);
+  if (workingdays.tuesday) days.push(2);
+  if (workingdays.wednesday) days.push(3);
+  if (workingdays.thursday) days.push(4);
+  if (workingdays.friday) days.push(5);
+  if (workingdays.saturday) days.push(6);
+  if (workingdays.sunday) days.push(0);
   return days;
 }

client/src/components/scoreboard-last-days/scoreboard-last-days.component.jsx

@@ -1,4 +1,3 @@
-import React from "react";
 import { connect } from "react-redux";
 import { createStructuredSelector } from "reselect";
 import { selectBodyshop } from "../../redux/user/user.selectors";
@@ -10,7 +9,7 @@ import LoadingSkeleton from "../loading-skeleton/loading-skeleton.component";
 const mapStateToProps = createStructuredSelector({
   bodyshop: selectBodyshop
 });
-const mapDispatchToProps = (dispatch) => ({
+const mapDispatchToProps = () => ({
   //setUserLanguage: language => dispatch(setUserLanguage(language))
 });
 
@@ -26,7 +25,7 @@ export function ScoreboardLastDays({ bodyshop, sbEntriesByDate }) {
     <Row>
       {ArrayOfDate.map((a) => (
         <Col span={2} key={a}>
-          {!!sbEntriesByDate ? <ScoreboardDayStat date={a} entries={sbEntriesByDate[a] || []} /> : <LoadingSkeleton />}
+          {sbEntriesByDate ? <ScoreboardDayStat date={a} entries={sbEntriesByDate[a] || []} /> : <LoadingSkeleton />}
         </Col>
       ))}
     </Row>

client/src/components/scoreboard-targets-table/scoreboard-targets-table.component.jsx

@@ -1,8 +1,8 @@
 import { CalendarOutlined } from "@ant-design/icons";
 import { Card, Col, Divider, Row, Statistic } from "antd";
-import _ from "lodash";
+import { groupBy } from "lodash";
 import dayjs from "../../utils/day";
-import React, { useMemo } from "react";
+import { useMemo } from "react";
 import { useTranslation } from "react-i18next";
 import { connect } from "react-redux";
 import { createStructuredSelector } from "reselect";
@@ -13,7 +13,7 @@ import * as Util from "./scoreboard-targets-table.util";
 const mapStateToProps = createStructuredSelector({
   bodyshop: selectBodyshop
 });
-const mapDispatchToProps = (dispatch) => ({
+const mapDispatchToProps = () => ({
   //setUserLanguage: language => dispatch(setUserLanguage(language))
 });
 
@@ -24,7 +24,7 @@ export function ScoreboardTargetsTable({ bodyshop, scoreBoardlist }) {
   const { t } = useTranslation();
 
   const values = useMemo(() => {
-    const dateHash = _.groupBy(scoreBoardlist, "date");
+    const dateHash = groupBy(scoreBoardlist, "date");
 
     let ret = {
       todayBody: 0,
@@ -213,4 +213,5 @@ export function ScoreboardTargetsTable({ bodyshop, scoreBoardlist }) {
     </Card>
   );
 }
+
 export default connect(mapStateToProps, mapDispatchToProps)(ScoreboardTargetsTable);

client/src/components/scoreboard-targets-table/scoreboard-targets-table.util.js

@@ -1,29 +1,172 @@
 import dayjs from "../../utils/day";
 
-export const CalculateWorkingDaysThisMonth = () => dayjs().endOf("month").businessDaysInMonth().length;
+const DEFAULT_WORKING_DAYS = [1, 2, 3, 4, 5]; // Default to Monday-Friday
 
-export const CalculateWorkingDaysInPeriod = (start, end) => dayjs(end).businessDiff(dayjs(start));
+// Module-level state for holidays and working weekdays
+let holidays = [];
+let workingWeekdays = DEFAULT_WORKING_DAYS;
 
-export const CalculateWorkingDaysAsOfToday = () => dayjs().endOf("day").businessDiff(dayjs().startOf("month"));
+/**
+ * Sets the holidays for the business logic.
+ * @param newHolidays
+ */
+export const setHolidays = (newHolidays = []) => {
+  holidays = newHolidays;
+};
 
-export const CalculateWorkingDaysLastMonth = () =>
-  dayjs().subtract(1, "month").endOf("month").businessDaysInMonth().length;
+/**
+ * Clears the holidays.
+ */
+export const clearHolidays = () => {
+  holidays = [];
+};
 
+/**
+ * Sets the working weekdays for the business logic.
+ * @param newWorkingWeekdays
+ */
+export const setWorkingWeekdays = (newWorkingWeekdays = DEFAULT_WORKING_DAYS) => {
+  workingWeekdays = newWorkingWeekdays;
+};
+
+/**
+ * Clears the working weekdays, resetting to default (Monday-Friday).
+ */
+export const clearWorkingWeekdays = () => {
+  workingWeekdays = DEFAULT_WORKING_DAYS; // Reset to default
+};
+
+/**
+ * Translates the bodyshop working days settings to an array of weekdays.
+ * @returns {*[]}
+ */
+export const getHolidays = () => {
+  return holidays;
+};
+
+/**
+ * Translates the working days settings from the bodyshop to an array of weekdays.
+ * @returns {number[]}
+ */
+export const getWorkingWeekdays = () => {
+  return workingWeekdays;
+};
+
+/**
+ * Calculates the number of working days in the current month, excluding holidays.
+ * @returns {number}
+ * @constructor
+ */
+export const CalculateWorkingDaysThisMonth = () => {
+  const businessDays = dayjs().businessDaysInMonth();
+  return businessDays.filter((day) => !holidays.includes(dayjs(day).format("MM-DD-YYYY"))).length;
+};
+
+/**
+ * Calculates the number of working days in a given period, excluding holidays.
+ * @param start
+ * @param end
+ * @returns {number}
+ * @constructor
+ */
+export const CalculateWorkingDaysInPeriod = (start, end) => {
+  let businessDays = dayjs(end).businessDiff(dayjs(start));
+  if (dayjs(end).isBusinessDay() && !holidays.includes(dayjs(end).format("MM-DD-YYYY"))) {
+    businessDays += 1;
+  }
+  return businessDays;
+};
+
+/**
+ * Calculates the number of working days as of today, excluding holidays.
+ * @returns {number}
+ * @constructor
+ */
+export const CalculateWorkingDaysAsOfToday = () => {
+  const today = dayjs().startOf("day");
+  let businessDays = today.businessDiff(dayjs().startOf("month"));
+  if (today.isBusinessDay() && !holidays.includes(today.format("MM-DD-YYYY"))) {
+    businessDays += 1;
+  }
+  return businessDays;
+};
+
+/**
+ * Calculates the number of working days in the last month, excluding holidays.
+ * @returns {number}
+ * @constructor
+ */
+export const CalculateWorkingDaysLastMonth = () => {
+  const businessDays = dayjs().subtract(1, "month").businessDaysInMonth();
+  return businessDays.filter((day) => !holidays.includes(dayjs(day).format("MM-DD-YYYY"))).length;
+};
+
+/**
+ * Calculates the weekly target hours based on daily target hours and the number of working days in the current week.
+ * @param dailyTargetHrs
+ * @returns {number}
+ * @constructor
+ */
 export const WeeklyTargetHrs = (dailyTargetHrs) =>
   dailyTargetHrs * CalculateWorkingDaysInPeriod(dayjs().startOf("week"), dayjs().endOf("week"));
 
+/**
+ * Calculates the weekly target hours for a specific period.
+ * @param dailyTargetHrs
+ * @param start
+ * @param end
+ * @returns {number}
+ * @constructor
+ */
 export const WeeklyTargetHrsInPeriod = (dailyTargetHrs, start, end) =>
   dailyTargetHrs * CalculateWorkingDaysInPeriod(start, end);
 
+/**
+ * Calculates the monthly target hours based on daily target hours and the number of working days in the current month.
+ * @param dailyTargetHrs
+ * @returns {number}
+ * @constructor
+ */
 export const MonthlyTargetHrs = (dailyTargetHrs) => dailyTargetHrs * CalculateWorkingDaysThisMonth();
 
+/**
+ * Calculates the monthly target hours for the last month based on daily target hours and the number of working days
+ * in the last month.
+ * @param dailyTargetHrs
+ * @returns {number}
+ * @constructor
+ */
 export const LastMonthTargetHrs = (dailyTargetHrs) => dailyTargetHrs * CalculateWorkingDaysLastMonth();
 
+/**
+ * Calculates the target hours as of today based on daily target hours and the number of working days as of today.
+ * @param dailyTargetHrs
+ * @returns {number}
+ * @constructor
+ */
 export const AsOfTodayTargetHrs = (dailyTargetHrs) => dailyTargetHrs * CalculateWorkingDaysAsOfToday();
 
-export const AsOfDateTargetHours = (dailyTargetHours, date) =>
-  dailyTargetHours * dayjs(date).businessDiff(dayjs().startOf("month"));
+/**
+ * Calculates the target hours as of a specific date based on daily target hours and the number of business days up to
+ * that date.
+ * @param dailyTargetHours
+ * @param date
+ * @returns {number}
+ * @constructor
+ */
+export const AsOfDateTargetHours = (dailyTargetHours, date) => {
+  let businessDays = dayjs(date).businessDiff(dayjs().startOf("month"));
+  if (dayjs(date).isBusinessDay() && !holidays.includes(dayjs(date).format("MM-DD-YYYY"))) {
+    businessDays += 1;
+  }
+  return dailyTargetHours * businessDays;
+};
 
+/**
+ * Generates a list of all days in the current month.
+ * @returns {*[]}
+ * @constructor
+ */
 export const ListOfDaysInCurrentMonth = () => {
   const days = [];
   let dateStart = dayjs().startOf("month");
@@ -36,6 +179,13 @@ export const ListOfDaysInCurrentMonth = () => {
   return days;
 };
 
+/**
+ * Generates a list of all days between two dates.
+ * @param start
+ * @param end
+ * @returns {*[]}
+ * @constructor
+ */
 export const ListDaysBetween = ({ start, end }) => {
   const days = [];
   let dateStart = dayjs(start);

client/src/contexts/SocketIO/socketProvider.jsx

@@ -16,7 +16,7 @@ import {
 import { useMutation } from "@apollo/client";
 import { useTranslation } from "react-i18next";
 import { useSplitTreatments } from "@splitsoftware/splitio-react";
-import { INITIAL_NOTIFICATIONS, SocketContext } from "./useSocket.js";
+import { SocketContext, INITIAL_NOTIFICATIONS } from "./useSocket.js";
 
 /**
  * Socket Provider - Scenario Notifications / Web Socket related items
@@ -157,10 +157,7 @@ const SocketProvider = ({ children, bodyshop, navigate, currentUser }) => {
         auth: { token, bodyshopId: bodyshop.id },
         reconnectionAttempts: Infinity,
         reconnectionDelay: 2000,
-        reconnectionDelayMax: 60000,
-        randomizationFactor: 0.5,
-        transports: ["websocket", "polling"], // Add this to prefer WebSocket with polling fallback
-        rememberUpgrade: true
+        reconnectionDelayMax: 10000
       });
 
       socketRef.current = socketInstance;

server/job/job-costing.js

@@ -19,7 +19,7 @@ async function JobCosting(req, res) {
   const client = req.userGraphQLClient;
 
   //Uncomment for further testing
-  logger.log("job-costing-start", "DEBUG", req.user.email, jobid, null);
+  // logger.log("job-costing-start", "DEBUG", req.user.email, jobid, null);
 
   try {
     const resp = await client.setHeaders({ Authorization: BearerToken }).request(queries.QUERY_JOB_COSTING_DETAILS, {
@@ -47,9 +47,9 @@ async function JobCostingMulti(req, res) {
   const client = req.userGraphQLClient;
 
   //Uncomment for further testing
-  logger.log("job-costing-multi-start", "DEBUG", req?.user?.email, null, {
-    jobids
-  });
+  // logger.log("job-costing-multi-start", "DEBUG", req?.user?.email, null, {
+  //   jobids
+  // });
 
   try {
     const resp = await client
@@ -589,7 +589,7 @@ function GenerateCostingData(job) {
           amount: Math.round((job.storage_payable || 0) * 100)
         });
   }
-
+  
   //Is it a DMS Setup?
   const selectedDmsAllocationConfig =
     (job.bodyshop.md_responsibility_centers.dms_defaults &&

server/job/job-lifecycle.js

@@ -8,7 +8,6 @@ const getLifecycleStatusColor = require("../utils/getLifecycleStatusColor");
 const jobLifecycle = async (req, res) => {
   // Grab the jobids and statuses from the request body
   const { jobids, statuses } = req.body;
-  const { logger } = req;
 
   if (!jobids) {
     return res.status(400).json({
@@ -17,118 +16,102 @@ const jobLifecycle = async (req, res) => {
   }
 
   const jobIDs = _.isArray(jobids) ? jobids : [jobids];
+  const client = req.userGraphQLClient;
+  const resp = await client.request(queries.QUERY_TRANSITIONS_BY_JOBID, { jobids: jobIDs });
 
-  logger.log("job-lifecycle-start", "DEBUG", req?.user?.email, null, {
-    jobids: jobIDs
-  });
-
-  try {
-    const client = req.userGraphQLClient;
-    const resp = await client.request(queries.QUERY_TRANSITIONS_BY_JOBID, { jobids: jobIDs });
-
-    const transitions = resp.transitions;
-
-    if (!transitions) {
-      return res.status(200).json({
-        jobIDs,
-        transitions: []
-      });
-    }
-
-    const transitionsByJobId = _.groupBy(resp.transitions, "jobid");
-
-    const groupedTransitions = {};
-    const allDurations = [];
-
-    for (let jobId in transitionsByJobId) {
-      let lifecycle = transitionsByJobId[jobId].map((transition) => {
-        transition.start_readable = transition.start ? moment(transition.start).fromNow() : "N/A";
-        transition.end_readable = transition.end ? moment(transition.end).fromNow() : "N/A";
-
-        if (transition.duration) {
-          transition.duration_seconds = Math.round(transition.duration / 1000);
-          transition.duration_minutes = Math.round(transition.duration_seconds / 60);
-          let duration = moment.duration(transition.duration);
-          transition.duration_readable = durationToHumanReadable(duration);
-        } else {
-          transition.duration_seconds = 0;
-          transition.duration_minutes = 0;
-          transition.duration_readable = "N/A";
-        }
-        return transition;
-      });
-
-      const durations = calculateStatusDuration(lifecycle, statuses);
-
-      groupedTransitions[jobId] = {
-        lifecycle,
-        durations
-      };
-
-      if (durations?.summations) {
-        allDurations.push(durations.summations);
-      }
-    }
-
-    const finalSummations = [];
-    const flatGroupedAllDurations = _.groupBy(allDurations.flat(), "status");
-
-    const finalStatusCounts = Object.keys(flatGroupedAllDurations).reduce((acc, status) => {
-      acc[status] = flatGroupedAllDurations[status].length;
-      return acc;
-    }, {});
-    // Calculate total value of all statuses
-    const finalTotal = Object.values(flatGroupedAllDurations).reduce((total, statusArr) => {
-      return total + statusArr.reduce((acc, curr) => acc + curr.value, 0);
-    }, 0);
-
-    Object.keys(flatGroupedAllDurations).forEach((status) => {
-      const value = flatGroupedAllDurations[status].reduce((acc, curr) => acc + curr.value, 0);
-      const humanReadable = durationToHumanReadable(moment.duration(value));
-      const percentage = finalTotal > 0 ? (value / finalTotal) * 100 : 0;
-      const color = getLifecycleStatusColor(status);
-      const roundedPercentage = `${Math.round(percentage)}%`;
-      const averageValue = _.size(jobIDs) > 0 ? value / jobIDs.length : 0;
-      const averageHumanReadable = durationToHumanReadable(moment.duration(averageValue));
-      finalSummations.push({
-        status,
-        value,
-        humanReadable,
-        percentage,
-        color,
-        roundedPercentage,
-        averageValue,
-        averageHumanReadable
-      });
-    });
+  const transitions = resp.transitions;
 
+  if (!transitions) {
     return res.status(200).json({
       jobIDs,
-      transition: groupedTransitions,
-      durations: {
-        jobs: jobIDs.length,
-        summations: finalSummations,
-        totalStatuses: finalSummations.length,
-        total: finalTotal,
-        statusCounts: finalStatusCounts,
-        humanReadable: durationToHumanReadable(moment.duration(finalTotal)),
-        averageValue: _.size(jobIDs) > 0 ? finalTotal / jobIDs.length : 0,
-        averageHumanReadable:
-          _.size(jobIDs) > 0
-            ? durationToHumanReadable(moment.duration(finalTotal / jobIDs.length))
-            : durationToHumanReadable(moment.duration(0))
-      }
-    });
-  } catch (error) {
-    logger.log("job-lifecycle-error", "ERROR", req?.user?.email, null, {
-      jobids: jobIDs,
-      statuses: statuses ? JSON.stringify(statuses) : "N/A",
-      error: error.message
-    });
-    return res.status(500).json({
-      error: "Internal server error"
+      transitions: []
     });
   }
+
+  const transitionsByJobId = _.groupBy(resp.transitions, "jobid");
+
+  const groupedTransitions = {};
+  const allDurations = [];
+
+  for (let jobId in transitionsByJobId) {
+    let lifecycle = transitionsByJobId[jobId].map((transition) => {
+      transition.start_readable = transition.start ? moment(transition.start).fromNow() : "N/A";
+      transition.end_readable = transition.end ? moment(transition.end).fromNow() : "N/A";
+
+      if (transition.duration) {
+        transition.duration_seconds = Math.round(transition.duration / 1000);
+        transition.duration_minutes = Math.round(transition.duration_seconds / 60);
+        let duration = moment.duration(transition.duration);
+        transition.duration_readable = durationToHumanReadable(duration);
+      } else {
+        transition.duration_seconds = 0;
+        transition.duration_minutes = 0;
+        transition.duration_readable = "N/A";
+      }
+      return transition;
+    });
+
+    const durations = calculateStatusDuration(lifecycle, statuses);
+
+    groupedTransitions[jobId] = {
+      lifecycle,
+      durations
+    };
+
+    if (durations?.summations) {
+      allDurations.push(durations.summations);
+    }
+  }
+
+  const finalSummations = [];
+  const flatGroupedAllDurations = _.groupBy(allDurations.flat(), "status");
+
+  const finalStatusCounts = Object.keys(flatGroupedAllDurations).reduce((acc, status) => {
+    acc[status] = flatGroupedAllDurations[status].length;
+    return acc;
+  }, {});
+  // Calculate total value of all statuses
+  const finalTotal = Object.values(flatGroupedAllDurations).reduce((total, statusArr) => {
+    return total + statusArr.reduce((acc, curr) => acc + curr.value, 0);
+  }, 0);
+
+  Object.keys(flatGroupedAllDurations).forEach((status) => {
+    const value = flatGroupedAllDurations[status].reduce((acc, curr) => acc + curr.value, 0);
+    const humanReadable = durationToHumanReadable(moment.duration(value));
+    const percentage = finalTotal > 0 ? (value / finalTotal) * 100 : 0;
+    const color = getLifecycleStatusColor(status);
+    const roundedPercentage = `${Math.round(percentage)}%`;
+    const averageValue = _.size(jobIDs) > 0 ? value / jobIDs.length : 0;
+    const averageHumanReadable = durationToHumanReadable(moment.duration(averageValue));
+    finalSummations.push({
+      status,
+      value,
+      humanReadable,
+      percentage,
+      color,
+      roundedPercentage,
+      averageValue,
+      averageHumanReadable
+    });
+  });
+
+  return res.status(200).json({
+    jobIDs,
+    transition: groupedTransitions,
+    durations: {
+      jobs: jobIDs.length,
+      summations: finalSummations,
+      totalStatuses: finalSummations.length,
+      total: finalTotal,
+      statusCounts: finalStatusCounts,
+      humanReadable: durationToHumanReadable(moment.duration(finalTotal)),
+      averageValue: _.size(jobIDs) > 0 ? finalTotal / jobIDs.length : 0,
+      averageHumanReadable:
+        _.size(jobIDs) > 0
+          ? durationToHumanReadable(moment.duration(finalTotal / jobIDs.length))
+          : durationToHumanReadable(moment.duration(0))
+    }
+  });
 };
 
 module.exports = jobLifecycle;