@os1-platform/dispatch-mobile 3.0.4 → 3.1.1

package/src/manager/syncmanager/document/DocumentSyncManager.ts

@@ -313,7 +313,7 @@ export default class DocumentSyncManager {
         processedPath
       );
     } catch (err: any) {
-      let cta = 'updateDocument-updateDocumentProcessedPath'
+      let cta = 'updateDocument-updateDocumentProcessedPath-Error'
       fireEventWithScreenName({
         severityLevel: SeverityLevelValue.ERROR,
         eventName: SentryEventNameSdkConstants.APP_ERROR,
@@ -364,104 +364,95 @@ export default class DocumentSyncManager {
 
   // This function will generate overlay image and update documents table for processed_file_path columns with overlayed image path.
   private async processImageData(documentRow: DocumentRow) {
+    let extra = {
+      msg: '',
+      fName: documentRow.file_name && documentRow.file_name.length != 0 ? documentRow.file_name.substring(4) : '',
+      dName: documentRow.fms_folder_id && documentRow.fms_folder_id.length != 0 ? documentRow.fms_folder_id.substring(4) : '',
+      dispId: documentRow.dispatch_id && documentRow.dispatch_id.length != 0 ? documentRow.dispatch_id.substring(9) : ''
+    };
     // If processed_file_path of overlayed image already existing then do not generate it again.
     if (
       documentRow.processed_file_path === null ||
       documentRow.processed_file_path === ''
     ) {
-      let cta = 'processImageData-started';
-      let extra = {
-        msg: 'processImageData-started',
-        fName: documentRow.file_name && documentRow.file_name.length != 0 ? documentRow.file_name.substring(4) : '',
-        dName: documentRow.fms_folder_id && documentRow.fms_folder_id.length != 0 ? documentRow.fms_folder_id.substring(4) : '',
-        dispId: documentRow.dispatch_id && documentRow.dispatch_id.length != 0 ? documentRow.dispatch_id.substring(9) : ''
-      };
-      fireEventWithScreenName({
-        severityLevel: SeverityLevelValue.LOG,
-        eventName: SentryEventNameSdkConstants.APP_LOG,
-        screenName: cta,
-        cta: cta,
-        extraParams: extra,
-      });
-      Logger.getInstance().logEvent(
-        cta,
-        flattenObject(extra),
-        LOG_TYPE.SDK_ERROR
-      );
-      let pFilePath = 'processed_' + documentRow.file_name; // File name for processed file.
-      let strGeoStamp = documentRow.geo_timestamp; // Saved geostamp string
-      let objGeoStamp = JSON.parse(strGeoStamp); // Conversion to geostamp object
-      let dateTime = objGeoStamp.dateTime; // Date time stamp in UTC format
-      let lat = objGeoStamp.lat; // Latitide
-      let lng = objGeoStamp.lng; // Longitude
-      let accuracy = objGeoStamp.accuracy; // Location accuracy
-      let strDMS = latlngToDms(`${lat}, ${lng}`); // Location in degree format
-      let strDMSWithAccuracy = strDMS;
-      if (accuracy !== '') {
-        strDMSWithAccuracy = strDMS + ' (Accuracy: ' + accuracy + 'm)'; // Appedning accuracy in location 
-      }
-      let fontSize = 14;
-      if (Platform.OS !== 'android') {
-        fontSize = 28;
-      }
-      const options = {
-        backgroundImage: { // Image for overlay
-          src: documentRow.file_path,
-          scale: 1,
-        },
-        watermarkTexts: [
-          {
-            text: `${dateTime}\n${strDMSWithAccuracy}`,  //Overlay text
-            position: {
-              position: Position.topLeft, // Overlay text position
-            },
-            style: { // Style for overlay
-              color: '#ffffff',
-              fontSize: fontSize,
-              fontName: 'Arial',
-              textBackgroundStyle: {
-                padding: '1% 1%',
-                type: TextBackgroundType.none,
-                color: '#444444CC',
+      try {
+        let cta = 'processImageData-started';
+        extra.msg = cta;
+        Logger.getInstance().logEvent(
+          cta,
+          flattenObject(extra),
+          LOG_TYPE.SDK_ERROR
+        );
+        let pFilePath = 'processed_' + documentRow.file_name; // File name for processed file.
+        let strGeoStamp = documentRow.geo_timestamp; // Saved geostamp string
+        let objGeoStamp = JSON.parse(strGeoStamp); // Conversion to geostamp object
+        let dateTime = objGeoStamp.dateTime; // Date time stamp in UTC format
+        let lat = objGeoStamp.lat; // Latitide
+        let lng = objGeoStamp.lng; // Longitude
+        let accuracy = objGeoStamp.accuracy; // Location accuracy
+        let strDMS = latlngToDms(`${lat}, ${lng}`); // Location in degree format
+        let strDMSWithAccuracy = strDMS;
+        if (accuracy !== '') {
+          strDMSWithAccuracy = strDMS + ' (Accuracy: ' + accuracy + 'm)'; // Appedning accuracy in location 
+        }
+        let fontSize = 14;
+        if (Platform.OS !== 'android') {
+          fontSize = 28;
+        }
+        const options = {
+          backgroundImage: { // Image for overlay
+            src: documentRow.file_path,
+            scale: 1,
+          },
+          watermarkTexts: [
+            {
+              text: `${dateTime}\n${strDMSWithAccuracy}`,  //Overlay text
+              position: {
+                position: Position.topLeft, // Overlay text position
+              },
+              style: { // Style for overlay
+                color: '#ffffff',
+                fontSize: fontSize,
+                fontName: 'Arial',
+                textBackgroundStyle: {
+                  padding: '1% 1%',
+                  type: TextBackgroundType.none,
+                  color: '#444444CC',
+                },
               },
             },
-          },
-        ],
-        scale: 0,
-        quality: 100,
-        filename: pFilePath,
-        saveFormat: ImageFormat.jpg, // Saving in jpeg format
-      };
-      let processedFilePath = await Marker.markText(options); // Generating overlay image
-      if (processedFilePath !== null && processedFilePath !== '') {
-        let completeFilePath = processedFilePath;
-        // If processd image file path does not have prefix file:// then we are addding manually
-        if (!processedFilePath.includes('file')) {
-          completeFilePath = 'file://' + processedFilePath;
+          ],
+          scale: 0,
+          quality: 100,
+          filename: pFilePath,
+          saveFormat: ImageFormat.jpg, // Saving in jpeg format
+        };
+        let processedFilePath = await Marker.markText(options); // Generating overlay image
+        if (processedFilePath !== null && processedFilePath !== '') {
+          let completeFilePath = processedFilePath;
+          // If processd image file path does not have prefix file:// then we are addding manually
+          if (!processedFilePath.includes('file')) {
+            completeFilePath = 'file://' + processedFilePath;
+          }
+          // Updating document document table with overlayed image path
+          this.updateDocumentProcessedPath(
+            documentRow,
+            documentRow.file_path, //original file path catprued from camera
+            completeFilePath // completeFilePath is the path with file:// of processed file 
+          );
+          documentRow.processed_file_path = completeFilePath;
         }
-        // Updating document document table with overlayed image path
+      } catch (error: any) {
         this.updateDocumentProcessedPath(
           documentRow,
           documentRow.file_path, //original file path catprued from camera
-          completeFilePath // completeFilePath is the path with file:// of processed file 
+          documentRow.file_path // completeFilePath is the path with file:// of processed file 
         );
-        documentRow.processed_file_path = completeFilePath;
+        documentRow.processed_file_path = ""
       }
     }
     let cta = 'processImageData-completed';
-    let extra = {
-      msg: 'processImageData-completed',
-      fName: documentRow.file_name && documentRow.file_name.length != 0 ? documentRow.file_name.substring(4) : '',
-      dName: documentRow.fms_folder_id && documentRow.fms_folder_id.length != 0 ? documentRow.fms_folder_id.substring(4) : '',
-      dispId: documentRow.dispatch_id && documentRow.dispatch_id.length != 0 ? documentRow.dispatch_id.substring(9) : ''
-    };
-    fireEventWithScreenName({
-      severityLevel: SeverityLevelValue.LOG,
-      eventName: SentryEventNameSdkConstants.APP_LOG,
-      screenName: cta,
-      cta: cta,
-      extraParams: extra,
-    });
+    extra.msg = cta;
     Logger.getInstance().logEvent(
       cta,
       flattenObject(extra),

package/src/models/sdk.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { EmailAndPhoneResponse } from '../components/executiontasks/validateOTP/ValidateOTPSchema';
 import type { EventCodes } from './ReasonCodes';
 
 export interface DispatchSDKConfig {
@@ -6,6 +8,7 @@ export interface DispatchSDKConfig {
   userName: string;
   tenantBaseURL: string;
   domain: string;
+  validateOtpDomain: string;
   env: ENV;
   headers?: { [key: string]: any };
   enableLogging?: boolean;
@@ -30,6 +33,9 @@ export interface DispatchSDKConfig {
     ) => Promise<{ key: string; value: string[] }>;
     fetchDateTimeCallback?: () => Promise<string>;
     tokenRefreshCallback?: () => Promise<string>;
+    fetchSDSEmailAndPhoneNumbersCallback: (
+      sdsIds: string[]
+    ) => Promise<Record<string, EmailAndPhoneResponse>>;
   };
   etConfig: {
     phoneCode: string;

package/src/ui/screens/ValidateOTPScreen.tsx

@@ -1,13 +1,51 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// External Libraries
 import React, { useEffect, useState } from 'react';
+import { SafeAreaProvider } from 'react-native-safe-area-context';
+
+// SDKs and Platform Libraries
+import { DispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
+
+// Utility and Manager Imports
+import Storage from '../../utils/storage';
+import callbackHandler from '../../manager/sdk/callbacksHandler';
+import Logger, { LOG_TYPE } from '../../utils/Logger';
+import { handleDynamicValues, onTaskStart } from '../../utils/ExecTaskUtils';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import { PROGRESS_GROUP } from '../../utils/Constants';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
 import withBaseDispatchScreen from './WithBaseDispatchScreen';
-import type { BaseETProps } from '../../models/DispatchModels';
+import { BaseETProps } from '../../models/DispatchModels';
+import DispatchSdkCache from '../../manager/sdk/DispatchSdkCache';
+import { DispatchSDKConfig } from '../../models/sdk';
+import Helper from '../../utils/helper';
+
+// Network Client
+import NetworkClient from '../../network/NetworkClient';
+
+// Models and Constants
 import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
-import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
-import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+
+// Components
 import ValidateOTPET from '../../components/executiontasks/validateOTP/ValidateOTPET';
-import { handleDynamicValues, onTaskStart } from '../../utils/ExecTaskUtils';
-import { ScreenNameSdkConstants, SentryEventNameSdkConstants, SeverityLevelValue } from '../../analytics/sentry/SentrySdkConstants';
+import {
+  generateContactList,
+  getUniqueRefId,
+  resetCount,
+} from '../../components/executiontasks/validateOTP/utils';
+import { ContactType } from '../../components/executiontasks/validateOTP/ValidateOTPSchema';
+
+// Analytics
+import {
+  ScreenNameSdkConstants,
+  SentryEventNameSdkConstants,
+  SeverityLevelValue,
+} from '../../analytics/sentry/SentrySdkConstants';
 import { fireEventWithScreenName } from '../../analytics/sentry/SentryAnalyticsUtils';
+import { ValidateOTPContext } from '../../utils/context/valdiateOTPContext';
+
+// Storage
+let storage = Storage.getInstance();
 
 const ValidateOTPScreen = ({
   route,
@@ -18,14 +56,116 @@ const ValidateOTPScreen = ({
   navigation: any;
   baseETProps: BaseETProps;
 }) => {
+  const helperInstance = Helper.getInstance();
   const nextState = route.params[RouteParams.NEXT_STATES];
-  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+  const { taskMeta, mergedObjectiveId, input, wfMeta, taskName } =
     getDataFromNextState(nextState);
   const message = input?.message;
+  const workflowId = mergedObjectiveId[0]?.split('#')[1]?.toString();
+  let _route = JSON.parse(JSON.stringify(route));
   const firstInput = input;
-  const [_input, setInputs] = useState({ ...firstInput });
+  const [_input, setInputs] = useState({
+    ...firstInput,
+    wfMeta,
+    workflowId,
+  });
+  const [contactList, setContactList] = useState<ContactType[] | any[]>([]);
+  // state to store orders data
+  const [orderData, setOrderData] = useState<any>([]);
+  const [contextData, setContextData] = useState<any>();
+  const [isSelfLoopTrue, setSelfLoop] = useState(false);
+
+  async function getSdkConfig() {
+    const cache = DispatchSdkCache.getInstance();
+    const _sdkConfig: DispatchSDKConfig = await cache.getObjectFromCache(
+      DispatchSdkCache.KEYS.SDK_CONFIG
+    );
+
+    const networkInstance = new NetworkClient(
+      _sdkConfig.validateOtpDomain ?? ''
+    );
+    setContextData({ _sdkConfig, networkInstance });
+    return { _sdkConfig, networkInstance };
+  }
+
+  const getSelfLoopBool = async () => {
+    try {
+      const splitArr = mergedObjectiveId[0]?.split('#');
+      const isSelfLoopTrue: boolean = await helperInstance.isSelfLoopExistOnET(splitArr[1], taskName)
+      setSelfLoop(isSelfLoopTrue);
+    } catch (error) {
+      console.log('isSelfLoopTrue code execution error', error);
+    }
+  };
 
   useEffect(() => {
+    // fetch Contact details & mapped contact list
+    const fetchContactDetails = async () => {
+      const rootMetaData = route.params[RouteParams.ROOT_META_DATA];
+      if (!rootMetaData) return; // Exit early if ROOT_META_DATA is not available
+
+      let progressGroup: string | null = null;
+      let reattemptId: number | string | null = null;
+
+      // Fetch the progress group with error handling
+      try {
+        progressGroup = await storage.getSharedItem(PROGRESS_GROUP, false);
+        reattemptId = await DispatchExecutor.getAttemptCountByMoId(
+          mergedObjectiveId[0]
+        );
+        const refId = getUniqueRefId(
+          mergedObjectiveId[0],
+          progressGroup,
+          Number(reattemptId)
+        );
+        setInputs({ ..._input, progressGroup, reattemptId, refId });
+      } catch (error: any) {
+        Logger.getInstance().logEvent(
+          '~ getPaymentStatus triggered ',
+          JSON.stringify(error?.response?.data || error),
+          LOG_TYPE.SDK_ERROR
+        );
+      }
+
+      try {
+        // Get objective task details
+        const { contact } = await DispatchExecutor.getObjectiveTaskDetails(
+          mergedObjectiveId[0],
+          progressGroup,
+          rootMetaData.statusFilter
+        );
+
+        // Fetch contact details and generate contact list
+        const contactDetails = await callbackHandler.getEmailAndPhoneNumbers(
+          contact
+        );
+
+        // Fetch and set order data
+        const data = await DispatchExecutor.filterWFIData(
+          taskName,
+          mergedObjectiveId,
+          100,
+          0
+        );
+        if (data?.data) {
+          setOrderData(data.data);
+        }
+
+        // If valid contact details, generate and set contact list
+        if (contactDetails?.[contact[0]]) {
+          const mappedContacts = generateContactList(
+            contactDetails[contact[0]],
+            data?.data[0]?.displayInfo?.orderId ?? null
+          );
+          setContactList(mappedContacts);
+        }
+      } catch (error) {
+        // Handle any unexpected errors in the process
+        console.error('Error fetching contact details:', error);
+      }
+    };
+
+    // fetch & update dynamic inputs
     onTaskStart(
       route.params[RouteParams.NEXT_STATES],
       route.params[RouteParams.ROOT_META_DATA].customEventsData
@@ -37,36 +177,58 @@ const ValidateOTPScreen = ({
       );
       setInputs(updatedInput);
     }
-  }, []);
-
-  useEffect(() => {
+    //fire sentry event
     (async () => {
-      //fire sentry event
-      fireEventWithScreenName({severityLevel:SeverityLevelValue.LOG, eventName:SentryEventNameSdkConstants.VERIFY_OTP_ET_OPENED, screenName:ScreenNameSdkConstants.VERIFY_OTP_ET_SCREEN});
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.LOG,
+        eventName: SentryEventNameSdkConstants.VERIFY_OTP_ET_OPENED,
+        screenName: ScreenNameSdkConstants.VERIFY_OTP_ET_SCREEN,
+      });
+      //get SDK config
+      await getSdkConfig();
+      //get self loop boolean
+      await getSelfLoopBool();
     })();
-  }, []);
 
+    fetchContactDetails();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
 
   return (
-    <ValidateOTPET
-      {..._input}
-      mergedObjectiveId={mergedObjectiveId}
-      taskMeta={taskMeta}
-      message={message}
-      navigation={navigation}
-      onSubmitET={async (validateOtpOutput) => {
-        await DispatchStateContainer.getInstance().navigateToNextTask(
-          navigation,
-          route,
-          validateOtpOutput,
-          validateOtpOutput.success,
-          EntityCode.VALIDATE_OTP_ET,
-          ExecutionTaskID.VALIDATE_OTP_ET,
-          baseETProps,
-          false
-        );
-      }}
-    />
+    <SafeAreaProvider>
+      <ValidateOTPContext.Provider
+        value={{
+          sdkConfig: contextData?._sdkConfig,
+          networkInstance: contextData?.networkInstance,
+        }}
+      >
+        <ValidateOTPET
+          {..._input}
+          route={route}
+          isSelfLoop={isSelfLoopTrue}
+          mergedObjectiveId={mergedObjectiveId}
+          workflowId={workflowId}
+          taskMeta={taskMeta}
+          message={message}
+          contacts={contactList || []}
+          orderData={orderData}
+          navigation={navigation}
+          onSubmitET={async (validateOtpOutput) => {
+            await DispatchStateContainer.getInstance().navigateToNextTask(
+              navigation,
+              _route,
+              validateOtpOutput,
+              validateOtpOutput.success,
+              EntityCode.VALIDATE_OTP_ET,
+              ExecutionTaskID.VALIDATE_OTP_ET,
+              baseETProps,
+              false
+            );
+            await resetCount();
+          }}
+        />
+      </ValidateOTPContext.Provider>
+    </SafeAreaProvider>
   );
 };
 export default withBaseDispatchScreen(ValidateOTPScreen);

package/src/utils/ApiUtils.ts

@@ -1,6 +1,9 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import axios, { AxiosRequestConfig } from 'axios';
 import { API_CONFIG } from '../constants/apiConstants';
 import { getHeaders } from '../network/NetworkUtils';
+import { RouteParams } from '../ui/uiConfig/RouteParams';
+import { parseRequestBody } from './ExecTaskUtils';
 
 export type HTTPMethod = 'PUT' | 'POST' | 'GET';
 export type HeaderKey = string;
@@ -49,8 +52,10 @@ export interface APIData {
   requestBody?: HTTPRequestBody;
   queryParams?: QueryParams[];
   pathParams?: PathParams[];
-  responseJsonPath: string;
-  errorJsonPath: string;
+  responseJsonPath: string | object;
+  errorJsonPath: string | object;
+  errorJsonLogic?: object | string;
+  responseJsonLogic?: object | string;
 }
 
 export interface KeyValueArray {
@@ -119,11 +124,134 @@ export async function getApiResponse(apiData: APIData) {
   if (apiData.requestBody) {
     axiosConfig.data = { ...apiData.requestBody };
   }
-  // console.log('axiosConfig: ', JSON.stringify(axiosConfig));
+  console.log('axiosConfig: ', JSON.stringify(axiosConfig));
 
   return axios(axiosConfig);
 }
 
+// new
+export async function getAxiosApiResponse(apiData: APIData) {
+  let axiosConfig: AxiosRequestConfig = {
+    method: apiData.httpMethod,
+    timeout: apiData.timeout ?? API_CONFIG.timeout, // timeout in millis i.e 15s
+    url: apiData.uri,
+    headers: {
+      ...getAddHeaders(apiData.headers),
+      ...(await getHeaders('application/json')),
+    },
+  };
+
+  // Handle path parameters
+  if (apiData.pathParams) {
+    const params = apiData.pathParams;
+    params.forEach((param) => {
+      apiData.uri = apiData.uri.replace(`{${param.key}}`, param.value);
+    });
+    axiosConfig.url = apiData.uri;
+  }
+
+  // Handle query parameters
+  if (apiData.queryParams) {
+    axiosConfig.params = { ...getQueryParams(apiData.queryParams) };
+  }
+
+  // Handle request body
+  if (apiData.requestBody) {
+    axiosConfig.data = { ...apiData.requestBody };
+  }
+
+  console.log('axiosConfig: ', JSON.stringify(axiosConfig));
+
+  try {
+    // Make the API call
+    const response = await axios(axiosConfig);
+    return response;
+  } catch (error: any) {
+    console.error('API Error:', error);
+
+    let customError = {
+      ...error,
+      data: {
+        message: error?.response?.data?.message,
+        additionalInfo: error?.response?.data?.additionalInfo,
+        status: error?.response?.data?.status,
+      },
+    };
+
+    // console.log('Formatted Error:', customError);
+    // Throw the custom error for the caller to handle
+    throw customError;
+  }
+}
+
+// To generate an common payload for APIS as per config
+export const createApiData = (
+  payload: any,
+  props: any,
+  endpoint: string,
+  httpMethod: HTTPMethod,
+  headers: Headers[] | null,
+  customApiConfig?: Partial<APIData>
+): APIData => {
+  const baseApiData: APIData = {
+    errorJsonPath: '',
+    responseJsonPath: '',
+    uri: endpoint,
+    httpMethod: httpMethod ?? 'POST',
+    timeout: 15000,
+    headers: headers ?? [],
+    responseJsonLogic: '',
+    errorJsonLogic: '',
+    requestBody: payload,
+    pathParams: [{ key: 'baseURI', value: props.domain }],
+  };
+
+  if (customApiConfig) {
+    Object.assign(baseApiData, {
+      httpMethod: customApiConfig.httpMethod ?? baseApiData.httpMethod,
+      timeout: customApiConfig.timeout ?? baseApiData.timeout,
+      headers: customApiConfig.headers ?? baseApiData.headers,
+      responseJsonLogic: customApiConfig.responseJsonLogic,
+      errorJsonLogic: customApiConfig.errorJsonLogic,
+      errorJsonPath: customApiConfig.errorJsonPath ?? baseApiData.errorJsonPath,
+      responseJsonPath:
+        customApiConfig.responseJsonPath ?? baseApiData.responseJsonPath,
+    });
+
+    if (customApiConfig.requestBody) {
+      const inputMeta =
+        props?.route?.params[RouteParams.NEXT_STATES]?.meta?.task;
+      const parsedInputMeta = inputMeta ? JSON.parse(inputMeta) : {};
+      console.log('parsedInputMeta', parsedInputMeta);
+
+      const metaData = {
+        meta: { task: parsedInputMeta },
+      };
+      const updatedPayload = {
+        ...payload,
+        ...metaData,
+      };
+      console.log('updatedPayload', updatedPayload);
+      baseApiData.requestBody = parseRequestBody(
+        customApiConfig.requestBody,
+        updatedPayload
+      );
+
+      console.log('baseApiData.requestBody', baseApiData.requestBody);
+    }
+    if (customApiConfig.pathParams) {
+      baseApiData.pathParams = customApiConfig.pathParams;
+    }
+    if (customApiConfig.queryParams) {
+      baseApiData.queryParams = customApiConfig.queryParams;
+    }
+  }
+
+  console.log('baseApiData', baseApiData);
+
+  return baseApiData;
+};
+
 export function parseBody(body: any, userInput: any) {
   const requestBody = JSON.parse(JSON.stringify(body));
   for (const key in requestBody) {