IO-2971 add null coalescing

Release/2024 09 27 into master-AIO - IO-2967

client/src/components/jobs-export-all-button/jobs-export-all-button.component.jsx

@@ -219,7 +219,7 @@ export function JobsExportAllButton({
   };
 
   return (
-    <Button onClick={handleQbxml} loading={loading} disabled={disabled}>
+    <Button onClick={handleQbxml} loading={loading} disabled={disabled || jobIds?.length > 10}>
       {t("jobs.actions.exportselected")}
     </Button>
   );

client/src/components/payable-export-all-button/payable-export-all-button.component.jsx

@@ -200,7 +200,7 @@ export function PayableExportAll({
     );
 
   return (
-    <Button onClick={handleQbxml} loading={loading} disabled={disabled}>
+    <Button onClick={handleQbxml} loading={loading} disabled={disabled || billids?.length > 10}>
       {t("jobs.actions.exportselected")}
     </Button>
   );

client/src/components/payments-export-all-button/payments-export-all-button.component.jsx

@@ -180,7 +180,7 @@ export function PaymentsExportAllButton({
   };
 
   return (
-    <Button onClick={handleQbxml} loading={loading} disabled={disabled}>
+    <Button onClick={handleQbxml} loading={loading} disabled={disabled || paymentIds?.length > 10}>
       {t("jobs.actions.exportselected")}
     </Button>
   );

client/src/components/production-board-kanban/production-board-kanban.container.jsx

@@ -1,8 +1,9 @@
-import React, { useEffect, useMemo, useRef } from "react";
-import { useQuery, useSubscription } from "@apollo/client";
+import React, { useContext, useEffect, useMemo, useRef } from "react";
+import { useApolloClient, useQuery, useSubscription } from "@apollo/client";
 import { connect } from "react-redux";
 import { createStructuredSelector } from "reselect";
 import {
+  QUERY_EXACT_JOB_IN_PRODUCTION,
   QUERY_JOBS_IN_PRODUCTION,
   SUBSCRIPTION_JOBS_IN_PRODUCTION,
   SUBSCRIPTION_JOBS_IN_PRODUCTION_VIEW
@@ -10,6 +11,8 @@ import {
 import { QUERY_KANBAN_SETTINGS } from "../../graphql/user.queries";
 import { selectBodyshop, selectCurrentUser } from "../../redux/user/user.selectors";
 import ProductionBoardKanbanComponent from "./production-board-kanban.component";
+import { useSplitTreatments } from "@splitsoftware/splitio-react";
+import SocketContext from "../../contexts/SocketIO/socketContext.jsx";
 
 const mapStateToProps = createStructuredSelector({
   bodyshop: selectBodyshop,
@@ -17,7 +20,20 @@ const mapStateToProps = createStructuredSelector({
 });
 
 function ProductionBoardKanbanContainer({ bodyshop, currentUser, subscriptionType = "direct" }) {
-  const fired = useRef(false); // useRef to keep track of whether the subscription fired
+  const fired = useRef(false);
+  const client = useApolloClient();
+  const { socket } = useContext(SocketContext); // Get the socket from context
+  const reconnectTimeout = useRef(null); // To store the reconnect timeout
+  const disconnectTime = useRef(null); // To track disconnection time
+  const acceptableReconnectTime = 2000; // 2 seconds threshold
+
+  const {
+    treatments: { Websocket_Production }
+  } = useSplitTreatments({
+    attributes: {},
+    names: ["Websocket_Production"],
+    splitKey: bodyshop && bodyshop.imexshopid
+  });
 
   const combinedStatuses = useMemo(
     () => [
@@ -34,9 +50,12 @@ function ProductionBoardKanbanContainer({ bodyshop, currentUser, subscriptionTyp
     onError: (error) => console.error(`Error fetching jobs in production: ${error.message}`)
   });
 
+  const subscriptionEnabled = Websocket_Production?.treatment === "off";
+
   const { data: updatedJobs } = useSubscription(
     subscriptionType === "view" ? SUBSCRIPTION_JOBS_IN_PRODUCTION_VIEW : SUBSCRIPTION_JOBS_IN_PRODUCTION,
     {
+      skip: !subscriptionEnabled,
       onError: (error) => console.error(`Error subscribing to jobs in production: ${error.message}`)
     }
   );
@@ -46,22 +65,112 @@ function ProductionBoardKanbanContainer({ bodyshop, currentUser, subscriptionTyp
     onError: (error) => console.error(`Error fetching Kanban settings: ${error.message}`)
   });
 
-  // const currentReducerData = useSelector((state) => (state.trello.lanes ? state.trello : {}));
-
   useEffect(() => {
-    if (!updatedJobs) {
+    if (subscriptionEnabled) {
+      if (!updatedJobs) {
+        return;
+      }
+      if (!fired.current) {
+        fired.current = true;
+        return;
+      }
+      refetch().catch((err) => console.error(`Error re-fetching jobs in production: ${err.message}`));
+    }
+  }, [updatedJobs, refetch, subscriptionEnabled]);
+
+  // Socket.IO implementation for users with Split treatment "off"
+  useEffect(() => {
+    if (subscriptionEnabled || !socket || !bodyshop || !bodyshop.id) {
       return;
     }
-    if (!fired.current) {
-      fired.current = true;
-      return;
-    }
-    refetch().catch((err) => console.error(`Error re-fetching jobs in production: ${err.message}`));
-  }, [updatedJobs, refetch]);
+
+    const handleJobUpdates = async (jobChangedData) => {
+      const jobId = jobChangedData.id;
+
+      // Access the existing cache for QUERY_JOBS_IN_PRODUCTION
+      const existingJobsCache = client.readQuery({
+        query: QUERY_JOBS_IN_PRODUCTION
+      });
+
+      const existingJobs = existingJobsCache?.jobs || [];
+
+      // Check if the job already exists in the cached jobs
+      const existingJob = existingJobs.find((job) => job.id === jobId);
+
+      if (existingJob) {
+        // If the job exists, we update the cache without making any additional queries
+        client.writeQuery({
+          query: QUERY_JOBS_IN_PRODUCTION,
+          data: {
+            jobs: existingJobs.map((job) =>
+              job.id === jobId ? { ...existingJob, ...jobChangedData, __typename: "jobs" } : job
+            )
+          }
+        });
+      } else {
+        // If the job doesn't exist, fetch it from the server and then add it to the cache
+        try {
+          const { data: jobData } = await client.query({
+            query: QUERY_EXACT_JOB_IN_PRODUCTION,
+            variables: { id: jobId },
+            fetchPolicy: "network-only"
+          });
+
+          // Add the job to the existing cached jobs
+          client.writeQuery({
+            query: QUERY_JOBS_IN_PRODUCTION,
+            data: {
+              jobs: [...existingJobs, { ...jobData.job, __typename: "jobs" }]
+            }
+          });
+        } catch (error) {
+          console.error(`Error fetching job ${jobId}: ${error.message}`);
+        }
+      }
+    };
+
+    const handleDisconnect = () => {
+      // Capture the disconnection time
+      disconnectTime.current = Date.now();
+    };
+
+    const handleReconnect = () => {
+      const reconnectTime = Date.now();
+      const disconnectionDuration = reconnectTime - disconnectTime.current;
+
+      // Only refetch if disconnection was longer than the acceptable reconnect time
+      if (disconnectionDuration >= acceptableReconnectTime) {
+        if (!reconnectTimeout.current) {
+          reconnectTimeout.current = setTimeout(() => {
+            const randomDelay = Math.floor(Math.random() * (30000 - 10000 + 1)) + 10000; // Random delay between 10 and 30 seconds
+            setTimeout(() => {
+              if (refetch) refetch().catch((err) => console.error(`Issue `));
+              reconnectTimeout.current = null; // Clear the timeout reference after refetch
+            }, randomDelay);
+          }, acceptableReconnectTime);
+        }
+      }
+    };
+
+    // Listen for 'job-changed', 'disconnect', and 'connect' events
+    socket.on("production-job-updated", handleJobUpdates);
+    socket.on("disconnect", handleDisconnect);
+    socket.on("connect", handleReconnect);
+
+    // Clean up on unmount or when dependencies change
+    return () => {
+      socket.off("production-job-updated", handleJobUpdates);
+      socket.off("disconnect", handleDisconnect);
+      socket.off("connect", handleReconnect);
+      if (reconnectTimeout.current) {
+        clearTimeout(reconnectTimeout.current);
+      }
+    };
+  }, [subscriptionEnabled, socket, bodyshop, client, refetch]);
 
   const filteredAssociationSettings = useMemo(() => {
     return associationSettings?.associations[0] || null;
-  }, [associationSettings]);
+  }, [associationSettings?.associations]);
 
   return (
     <ProductionBoardKanbanComponent

client/src/components/production-list-table/production-list-table.container.jsx

@@ -1,5 +1,5 @@
 import { useApolloClient, useQuery, useSubscription } from "@apollo/client";
-import React, { useEffect, useState } from "react";
+import React, { useContext, useEffect, useState, useRef } from "react";
 import {
   QUERY_EXACT_JOB_IN_PRODUCTION,
   QUERY_EXACT_JOBS_IN_PRODUCTION,
@@ -9,19 +9,46 @@ import {
 } from "../../graphql/jobs.queries";
 import ProductionListTable from "./production-list-table.component";
 import _ from "lodash";
+import { useSplitTreatments } from "@splitsoftware/splitio-react";
+import SocketContext from "../../contexts/SocketIO/socketContext.jsx";
 
-export default function ProductionListTableContainer({ subscriptionType = "direct" }) {
+export default function ProductionListTableContainer({ bodyshop, subscriptionType = "direct" }) {
+  const client = useApolloClient();
+  const { socket } = useContext(SocketContext);
+  const [joblist, setJoblist] = useState([]);
+  const reconnectTimeout = useRef(null); // To store the reconnect timeout
+  const disconnectTime = useRef(null); // To store the time of disconnection
+
+  const acceptableReconnectTime = 2000; // 2 seconds threshold
+
+  // Get Split treatment
+  const {
+    treatments: { Websocket_Production }
+  } = useSplitTreatments({
+    attributes: {},
+    names: ["Websocket_Production"],
+    splitKey: bodyshop && bodyshop.imexshopid
+  });
+
+  // Determine if subscription is enabled
+  const subscriptionEnabled = Websocket_Production?.treatment === "off";
+
+  // Use GraphQL query
   const { refetch, loading, data } = useQuery(QUERY_JOBS_IN_PRODUCTION, {
     pollInterval: 3600000,
     fetchPolicy: "network-only",
     nextFetchPolicy: "network-only"
   });
-  const client = useApolloClient();
-  const [joblist, setJoblist] = useState([]);
+
+  // Use GraphQL subscription when subscription is enabled
   const { data: updatedJobs } = useSubscription(
-    subscriptionType === "view" ? SUBSCRIPTION_JOBS_IN_PRODUCTION_VIEW : SUBSCRIPTION_JOBS_IN_PRODUCTION
+    subscriptionType === "view" ? SUBSCRIPTION_JOBS_IN_PRODUCTION_VIEW : SUBSCRIPTION_JOBS_IN_PRODUCTION,
+    {
+      skip: !subscriptionEnabled
+    }
   );
 
+  // Update joblist when data changes
   useEffect(() => {
     if (!(data && data.jobs)) return;
     setJoblist(
@@ -31,34 +58,134 @@ export default function ProductionListTableContainer({ subscriptionType = "direc
     );
   }, [data]);
 
+  // Handle updates from GraphQL subscription
   useEffect(() => {
-    if (!updatedJobs || joblist.length === 0) return;
+    if (subscriptionEnabled) {
+      if (!updatedJobs || joblist.length === 0) return;
 
-    const jobDiff = _.differenceWith(
-      joblist,
-      updatedJobs.jobs,
-      (a, b) => a.id === b.id && a.updated_at === b.updated_at
-    );
+      const jobDiff = _.differenceWith(
+        joblist,
+        updatedJobs.jobs,
+        (a, b) => a.id === b.id && a.updated_at === b.updated_at
+      );
 
-    if (jobDiff.length > 1) {
-      getUpdatedJobsData(jobDiff.map((j) => j.id));
-    } else if (jobDiff.length === 1) {
-      jobDiff.forEach((job) => {
-        getUpdatedJobData(job.id);
-      });
+      if (jobDiff.length > 1) {
+        getUpdatedJobsData(jobDiff.map((j) => j.id));
+      } else if (jobDiff.length === 1) {
+        jobDiff.forEach((job) => {
+          getUpdatedJobData(job.id);
+        });
+      }
+
+      setJoblist(updatedJobs.jobs);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [updatedJobs, subscriptionEnabled]);
+
+  // Handle updates from Socket.IO when subscription is disabled
+  useEffect(() => {
+    if (subscriptionEnabled || !socket || !bodyshop || !bodyshop.id) {
+      return;
     }
 
-    setJoblist(updatedJobs.jobs);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [updatedJobs]);
+    const handleJobUpdates = async (jobChangedData) => {
+      const jobId = jobChangedData.id;
 
+      // Access the existing cache for QUERY_JOBS_IN_PRODUCTION
+      const existingJobsCache = client.readQuery({
+        query: QUERY_JOBS_IN_PRODUCTION
+      });
+
+      const existingJobs = existingJobsCache?.jobs || [];
+
+      // Check if the job already exists in the cached jobs
+      const existingJob = existingJobs.find((job) => job.id === jobId);
+
+      if (existingJob) {
+        // If the job exists, we update the cache without making any additional queries
+        client.writeQuery({
+          query: QUERY_JOBS_IN_PRODUCTION,
+          data: {
+            jobs: existingJobs.map((job) =>
+              job.id === jobId ? { ...existingJob, ...jobChangedData, __typename: "jobs" } : job
+            )
+          }
+        });
+      } else {
+        // If the job doesn't exist, fetch it from the server and then add it to the cache
+        try {
+          const { data: jobData } = await client.query({
+            query: QUERY_EXACT_JOB_IN_PRODUCTION,
+            variables: { id: jobId },
+            fetchPolicy: "network-only"
+          });
+
+          // Add the job to the existing cached jobs
+          client.writeQuery({
+            query: QUERY_JOBS_IN_PRODUCTION,
+            data: {
+              jobs: [...existingJobs, { ...jobData.job, __typename: "jobs" }]
+            }
+          });
+        } catch (error) {
+          console.error(`Error fetching job ${jobId}: ${error.message}`);
+        }
+      }
+    };
+
+    const handleDisconnect = () => {
+      // Capture the time when the disconnection happens
+      disconnectTime.current = Date.now();
+    };
+
+    const handleReconnect = () => {
+      // Calculate how long the disconnection lasted
+      const reconnectTime = Date.now();
+      const disconnectionDuration = reconnectTime - disconnectTime.current;
+
+      // If disconnection lasted less than acceptable reconnect time, do nothing
+      if (disconnectionDuration < acceptableReconnectTime) {
+        return;
+      }
+
+      // Schedule a refetch with a random delay between 10 and 30 seconds
+      if (!reconnectTimeout.current) {
+        reconnectTimeout.current = setTimeout(() => {
+          const randomDelay = Math.floor(Math.random() * (30000 - 10000 + 1)) + 10000; // Random delay between 10 and 30 seconds
+          setTimeout(() => {
+            if (refetch) refetch();
+            reconnectTimeout.current = null; // Clear the timeout reference after refetch
+          }, randomDelay);
+        }, acceptableReconnectTime);
+      }
+    };
+
+    // Listen for 'production-job-updated', 'disconnect', and 'connect' events
+    socket.on("production-job-updated", handleJobUpdates);
+    socket.on("disconnect", handleDisconnect);
+    socket.on("connect", handleReconnect);
+
+    // Clean up on unmount or when dependencies change
+    return () => {
+      socket.off("production-job-updated", handleJobUpdates);
+      socket.off("disconnect", handleDisconnect);
+      socket.off("connect", handleReconnect);
+      if (reconnectTimeout.current) {
+        clearTimeout(reconnectTimeout.current);
+      }
+    };
+  }, [subscriptionEnabled, socket, bodyshop, client, refetch]);
+
+  // Functions to fetch updated job data
   const getUpdatedJobData = async (jobId) => {
-    client.query({
+    await client.query({
       query: QUERY_EXACT_JOB_IN_PRODUCTION,
-      variables: { id: jobId }
+      variables: { id: jobId },
+      fetchPolicy: "network-only"
     });
   };
-  const getUpdatedJobsData = async (jobIds) => {
+
+  const getUpdatedJobsData = (jobIds) => {
     client.query({
       query: QUERY_EXACT_JOBS_IN_PRODUCTION,
       variables: { ids: jobIds }

client/src/components/wss-status-display/wss-status-display.component.jsx

@@ -0,0 +1,18 @@
+import { connect } from "react-redux";
+import { GlobalOutlined } from "@ant-design/icons";
+import { createStructuredSelector } from "reselect";
+import React from "react";
+import { selectWssStatus } from "../../redux/application/application.selectors";
+const mapStateToProps = createStructuredSelector({
+  //currentUser: selectCurrentUser
+  wssStatus: selectWssStatus
+});
+const mapDispatchToProps = (dispatch) => ({
+  //setUserLanguage: language => dispatch(setUserLanguage(language))
+});
+export default connect(mapStateToProps, mapDispatchToProps)(WssStatusDisplay);
+
+export function WssStatusDisplay({ wssStatus }) {
+  console.log("🚀 ~ WssStatusDisplay ~ wssStatus:", wssStatus);
+  return <GlobalOutlined style={{ color: wssStatus === "connected" ? "green" : "red", marginRight: ".5rem" }} />;
+}

client/src/contexts/SocketIO/useSocket.js

@@ -1,83 +1,88 @@
-import { useEffect, useState } from "react";
+import { useEffect, useState, useRef } from "react";
 import SocketIO from "socket.io-client";
 import { auth } from "../../firebase/firebase.utils";
-
+import { store } from "../../redux/store";
+import { setWssStatus } from "../../redux/application/application.actions";
 const useSocket = (bodyshop) => {
-  const [socket, setSocket] = useState(null);
+  const socketRef = useRef(null);
   const [clientId, setClientId] = useState(null);
-  const [token, setToken] = useState(null);
 
   useEffect(() => {
-    // Listener for token changes
     const unsubscribe = auth.onIdTokenChanged(async (user) => {
       if (user) {
         const newToken = await user.getIdToken();
-        setToken(newToken);
+
+        if (socketRef.current) {
+          // Send new token to server
+          socketRef.current.emit("update-token", newToken);
+        } else if (bodyshop && bodyshop.id) {
+          // Initialize the socket
+          const endpoint = import.meta.env.PROD ? import.meta.env.VITE_APP_AXIOS_BASE_API_URL : "";
+
+          const socketInstance = SocketIO(endpoint, {
+            path: "/wss",
+            withCredentials: true,
+            auth: { token: newToken },
+            reconnectionAttempts: Infinity,
+            reconnectionDelay: 2000,
+            reconnectionDelayMax: 10000
+          });
+
+          socketRef.current = socketInstance;
+
+          const handleBodyshopMessage = (message) => {
+            if (!import.meta.env.DEV) return;
+            console.log(`Received message for bodyshop ${bodyshop.id}:`, message);
+          };
+
+          const handleConnect = () => {
+            console.log("Socket connected:", socketInstance.id);
+            socketInstance.emit("join-bodyshop-room", bodyshop.id);
+            setClientId(socketInstance.id);
+            store.dispatch(setWssStatus("connected"))
+          };
+
+          const handleReconnect = (attempt) => {
+            console.log(`Socket reconnected after ${attempt} attempts`);
+            store.dispatch(setWssStatus("connected"))
+          };
+
+          const handleConnectionError = (err) => {
+            console.error("Socket connection error:", err);
+            store.dispatch(setWssStatus("error"))
+          };
+
+          const handleDisconnect = () => {
+            console.log("Socket disconnected");
+            store.dispatch(setWssStatus("disconnected"))
+          };
+
+          socketInstance.on("connect", handleConnect);
+          socketInstance.on("reconnect", handleReconnect);
+          socketInstance.on("connect_error", handleConnectionError);
+          socketInstance.on("disconnect", handleDisconnect);
+          socketInstance.on("bodyshop-message", handleBodyshopMessage);
+        }
       } else {
-        setToken(null);
+        // User is not authenticated
+        if (socketRef.current) {
+          socketRef.current.disconnect();
+          socketRef.current = null;
+        }
       }
     });
 
     // Clean up the listener on unmount
-    return () => unsubscribe();
-  }, []);
+    return () => {
+      unsubscribe();
+      if (socketRef.current) {
+        socketRef.current.disconnect();
+        socketRef.current = null;
+      }
+    };
+  }, [bodyshop]);
 
-  useEffect(() => {
-    if (bodyshop && bodyshop.id && token) {
-      const endpoint = import.meta.env.PROD ? import.meta.env.VITE_APP_AXIOS_BASE_API_URL : "";
-
-      const socketInstance = SocketIO(endpoint, {
-        path: "/wss",
-        withCredentials: true,
-        auth: { token }, // Use the current token
-        reconnectionAttempts: Infinity,
-        reconnectionDelay: 2000,
-        reconnectionDelayMax: 10000
-      });
-
-      setSocket(socketInstance);
-
-      const handleBodyshopMessage = (message) => {
-        console.log(`Received message for bodyshop ${bodyshop.id}:`, message);
-      };
-
-      const handleConnect = () => {
-        console.log("Socket connected:", socketInstance.id);
-        socketInstance.emit("join-bodyshop-room", bodyshop.id);
-        setClientId(socketInstance.id);
-      };
-
-      const handleReconnect = (attempt) => {
-        console.log(`Socket reconnected after ${attempt} attempts`);
-      };
-
-      const handleConnectionError = (err) => {
-        console.error("Socket connection error:", err);
-      };
-
-      const handleDisconnect = () => {
-        console.log("Socket disconnected");
-      };
-
-      socketInstance.on("connect", handleConnect);
-      socketInstance.on("reconnect", handleReconnect);
-      socketInstance.on("connect_error", handleConnectionError);
-      socketInstance.on("disconnect", handleDisconnect);
-      socketInstance.on("bodyshop-message", handleBodyshopMessage);
-
-      return () => {
-        socketInstance.emit("leave-bodyshop-room", bodyshop.id);
-        socketInstance.off("connect", handleConnect);
-        socketInstance.off("reconnect", handleReconnect);
-        socketInstance.off("connect_error", handleConnectionError);
-        socketInstance.off("disconnect", handleDisconnect);
-        socketInstance.off("bodyshop-message", handleBodyshopMessage);
-        socketInstance.disconnect();
-      };
-    }
-  }, [bodyshop, token]); // Include 'token' in dependencies to re-run effect when it changes
-
-  return { socket, clientId };
+  return { socket: socketRef.current, clientId };
 };
 
 export default useSocket;

client/src/pages/manage/manage.page.component.jsx

@@ -25,6 +25,7 @@ import { selectBodyshop, selectInstanceConflict } from "../../redux/user/user.se
 import UpdateAlert from "../../components/update-alert/update-alert.component";
 import InstanceRenderManager from "../../utils/instanceRenderMgr.js";
 import "./manage.page.styles.scss";
+import WssStatusDisplayComponent from "../../components/wss-status-display/wss-status-display.component.jsx";
 
 const JobsPage = lazy(() => import("../jobs/jobs.page"));
 
@@ -604,6 +605,7 @@ export function Manage({ conflict, bodyshop }) {
             }}
           >
             <div style={{ display: "flex" }}>
+              <WssStatusDisplayComponent />
               <div onClick={broadcastMessage}>
                 {`${InstanceRenderManager({
                   imex: t("titles.imexonline"),

client/src/pages/production-list/production-list.component.jsx

@@ -26,7 +26,7 @@ export function ProductionListComponent({ bodyshop }) {
   return (
     <>
       <NoteUpsertModal />
-      <ProductionListTable subscriptionType={Production_Use_View.treatment} />
+      <ProductionListTable bodyshop={bodyshop} subscriptionType={Production_Use_View.treatment} />
     </>
   );
 }

client/src/redux/application/application.actions.js

@@ -67,3 +67,7 @@ export const setUpdateAvailable = (isUpdateAvailable) => ({
   type: ApplicationActionTypes.SET_UPDATE_AVAILABLE,
   payload: isUpdateAvailable
 });
+export const setWssStatus = (status) => ({
+  type: ApplicationActionTypes.SET_WSS_STATUS,
+  payload: status
+});

client/src/redux/application/application.reducer.js

@@ -3,6 +3,7 @@ import ApplicationActionTypes from "./application.types";
 const INITIAL_STATE = {
   loading: false,
   online: true,
+  wssStatus: "disconnected",
   updateAvailable: false,
   breadcrumbs: [],
   recentItems: [],
@@ -87,6 +88,9 @@ const applicationReducer = (state = INITIAL_STATE, action) => {
     case ApplicationActionTypes.SET_PROBLEM_JOBS: {
       return { ...state, problemJobs: action.payload };
     }
+    case ApplicationActionTypes.SET_WSS_STATUS: {
+      return { ...state, wssStatus: action.payload };
+    }
     default:
       return state;
   }

client/src/redux/application/application.selectors.js

@@ -22,3 +22,4 @@ export const selectJobReadOnly = createSelector([selectApplication], (applicatio
 export const selectOnline = createSelector([selectApplication], (application) => application.online);
 export const selectProblemJobs = createSelector([selectApplication], (application) => application.problemJobs);
 export const selectUpdateAvailable = createSelector([selectApplication], (application) => application.updateAvailable);
+export const selectWssStatus = createSelector([selectApplication], (application) => application.wssStatus);

client/src/redux/application/application.types.js

@@ -12,6 +12,7 @@ const ApplicationActionTypes = {
   SET_ONLINE_STATUS: "SET_ONLINE_STATUS",
   INSERT_AUDIT_TRAIL: "INSERT_AUDIT_TRAIL",
   SET_PROBLEM_JOBS: "SET_PROBLEM_JOBS",
-  SET_UPDATE_AVAILABLE: "SET_UPDATE_AVAILABLE"
+  SET_UPDATE_AVAILABLE: "SET_UPDATE_AVAILABLE",
+  SET_WSS_STATUS: "SET_WSS_STATUS"
 };
 export default ApplicationActionTypes;

client/src/redux/user/user.sagas.js

@@ -242,6 +242,10 @@ export function* signInSuccessSaga({ payload }) {
         window.$crisp.push(["set", "user:nickname", [payload.displayName || payload.email]]);
         window.$crisp.push(["set", "session:segments", [["user"]]]);
       },
+      rome: () => {
+        window.$zoho.salesiq.visitor.name(payload.displayName || payload.email);
+        window.$zoho.salesiq.visitor.email(payload.email);
+      },
       promanager: () => {
         Userpilot.identify(payload.email, {
           email: payload.email
@@ -371,6 +375,9 @@ export function* SetAuthLevelFromShopDetails({ payload }) {
           if (authRecord[0] && authRecord[0].user.validemail) {
             window.$crisp.push(["set", "user:email", [authRecord[0].user.email]]);
           }
+        },
+        rome: () => {
+          window.$zoho.salesiq.visitor.info({ "Shop Name": payload.shopname });
         }
       });
     } catch (error) {

server.js

@@ -10,10 +10,11 @@ const { createClient } = require("redis");
 const { createAdapter } = require("@socket.io/redis-adapter");
 const logger = require("./server/utils/logger");
 const { redisSocketEvents } = require("./server/web-sockets/redisSocketEvents");
-const { instrument, RedisStore } = require("@socket.io/admin-ui");
+const { instrument } = require("@socket.io/admin-ui");
 
 const { isString, isEmpty } = require("lodash");
 const applyRedisHelpers = require("./server/utils/redisHelpers");
+const applyIOHelpers = require("./server/utils/ioHelpers");
 
 // Load environment variables
 require("dotenv").config({
@@ -44,7 +45,7 @@ const SOCKETIO_CORS_ORIGIN = [
   "https://www.test.promanager.web-est.com",
   "https://test.promanager.web-est.com",
   "https://www.promanager.web-est.com",
-  "https://www.promanager.web-est.com",
+  "https://promanager.web-est.com",
   "https://old.imex.online",
   "https://www.old.imex.online",
   "https://wsadmin.imex.online",
@@ -62,13 +63,8 @@ const applyMiddleware = (app) => {
   app.use(cookieParser());
   app.use(bodyParser.json({ limit: "50mb" }));
   app.use(bodyParser.urlencoded({ limit: "50mb", extended: true }));
-  app.use(
-    cors({
-      origin: SOCKETIO_CORS_ORIGIN,
-      credentials: true,
-      exposedHeaders: ["set-cookie"]
-    })
-  );
+  app.use(cors({ credentials: true, exposedHeaders: ["set-cookie"] }));
+
   // Helper middleware
   app.use((req, res, next) => {
     req.logger = logger;
@@ -191,14 +187,15 @@ const main = async () => {
   const server = http.createServer(app);
 
   const { pubClient, ioRedis } = await applySocketIO(server, app);
-  const api = applyRedisHelpers(pubClient, app);
+  const api = applyRedisHelpers(pubClient, app, logger);
+  const ioHelpers = applyIOHelpers(app, api, ioRedis, logger);
 
   // Legacy Socket Events
   require("./server/web-sockets/web-socket");
 
   applyMiddleware(app);
   applyRoutes(app);
-  redisSocketEvents(ioRedis, api);
+  redisSocketEvents(ioRedis, api, ioHelpers);
 
   try {
     await server.listen(port);
@@ -209,4 +206,11 @@ const main = async () => {
 };
 
 // Start server
-main();
+main().catch((error) => {
+  logger.log(`Main-API-Error: Something was not caught in the application.`, "error", "api", null, {
+    error: error.message,
+    errorjson: JSON.stringify(error)
+  });
+  // Note: If we want the app to crash on all uncaught async operations, we would
+  // need to put a `process.exit(1);` here
+});

server/accounting/pbs/pbs-job-export.js

@@ -602,18 +602,22 @@ async function MarkJobExported(socket, jobid) {
 }
 
 async function InsertFailedExportLog(socket, error) {
-  const client = new GraphQLClient(process.env.GRAPHQL_ENDPOINT, {});
-  const result = await client
-    .setHeaders({ Authorization: `Bearer ${socket.handshake.auth.token}` })
-    .request(queries.INSERT_EXPORT_LOG, {
-      log: {
-        bodyshopid: socket.JobData.bodyshop.id,
-        jobid: socket.JobData.id,
-        successful: false,
-        message: [error],
-        useremail: socket.user.email
-      }
-    });
+  try {
+    const client = new GraphQLClient(process.env.GRAPHQL_ENDPOINT, {});
+    const result = await client
+      .setHeaders({ Authorization: `Bearer ${socket.handshake.auth.token}` })
+      .request(queries.INSERT_EXPORT_LOG, {
+        log: {
+          bodyshopid: socket.JobData.bodyshop.id,
+          jobid: socket.JobData.id,
+          successful: false,
+          message: [error],
+          useremail: socket.user.email
+        }
+      });
 
-  return result;
+    return result;
+  } catch (error2) {
+    CdkBase.createLogEvent(socket, "ERROR", `Error in InsertFailedExportLog - ${error} - ${JSON.stringify(error2)}`);
+  }
 }

server/cdk/cdk-job-export.js

@@ -986,18 +986,22 @@ async function MarkJobExported(socket, jobid) {
 }
 
 async function InsertFailedExportLog(socket, error) {
-  const client = new GraphQLClient(process.env.GRAPHQL_ENDPOINT, {});
-  const result = await client
-    .setHeaders({ Authorization: `Bearer ${socket.handshake.auth.token}` })
-    .request(queries.INSERT_EXPORT_LOG, {
-      log: {
-        bodyshopid: socket.JobData.bodyshop.id,
-        jobid: socket.JobData.id,
-        successful: false,
-        message: [error],
-        useremail: socket.user.email
-      }
-    });
+  try {
+    const client = new GraphQLClient(process.env.GRAPHQL_ENDPOINT, {});
+    const result = await client
+      .setHeaders({ Authorization: `Bearer ${socket.handshake.auth.token}` })
+      .request(queries.INSERT_EXPORT_LOG, {
+        log: {
+          bodyshopid: socket.JobData.bodyshop.id,
+          jobid: socket.JobData.id,
+          successful: false,
+          message: [error],
+          useremail: socket.user.email
+        }
+      });
 
-  return result;
+    return result;
+  } catch (error2) {
+    CdkBase.createLogEvent(socket, "ERROR", `Error in InsertFailedExportLog - ${error} - ${JSON.stringify(error2)}`);
+  }
 }

server/ioevent/ioevent.js

@@ -11,21 +11,24 @@ require("dotenv").config({
 
 exports.default = async (req, res) => {
   const { useremail, bodyshopid, operationName, variables, env, time, dbevent, user } = req.body;
-  const { ioRedis } = req;
+  const {
+    ioRedis,
+    ioHelpers: { getBodyshopRoom }
+  } = req;
   try {
-    await client.request(queries.INSERT_IOEVENT, {
-      event: {
-        operationname: operationName,
-        time,
-        dbevent,
-        env,
-        variables,
-        bodyshopid,
-        useremail
-      }
-    });
+    // await client.request(queries.INSERT_IOEVENT, {
+    //   event: {
+    //     operationname: operationName,
+    //     time,
+    //     dbevent,
+    //     env,
+    //     variables,
+    //     bodyshopid,
+    //     useremail
+    //   }
+    // });
 
-    ioRedis.to(bodyshopid).emit("bodyshop-message", {
+    ioRedis.to(getBodyshopRoom(bodyshopid)).emit("bodyshop-message", {
       operationName,
       useremail
     });

server/job/job-updated.js

@@ -0,0 +1,32 @@
+const { isObject } = require("lodash");
+
+const jobUpdated = async (req, res) => {
+  const { ioRedis, logger, ioHelpers } = req;
+
+  if (!req?.body?.event?.data?.new || !isObject(req?.body?.event?.data?.new)) {
+    logger.log("job-update-error", "ERROR", req.user?.email, null, {
+      message: `Malformed Job Update request sent from Hasura`,
+      body: req?.body
+    });
+
+    return res.json({
+      status: "error",
+      message: `Malformed Job Update request sent from Hasura`
+    });
+  }
+
+  logger.log("job-update", "INFO", req.user?.email, null, {
+    message: `Job updated event received from Hasura`,
+    jobid: req?.body?.event?.data?.new?.id
+  });
+
+  const updatedJob = req.body.event.data.new;
+  const bodyshopID = updatedJob.shopid;
+
+  // Emit the job-updated event only to the room corresponding to the bodyshop
+  ioRedis.to(ioHelpers.getBodyshopRoom(bodyshopID)).emit("production-job-updated", updatedJob);
+
+  return res.json({ message: "Job updated and event emitted" });
+};
+
+module.exports = jobUpdated;

server/job/job.js

@@ -14,3 +14,4 @@ exports.costing = require("./job-costing").JobCosting;
 exports.costingmulti = require("./job-costing").JobCostingMulti;
 exports.statustransition = require("./job-status-transition").statustransition;
 exports.lifecycle = require("./job-lifecycle");
+exports.jobUpdated = require("./job-updated");

server/routes/jobRoutes.js

@@ -5,7 +5,7 @@ const ppc = require("../ccc/partspricechange");
 const { partsScan } = require("../parts-scan/parts-scan");
 const eventAuthorizationMiddleware = require("../middleware/eventAuthorizationMIddleware");
 const validateFirebaseIdTokenMiddleware = require("../middleware/validateFirebaseIdTokenMiddleware");
-const { totals, statustransition, totalsSsu, costing, lifecycle, costingmulti } = require("../job/job");
+const { totals, statustransition, totalsSsu, costing, lifecycle, costingmulti, jobUpdated } = require("../job/job");
 const withUserGraphQLClientMiddleware = require("../middleware/withUserGraphQLClientMiddleware");
 
 router.post("/totals", validateFirebaseIdTokenMiddleware, withUserGraphQLClientMiddleware, totals);
@@ -16,5 +16,6 @@ router.post("/lifecycle", validateFirebaseIdTokenMiddleware, withUserGraphQLClie
 router.post("/costingmulti", validateFirebaseIdTokenMiddleware, withUserGraphQLClientMiddleware, costingmulti);
 router.post("/partsscan", validateFirebaseIdTokenMiddleware, withUserGraphQLClientMiddleware, partsScan);
 router.post("/ppc", validateFirebaseIdTokenMiddleware, withUserGraphQLClientMiddleware, ppc.generatePpc);
+router.post("/job-updated", eventAuthorizationMiddleware, jobUpdated);
 
 module.exports = router;

server/utils/ioHelpers.js

@@ -0,0 +1,17 @@
+const applyIOHelpers = (app, api, io, logger) => {
+  const getBodyshopRoom = (bodyshopID) => `bodyshop-broadcast-room:${bodyshopID}`;
+
+  const ioHelpersAPI = {
+    getBodyshopRoom
+  };
+
+  // Helper middleware
+  app.use((req, res, next) => {
+    req.ioHelpers = ioHelpersAPI;
+    next();
+  });
+
+  return ioHelpersAPI;
+};
+
+module.exports = applyIOHelpers;

server/utils/redisHelpers.js

@@ -1,48 +1,71 @@
+const logger = require("./logger");
 /**
  * Apply Redis helper functions
  * @param pubClient
  * @param app
  */
-const applyRedisHelpers = (pubClient, app) => {
+const applyRedisHelpers = (pubClient, app, logger) => {
   // Store session data in Redis
   const setSessionData = async (socketId, key, value) => {
-    await pubClient.hSet(`socket:${socketId}`, key, JSON.stringify(value)); // Use Redis pubClient
+    try {
+      await pubClient.hSet(`socket:${socketId}`, key, JSON.stringify(value)); // Use Redis pubClient
+    } catch (error) {
+      logger.log(`Error Setting Session Data for socket ${socketId}: ${error}`, "ERROR", "redis");
+    }
   };
 
   // Retrieve session data from Redis
   const getSessionData = async (socketId, key) => {
-    const data = await pubClient.hGet(`socket:${socketId}`, key);
-    return data ? JSON.parse(data) : null;
+    try {
+      const data = await pubClient.hGet(`socket:${socketId}`, key);
+      return data ? JSON.parse(data) : null;
+    } catch (error) {
+      logger.log(`Error Getting Session Data for socket ${socketId}: ${error}`, "ERROR", "redis");
+    }
   };
 
   // Clear session data from Redis
   const clearSessionData = async (socketId) => {
-    await pubClient.del(`socket:${socketId}`);
+    try {
+      await pubClient.del(`socket:${socketId}`);
+    } catch (error) {
+      logger.log(`Error Clearing Session Data for socket ${socketId}: ${error}`, "ERROR", "redis");
+    }
   };
 
   // Store multiple session data in Redis
   const setMultipleSessionData = async (socketId, keyValues) => {
-    // keyValues is expected to be an object { key1: value1, key2: value2, ... }
-    const entries = Object.entries(keyValues).map(([key, value]) => [key, JSON.stringify(value)]);
-    await pubClient.hSet(`socket:${socketId}`, ...entries.flat());
+    try {
+      // keyValues is expected to be an object { key1: value1, key2: value2, ... }
+      const entries = Object.entries(keyValues).map(([key, value]) => [key, JSON.stringify(value)]);
+      await pubClient.hSet(`socket:${socketId}`, ...entries.flat());
+    } catch (error) {
+      logger.log(`Error Setting Multiple Session Data for socket ${socketId}: ${error}`, "ERROR", "redis");
+    }
   };
 
   // Retrieve multiple session data from Redis
   const getMultipleSessionData = async (socketId, keys) => {
-    const data = await pubClient.hmGet(`socket:${socketId}`, keys);
-    // Redis returns an object with null values for missing keys, so we parse the non-null ones
-    return Object.fromEntries(keys.map((key, index) => [key, data[index] ? JSON.parse(data[index]) : null]));
+    try {
+      const data = await pubClient.hmGet(`socket:${socketId}`, keys);
+      // Redis returns an object with null values for missing keys, so we parse the non-null ones
+      return Object.fromEntries(keys.map((key, index) => [key, data[index] ? JSON.parse(data[index]) : null]));
+    } catch (error) {
+      logger.log(`Error Getting Multiple Session Data for socket ${socketId}: ${error}`, "ERROR", "redis");
+    }
   };
 
   const setMultipleFromArraySessionData = async (socketId, keyValueArray) => {
-    // Use Redis multi/pipeline to batch the commands
-    const multi = pubClient.multi();
-
-    keyValueArray.forEach(([key, value]) => {
-      multi.hSet(`socket:${socketId}`, key, JSON.stringify(value));
-    });
-
-    await multi.exec(); // Execute all queued commands
+    try {
+      // Use Redis multi/pipeline to batch the commands
+      const multi = pubClient.multi();
+      keyValueArray.forEach(([key, value]) => {
+        multi.hSet(`socket:${socketId}`, key, JSON.stringify(value));
+      });
+      await multi.exec(); // Execute all queued commands
+    } catch (error) {
+      logger.log(`Error Setting Multiple Session Data for socket ${socketId}: ${error}`, "ERROR", "redis");
+    }
   };
 
   // Helper function to add an item to the end of the Redis list
@@ -50,7 +73,7 @@ const applyRedisHelpers = (pubClient, app) => {
     try {
       await pubClient.rPush(`socket:${socketId}:${key}`, JSON.stringify(newItem));
     } catch (error) {
-      console.error(`Error adding item to the end of the list for socket ${socketId}:`, error);
+      logger.log(`Error adding item to the end of the list for socket ${socketId}: ${error}`, "ERROR", "redis");
     }
   };
 
@@ -59,7 +82,7 @@ const applyRedisHelpers = (pubClient, app) => {
     try {
       await pubClient.lPush(`socket:${socketId}:${key}`, JSON.stringify(newItem));
     } catch (error) {
-      console.error(`Error adding item to the beginning of the list for socket ${socketId}:`, error);
+      logger.log(`Error adding item to the beginning of the list for socket ${socketId}: ${error}`, "ERROR", "redis");
     }
   };
 
@@ -68,33 +91,33 @@ const applyRedisHelpers = (pubClient, app) => {
     try {
       await pubClient.del(`socket:${socketId}:${key}`);
     } catch (error) {
-      console.error(`Error clearing list for socket ${socketId}:`, error);
+      logger.log(`Error clearing list for socket ${socketId}: ${error}`, "ERROR", "redis");
     }
   };
 
   // Add methods to manage room users
-  const addUserToRoom = async (bodyshopUUID, user) => {
+  const addUserToRoom = async (room, user) => {
     try {
-      await pubClient.sAdd(`bodyshopRoom:${bodyshopUUID}`, JSON.stringify(user));
-    } catch (err) {
-      console.error(`Error adding user to room: ${bodyshopUUID}`);
+      await pubClient.sAdd(room, JSON.stringify(user));
+    } catch (error) {
+      logger.log(`Error adding user to room ${room}: ${error}`, "ERROR", "redis");
     }
   };
 
-  const removeUserFromRoom = async (bodyshopUUID, user) => {
+  const removeUserFromRoom = async (room, user) => {
     try {
-      await pubClient.sRem(`bodyshopRoom:${bodyshopUUID}`, JSON.stringify(user));
-    } catch (err) {
-      console.error(`Error remove user from room: ${bodyshopUUID}`);
+      await pubClient.sRem(room, JSON.stringify(user));
+    } catch (error) {
+      logger.log(`Error removing user to room ${room}: ${error}`, "ERROR", "redis");
     }
   };
 
-  const getUsersInRoom = async (bodyshopUUID) => {
+  const getUsersInRoom = async (room) => {
     try {
-      const users = await pubClient.sMembers(`bodyshopRoom:${bodyshopUUID}`);
+      const users = await pubClient.sMembers(room);
       return users.map((user) => JSON.parse(user));
-    } catch (err) {
-      console.error(`Error getUsersInRoom: ${bodyshopUUID}`);
+    } catch (error) {
+      logger.log(`Error getting users in room ${room}: ${error}`, "ERROR", "redis");
     }
   };
 

server/web-sockets/redisSocketEvents.js

@@ -11,61 +11,90 @@ function createLogEvent(socket, level, message) {
   logger.log("ioredis-log-event", level, socket.user.email, null, { wsmessage: message });
 }
 
-const redisSocketEvents = (io, { addUserToRoom, getUsersInRoom, removeUserFromRoom }) => {
+const registerUpdateEvents = (socket) => {
+  socket.on("update-token", async (newToken) => {
+    try {
+      socket.user = await admin.auth().verifyIdToken(newToken);
+      createLogEvent(socket, "INFO", "Token updated successfully");
+      socket.emit("token-updated", { success: true });
+    } catch (error) {
+      createLogEvent(socket, "ERROR", `Token update failed: ${error.message}`);
+      socket.emit("token-updated", { success: false, error: error.message });
+      // Optionally disconnect the socket if token verification fails
+      socket.disconnect();
+    }
+  });
+};
+
+const redisSocketEvents = (io, { addUserToRoom, getUsersInRoom, removeUserFromRoom }, { getBodyshopRoom }) => {
   // Room management and broadcasting events
   function registerRoomAndBroadcastEvents(socket) {
     socket.on("join-bodyshop-room", async (bodyshopUUID) => {
-      socket.join(bodyshopUUID);
-      await addUserToRoom(bodyshopUUID, { uid: socket.user.uid, email: socket.user.email });
-      createLogEvent(socket, "DEBUG", `Client joined bodyshop room: ${bodyshopUUID}`);
+      try {
+        const room = getBodyshopRoom(bodyshopUUID);
+        socket.join(room);
+        await addUserToRoom(room, { uid: socket.user.uid, email: socket.user.email, socket: socket.id });
+        createLogEvent(socket, "DEBUG", `Client joined bodyshop room: ${room}`);
 
-      // Notify all users in the room about the updated user list
-      const usersInRoom = await getUsersInRoom(bodyshopUUID);
-      io.to(bodyshopUUID).emit("room-users-updated", usersInRoom);
+        // Notify all users in the room about the updated user list
+        const usersInRoom = await getUsersInRoom(room);
+        io.to(room).emit("room-users-updated", usersInRoom);
+      } catch (error) {
+        createLogEvent(socket, "ERROR", `Error joining room: ${error}`);
+      }
     });
 
     socket.on("leave-bodyshop-room", async (bodyshopUUID) => {
-      socket.leave(bodyshopUUID);
-      createLogEvent(socket, "DEBUG", `Client left bodyshop room: ${bodyshopUUID}`);
+      try {
+        const room = getBodyshopRoom(bodyshopUUID);
+        socket.leave(room);
+        createLogEvent(socket, "DEBUG", `Client left bodyshop room: ${room}`);
+      } catch (error) {
+        createLogEvent(socket, "ERROR", `Error joining room: ${error}`);
+      }
     });
 
     socket.on("get-room-users", async (bodyshopUUID, callback) => {
-      const usersInRoom = await getUsersInRoom(bodyshopUUID);
-      callback(usersInRoom);
+      try {
+        const usersInRoom = await getUsersInRoom(getBodyshopRoom(bodyshopUUID));
+        callback(usersInRoom);
+      } catch (error) {
+        createLogEvent(socket, "ERROR", `Error getting room: ${error}`);
+      }
     });
 
     socket.on("broadcast-to-bodyshop", async (bodyshopUUID, message) => {
-      io.to(bodyshopUUID).emit("bodyshop-message", message);
-      createLogEvent(socket, "INFO", `Broadcast message to bodyshop ${bodyshopUUID}`);
+      try {
+        const room = getBodyshopRoom(bodyshopUUID);
+        io.to(room).emit("bodyshop-message", message);
+        createLogEvent(socket, "INFO", `Broadcast message to bodyshop ${room}`);
+      } catch (error) {
+        createLogEvent(socket, "ERROR", `Error getting room: ${error}`);
+      }
     });
 
     socket.on("disconnect", async () => {
-      createLogEvent(socket, "DEBUG", `User disconnected.`);
+      try {
+        createLogEvent(socket, "DEBUG", `User disconnected.`);
 
-      // Get all rooms the socket is part of
-      const rooms = Array.from(socket.rooms).filter((room) => room !== socket.id);
-
-      for (const bodyshopUUID of rooms) {
-        await removeUserFromRoom(bodyshopUUID, { uid: socket.user.uid, email: socket.user.email });
-
-        // Notify all users in the room about the updated user list
-        const usersInRoom = await getUsersInRoom(bodyshopUUID);
-        io.to(bodyshopUUID).emit("room-users-updated", usersInRoom);
+        // Get all rooms the socket is part of
+        const rooms = Array.from(socket.rooms).filter((room) => room !== socket.id);
+        for (const room of rooms) {
+          await removeUserFromRoom(room, { uid: socket.user.uid, email: socket.user.email, socket: socket.id });
+        }
+      } catch (error) {
+        createLogEvent(socket, "ERROR", `Error getting room: ${error}`);
       }
     });
   }
 
   // Register all socket events for a given socket connection
   function registerSocketEvents(socket) {
-    createLogEvent(socket, "DEBUG", `Connected and Authenticated.`);
+    createLogEvent(socket, "DEBUG", `Registering RedisIO Socket Events.`);
 
     // Register room and broadcasting events
     registerRoomAndBroadcastEvents(socket);
-
-    // Handle socket disconnection
-    socket.on("disconnect", async () => {
-      createLogEvent(socket, "DEBUG", `User disconnected.`);
-    });
+    registerUpdateEvents(socket);
   }
 
   const authMiddleware = (socket, next) => {
@@ -79,7 +108,7 @@ const redisSocketEvents = (io, { addUserToRoom, getUsersInRoom, removeUserFromRo
             next();
           })
           .catch((error) => {
-            next(new Error("Authentication error", JSON.stringify(error)));
+            next(new Error(`Authentication error: ${error.message}`));
           });
       } else {
         next(new Error("Authentication error - no authorization token."));
@@ -87,7 +116,6 @@ const redisSocketEvents = (io, { addUserToRoom, getUsersInRoom, removeUserFromRo
     } catch (error) {
       console.log("Uncaught connection error:::", error);
       logger.log("websocket-connection-error", "error", null, null, {
-        token: socket.handshake.auth.token,
         ...error
       });
       next(new Error(`Authentication error ${error}`));