@os1-platform/dispatch-mobile 3.0.4 → 3.1.1

package/src/utils/ExecTaskUtils.ts

@@ -32,7 +32,7 @@ export async function getBaseETResponse(
   const startLocation = await cache.getObjectFromCache(
     DispatchSdkCache.KEYS.TASK_START_LOCATION
   );
-  console.log("getBaseETResponse:startLocation:",startLocation);
+  console.log('getBaseETResponse:startLocation:', startLocation);
   let baseResponse: BaseETResponse = {
     entityCode: entityCode,
     success: success,
@@ -40,13 +40,13 @@ export async function getBaseETResponse(
     reasonCode: reasonCode,
     id: taskId,
     meta: {
-      startLocation:{
-        latitude:startLocation.latitude,
-        longitude:startLocation.longitude
+      startLocation: {
+        latitude: startLocation.latitude,
+        longitude: startLocation.longitude,
       },
-      endLocation:{
-        latitude:lastLocation.latitude,
-        longitude:lastLocation.longitude
+      endLocation: {
+        latitude: lastLocation.latitude,
+        longitude: lastLocation.longitude,
       },
       // location: {
       //   latitude: location.latitude,
@@ -61,7 +61,7 @@ export async function getBaseETResponse(
     },
     mergedObjectiveIds,
   };
-  console.log("getBaseETResponse:baseResponse:",JSON.stringify(baseResponse));
+  console.log('getBaseETResponse:baseResponse:', JSON.stringify(baseResponse));
 
   return baseResponse;
 }
@@ -155,8 +155,6 @@ export function onTaskStart(
     await cache.setKeyInCache(keys.TASK_START_TIME, Date.now().toString());
     await cache.setKeyInCache(keys.CURRENT_WORKING_TASK_ID, eventData.taskId);
     await cache.setObjectInCache(keys.TASK_START_LOCATION, location);
-
-
   })();
   if (triggerEvent) {
     const customEtName = eventData.taskName;
@@ -269,13 +267,77 @@ export function handleDynamicValues(jsonInput: any, dataBlob: any) {
   return jsonInput;
 }
 
+export function parseRequestBody(body: any, userInput: any) {
+  const requestBody = JSON.parse(JSON.stringify(body)); //  Deep clone the input
+
+  // Preprocess `userInput` placeholders before calling handleDynamicValues
+  const preprocessUserInput = (jsonInput: any) => {
+    for (const key in jsonInput) {
+      if (Object.prototype.hasOwnProperty.call(jsonInput, key)) {
+        const value = jsonInput[key];
+
+        if (typeof value === 'string' && value.includes('{{$.userInput}}')) {
+          // Replace `{{$.userInput}}` with the OTP value from userInput
+          jsonInput[key] = userInput.otp || value;
+        } else if (typeof value === 'object' && value !== null) {
+          // Recursively preprocess nested objects
+          preprocessUserInput(value);
+        } else if (Array.isArray(value)) {
+          // Recursively preprocess arrays
+          jsonInput[key] = value.map((item) => {
+            if (typeof item === 'string' && item.includes('{{$.userInput}}')) {
+              return userInput.otp || userInput.input || item;
+            } else if (
+              typeof item === 'string' &&
+              item.includes('{{$.inputs.userInput}}')
+            ) {
+              return userInput.input || item;
+            } else if (typeof item === 'object' && item !== null) {
+              preprocessUserInput(item);
+              return item;
+            }
+            return item;
+          });
+        }
+      }
+    }
+    return jsonInput;
+  };
+
+  // Step 1: Preprocess the body for `{{$.userInput}}`
+  const preprocessedBody = preprocessUserInput(requestBody);
+
+  // Step 2: Pass the preprocessed body to `handleDynamicValues`
+  const resolvedBody = handleDynamicValues(preprocessedBody, userInput);
+
+  return resolvedBody;
+}
+
+// old masking
+// export const maskContact = (contact: string) => {
+//   if (contact && contact?.includes('@')) {
+//     const [name, domain] = contact.split('@');
+//     const maskedName = name.substring(0, 3) + '****';
+//     const maskedEmail = maskedName + '@' + domain;
+//     return maskedEmail;
+//   } else {
+//     return `${contact && contact.slice(0, 2)}****${contact.slice(-4)}`;
+//   }
+// };
 export const maskContact = (contact: string) => {
-  if (contact.includes('@')) {
+  if (contact && contact.includes('@')) {
     const [name, domain] = contact.split('@');
-    const maskedName = name.substring(0, 3) + '****';
-    const maskedEmail = maskedName + '@' + domain;
-    return maskedEmail;
+    let maskedName;
+    if (name.length <= 2) {
+      maskedName = name.substring(0, 1) + '*****';
+    } else {
+      maskedName = name.substring(0, 2) + '*****';
+    }
+    return maskedName + '@' + domain;
   } else {
-    return `${contact.slice(0, 2)}****${contact.slice(-4)}`;
+    const visibleDigits = 4;
+    const maskedPart = '*'.repeat(Math.max(contact.length - visibleDigits, 0));
+    const visiblePart = contact.slice(-visibleDigits);
+    return maskedPart + visiblePart;
   }
 };

package/src/utils/context/valdiateOTPContext.ts

@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { createContext } from 'react';
+import { DispatchSDKConfig } from '../../models/sdk';
+import NetworkClient from '../../network/NetworkClient';
+
+export const ValidateOTPContext = createContext<{
+  sdkConfig: DispatchSDKConfig;
+  networkInstance: NetworkClient;
+} | null>(null);

package/src/utils/helper.ts

@@ -1,6 +1,5 @@
 import Network from '../resources/network';
 import { DispatchExecutor as dispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
-import ETTransition from '@os1-platform/platform-coreos-execution-engine-sdk/';
 
 /**
  *

package/src/utils/hooks/useTimer.ts

@@ -1,44 +1,102 @@
-import { useEffect, useState } from 'react';
-
-const useTimer = (props: {
-  initialMinute: number;
-  initialSeconds: number;
-}): [string | null, () => void] => {
-  const { initialMinute = 0, initialSeconds = 0 } = props;
-  const [minutes, setMinutes] = useState(initialMinute);
-  const [seconds, setSeconds] = useState(initialSeconds);
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { AppState, AppStateStatus } from 'react-native';
+
+// Function to format the expiry time (without showing '0 sec' when it's unnecessary)
+export const formatExpiryTime = (timeInSeconds: number) => {
+  const minutes = Math.floor(timeInSeconds / 60);
+  const seconds = timeInSeconds % 60;
+
+  if (minutes > 0 && seconds > 0) {
+    return `${minutes} min ${seconds} sec`;
+  } else if (minutes > 0 && seconds === 0) {
+    return `${minutes} min`;
+  } else {
+    return `${seconds} sec`;
+  }
+};
+
+const useResendOtpTimer = (
+  initialTimerValue: number,
+  onTimerEnd?: () => void
+) => {
+  const [timer, setTimer] = useState(initialTimerValue);
+  const appState = useRef(AppState.currentState);
+  const initialTimeRef = useRef(Date.now());
+
+  const resetTimer = useCallback(() => {
+    initialTimeRef.current = Date.now();
+    setTimer(initialTimerValue);
+  }, [initialTimerValue]);
+
+  const updateTimer = useCallback(() => {
+    const currentTime = Date.now();
+    const elapsedTimeInSeconds = Math.floor(
+      (currentTime - initialTimeRef.current) / 1000
+    );
+    const remainingTime = Math.max(0, initialTimerValue - elapsedTimeInSeconds);
+
+    if (remainingTime !== timer) {
+      setTimer(remainingTime);
+    }
+
+    if (remainingTime === 0 && onTimerEnd) {
+      onTimerEnd();
+    }
+  }, [initialTimerValue, onTimerEnd, timer]);
+
   useEffect(() => {
-    let myInterval = setInterval(() => {
-      if (seconds > 0) {
-        setSeconds(seconds - 1);
-      }
-      if (seconds === 0) {
-        if (minutes === 0) {
-          clearInterval(myInterval);
-        } else {
-          setMinutes(minutes - 1);
-          setSeconds(59);
-        }
+    resetTimer();
+  }, [initialTimerValue, resetTimer]);
+
+  useEffect(() => {
+    // Update the timer immediately on mount
+    updateTimer();
+    const intervalId = setInterval(updateTimer, 1000);
+    return () => clearInterval(intervalId);
+  }, [updateTimer]);
+
+  useEffect(() => {
+    const handleAppStateChange = (nextAppState: AppStateStatus) => {
+      if (
+        appState.current.match(/inactive|background/) &&
+        nextAppState === 'active'
+      ) {
+        // Calculate elapsed time and adjust the initial time reference
+        const currentTime = Date.now();
+        const elapsedTimeInSeconds = Math.floor(
+          (currentTime - initialTimeRef.current) / 1000
+        );
+        const newRemainingTime = Math.max(
+          0,
+          initialTimerValue - elapsedTimeInSeconds
+        );
+
+        // Update initial time ref based on new remaining time
+        initialTimeRef.current =
+          currentTime - (initialTimerValue - newRemainingTime) * 1000;
+
+        // Update the timer
+        setTimer(newRemainingTime);
+        updateTimer();
       }
-    }, 1000);
+      appState.current = nextAppState;
+    };
+
+    const subscription = AppState.addEventListener(
+      'change',
+      handleAppStateChange
+    );
     return () => {
-      clearInterval(myInterval);
+      subscription.remove();
     };
-  });
+  }, [updateTimer, initialTimerValue]);
 
-  const resetTimer = () => {
-    if (!minutes && !seconds) {
-      setMinutes(initialMinute);
-      setSeconds(initialSeconds);
-    }
+  return {
+    formattedTime: formatExpiryTime(timer),
+    timer: timer,
+    resetTimer,
   };
-
-  const timer =
-    minutes === 0 && seconds === 0
-      ? null
-      : `${minutes}: ${seconds < 10 ? `0${seconds}` : seconds}`;
-
-  return [timer, resetTimer];
 };
 
-export default useTimer;
+export default useResendOtpTimer;