@os1-platform/dispatch-mobile 2.1.2 → 2.1.4

package/src/utils/SyncManagerUtils.ts

@@ -0,0 +1,223 @@
+import EventsSyncManager from '../manager/syncmanager/events/EventsSyncManager';
+import { IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
+const SyncType = IDispatch.SyncType;
+import Logger, { LOG_TYPE } from './Logger';
+import DispatchSdkCache from '../manager/sdk/DispatchSdkCache';
+import DocumentSyncManager from '../manager/syncmanager/document/DocumentSyncManager';
+import { isEmptyOrBlank } from './utils';
+import { BaseError } from '../errors/BaseError';
+import ErrorCodes from '../errors/ErrorCodes';
+import GraphQLClient from '../network/GraphQLClient';
+import AppSyncManager from '../manager/syncmanager/AppSyncManager';
+import type {
+  BulkEvent,
+  ExecEngineSyncType,
+} from '../manager/syncmanager/DBConfig';
+import Storage from './storage';
+
+const keys = DispatchSdkCache.KEYS;
+const cache = DispatchSdkCache.getInstance();
+
+const TAG = 'SaveEventDB';
+
+export async function pushEventForSync(
+  syncType: ExecEngineSyncType,
+  dspID: string,
+  data: string,
+  config: any,
+  sequence: number,
+  meta?: any
+): Promise<boolean> {
+  try {
+    await EventsSyncManager.getInstance().insertEvent(
+      sequence,
+      data,
+      dspID,
+      syncType,
+      meta ? meta.jobId + meta.objectiveReference : 'NO_REF_FOUND',
+      JSON.stringify(config)
+    );
+
+    /* Logger.getInstance().logEvent(
+      TAG,
+      `Event Inserted ${syncType} ${JSON.stringify(data)}`,
+      LOG_TYPE.SDK_ERROR
+    ); */
+    AppSyncManager.getInstance().startSDKSyncManager();
+    return true;
+  } catch (error: any) {
+    Logger.getInstance().logEvent(
+      'pushEventForSync ' + syncType,
+      JSON.stringify({
+        errorMessage: error.message,
+        data: `Event Inserted ${syncType} ${JSON.stringify(data)}`,
+        dspID: dspID,
+        config: config,
+        meta: meta,
+      }),
+      LOG_TYPE.SDK_ERROR
+    );
+    return false;
+  }
+}
+
+// NEW CODE
+export async function pushBulkEventForSync(
+  pushData: BulkEvent
+): Promise<boolean> {
+  try {
+    await EventsSyncManager.getInstance().insertBulkEvent(pushData);
+
+    AppSyncManager.getInstance().startSDKSyncManager();
+    return true;
+  } catch (error: any) {
+    Logger.getInstance().logEvent(
+      'pushEventForSync ',
+      JSON.stringify({
+        errorMessage: error.message,
+      }),
+      LOG_TYPE.SDK_ERROR
+    );
+    return false;
+  }
+}
+
+// OLD CODE
+// export async function pushBulkEventForSync(
+//   pushData: BulkEvent[]
+// ): Promise<boolean> {
+//   try {
+//     await EventsSyncManager.getInstance().insertBulkEvent(pushData);
+
+//     AppSyncManager.getInstance().startSDKSyncManager();
+//     return true;
+//   } catch (error: any) {
+//     Logger.getInstance().logEvent(
+//       'pushEventForSync ',
+//       JSON.stringify({
+//         errorMessage: error.message,
+//       }),
+//       LOG_TYPE.SDK_ERROR
+//     );
+//     return false;
+//   }
+// }
+
+/**
+ * clears synced events from Sync & Document manager
+ * @param dspID
+ * @private
+ */
+export async function clearCache(dspID: string) {
+  try {
+    let prevDspID = await cache.getKeyFromCache(keys.DISPATCH_ID);
+    if (prevDspID != null && prevDspID !== dspID) {
+      DocumentSyncManager.getInstance()
+        .clearSyncedDocs(prevDspID)
+        .then()
+        .catch();
+      EventsSyncManager.getInstance().clearEventsDB().then().catch();
+      await Storage.getInstance().clearShared();
+    }
+  } catch (error: any) {
+    Logger.getInstance().logEvent(
+      'clearCache',
+      error.message,
+      LOG_TYPE.SDK_WARNING
+    );
+  }
+}
+
+export async function insertDocumentInDB(
+  fileName: string,
+  fmsFolderName: string,
+  // jobID: string,
+  // objRef: string,
+  base64Image: string | null,
+  imageDesc: string,
+  filePath: string | null
+): Promise<number | undefined> {
+  try {
+    const dspID = await cache.getKeyFromCache(keys.DISPATCH_ID);
+    let response = await DocumentSyncManager.getInstance().insertDocument(
+      fmsFolderName,
+      base64Image,
+      base64Image != null,
+      imageDesc,
+      dspID ?? 'NULL',
+      // jobID,
+      // objRef,
+      filePath,
+      'image',
+      fileName
+    );
+    AppSyncManager.getInstance().startSDKSyncManager();
+    return response.insertId;
+  } catch (error: any) {
+    Logger.getInstance().logEvent(
+      'insertDocumentInDB',
+      error.message,
+      LOG_TYPE.SDK_ERROR
+    );
+    return undefined;
+  }
+}
+
+export async function createFmsFolder(dispatchID: string) {
+  const folderName = `dsp_${new Date()
+    .toISOString()
+    .slice(0, 10)
+    .split('-')
+    .join('')}`;
+  let fmsFolder = await cache.getKeyFromCache(keys.FMS_FOLDER);
+  const dspID = await cache.getKeyFromCache(keys.DISPATCH_ID);
+  if (!isEmptyOrBlank(fmsFolder) && dspID != null && dspID === dispatchID) {
+    return;
+  } else {
+    try {
+      const response = await GraphQLClient.getInstance().createFmsFolder(
+        folderName,
+        `${dispatchID}`
+      );
+      if (!isEmptyOrBlank(response?.data?.createFolder?.id)) {
+        Logger.getInstance().logEvent(
+          'createFmsFolder',
+          'Folder creation success!',
+          LOG_TYPE.SDK_INFO
+        );
+        await cache.setKeyInCache(keys.FMS_FOLDER, folderName);
+      } else {
+        /* Logger.getInstance().logEvent(
+          'createFmsFolder',
+          JSON.stringify(response?.data),
+          LOG_TYPE.SDK_ERROR
+        ); */
+        throw new BaseError(
+          ErrorCodes.FMS_FOLDER_CREATION_ERROR,
+          JSON.stringify(response?.data)
+        );
+      }
+    } catch (error: any) {
+      if (
+        error &&
+        error.graphQLErrors &&
+        error.graphQLErrors.length > 0 &&
+        error.graphQLErrors[0]?.code === '100010213009'
+      ) {
+        await cache.setKeyInCache(keys.FMS_FOLDER, folderName);
+        Logger.getInstance().logEvent(
+          'createFmsFolder',
+          'Folder already exists',
+          LOG_TYPE.SDK_INFO
+        );
+      } else {
+        Logger.getInstance().logEvent(
+          'createFmsFolder',
+          error.message,
+          LOG_TYPE.SDK_ERROR
+        );
+        throw new BaseError(ErrorCodes.FMS_GRAPHQL_API_ERROR, error.message);
+      }
+    }
+  }
+}

package/src/utils/fcm/FCM.ts

@@ -0,0 +1,118 @@
+import { Component } from 'react';
+import messaging from '@react-native-firebase/messaging';
+import Logger, { LOG_TYPE } from '../Logger';
+import DispatchSdkCache from '../../manager/sdk/DispatchSdkCache';
+// import JobRemovalManager from '../../manager/jobRemoval/JobRemovalManager';
+
+const cache = DispatchSdkCache.getInstance();
+// const jobRemoval = JobRemovalManager.getInstance();
+
+abstract class FCM extends Component<any, any> {
+  protected constructor(props: any) {
+    super(props);
+    messaging().onTokenRefresh((token) => {
+      Logger.getInstance().logEvent('FCM token refresh', '', LOG_TYPE.SDK_INFO);
+      cache
+        .setKeyInCache(DispatchSdkCache.KEYS.FIREBASE_REGISTRATION_TOKEN, token)
+        .then();
+    });
+  }
+
+  componentDidMount() {
+    messaging().onMessage(async (remoteMessage) => {
+      Logger.getInstance().logEvent(
+        'Message arrived at foreground state',
+        JSON.stringify(remoteMessage),
+        LOG_TYPE.SDK_INFO
+      );
+
+      // TODO: Need to implement via execution-engine-sdk
+      // if (remoteMessage?.data?.type == 'JOB_REMOVAL') {
+      //   try {
+      //     const result = await jobRemoval.handleRemoval(
+      //       remoteMessage?.data?.dispatchId,
+      //       JSON.parse(remoteMessage?.data?.jobIds)
+      //     );
+      //     if (!result.success.length) return;
+      //     else remoteMessage.data.jobIds = JSON.stringify(result.success);
+      //   } catch (error: any) {
+      //     Logger.getInstance().logEvent(
+      //       'handle Job Removal: ',
+      //       error.message,
+      //       LOG_TYPE.SDK_ERROR
+      //     );
+      //     return;
+      //   }
+      // }
+
+      this.handleFcmMessage(remoteMessage);
+    });
+
+    messaging().onNotificationOpenedApp(async (remoteMessage) => {
+      Logger.getInstance().logEvent(
+        'Notification Arrived',
+        JSON.stringify(remoteMessage),
+        LOG_TYPE.SDK_INFO
+      );
+
+      // TODO: Need to implement via execution-engine-sdk
+      // if (remoteMessage?.data?.type == 'JOB_REMOVAL') {
+      //   try {
+      //     const result = await jobRemoval.handleRemoval(
+      //       remoteMessage?.data?.dispatchId,
+      //       JSON.parse(remoteMessage?.data?.jobIds)
+      //     );
+      //     if (!result.success.length) return;
+      //     else remoteMessage.data.jobIds = JSON.stringify(result.success);
+      //   } catch (error: any) {
+      //     Logger.getInstance().logEvent(
+      //       'handle Job Removal: ',
+      //       error.message,
+      //       LOG_TYPE.SDK_ERROR
+      //     );
+      //     return;
+      //   }
+      // }
+
+      this.handleNotification(remoteMessage);
+    });
+
+    messaging()
+      .getInitialNotification()
+      .then(async (remoteMessage) => {
+        if (remoteMessage) {
+          Logger.getInstance().logEvent(
+            'Notification Arrived',
+            JSON.stringify(remoteMessage),
+            LOG_TYPE.SDK_INFO
+          );
+
+          // TODO: Need to implement via execution-engine-sdk
+          // if (remoteMessage?.data?.type == 'JOB_REMOVAL') {
+          //   try {
+          //     const result = await jobRemoval.handleRemoval(
+          //       remoteMessage?.data?.dispatchId,
+          //       JSON.parse(remoteMessage?.data?.jobIds)
+          //     );
+          //     if (!result.success.length) return;
+          //     else remoteMessage.data.jobIds = JSON.stringify(result.success);
+          //   } catch (error: any) {
+          //     Logger.getInstance().logEvent(
+          //       'handle Job Removal: ',
+          //       error.message,
+          //       LOG_TYPE.SDK_ERROR
+          //     );
+          //     return;
+          //   }
+          // }
+
+          this.handleNotification(remoteMessage);
+        }
+      });
+  }
+
+  abstract handleFcmMessage(remoteMessage: object): void;
+  abstract handleNotification(remoteMessage: object): void;
+}
+
+export default FCM;

package/src/utils/fcm/FcmUtils.ts

@@ -0,0 +1,130 @@
+import { useEffect, useState } from 'react';
+import messaging from '@react-native-firebase/messaging';
+import Logger, { LOG_TYPE } from '../Logger';
+import type { messageReceived, tokenRefreshed } from '../../models/fcm';
+import DispatchSdkCache from '../../manager/sdk/DispatchSdkCache';
+// import JobRemovalManager from '../../manager/jobRemoval/JobRemovalManager';
+
+const cache = DispatchSdkCache.getInstance();
+// const jobRemoval = JobRemovalManager.getInstance();
+
+export default function useFCMMessage() {
+  const [message, setMessage] = useState<any>(null);
+  useEffect(() => {
+    messaging().onTokenRefresh((token) => {
+      Logger.getInstance().logEvent(
+        'FCM Token Refreshed',
+        token,
+        LOG_TYPE.SDK_INFO
+      );
+      cache
+        .setKeyInCache(DispatchSdkCache.KEYS.FIREBASE_REGISTRATION_TOKEN, token)
+        .then()
+        .catch((err) =>
+          Logger.getInstance().logEvent(
+            'FCM_ERROR',
+            err.message,
+            LOG_TYPE.SDK_ERROR
+          )
+        );
+    });
+    const unsubscribe = messaging().onMessage(async (remoteMessage) => {
+      Logger.getInstance().logEvent(
+        '(hook) Message arrived at foreground state',
+        JSON.stringify(remoteMessage),
+        LOG_TYPE.SDK_INFO
+      );
+
+      setMessage(remoteMessage);
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, []);
+  return message;
+}
+
+export async function requestFirebasePermissions() {
+  const authStatus = await messaging().requestPermission();
+  return (
+    authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
+    authStatus === messaging.AuthorizationStatus.PROVISIONAL
+  );
+}
+
+export async function getFCMToken(): Promise<string | null> {
+  try {
+    let token = await cache.getKeyFromCache(
+      DispatchSdkCache.KEYS.FIREBASE_REGISTRATION_TOKEN
+    );
+    if (!token) {
+      return await generateFCMToken();
+    } else return token;
+  } catch (err: any) {
+    Logger.getInstance().logEvent(
+      'getFCMToken',
+      err.message,
+      LOG_TYPE.SDK_ERROR
+    );
+    return null;
+  }
+}
+
+async function generateFCMToken(): Promise<string | null> {
+  try {
+    let token = await messaging().getToken();
+    await cache.setKeyInCache(
+      DispatchSdkCache.KEYS.FIREBASE_REGISTRATION_TOKEN,
+      token
+    );
+    return token;
+  } catch (err: any) {
+    Logger.getInstance().logEvent(
+      'generateFCMToken',
+      err.message,
+      LOG_TYPE.SDK_ERROR
+    );
+    return null;
+  }
+}
+export function registerBackgroundHandler(callback: messageReceived) {
+  messaging().setBackgroundMessageHandler(async (remoteMessage) => {
+    Logger.getInstance().logEvent('setBackgroundMessageHandler Message arrived ',
+      JSON.stringify(remoteMessage), LOG_TYPE.SDK_INFO);
+    callback(remoteMessage);
+  });
+}
+
+export function onNotificationOpenedApp(callback: messageReceived) {
+  messaging().onNotificationOpenedApp(
+    async (remoteMessage) => {
+      Logger.getInstance().logEvent('onNotificationOpenedApp Notification Arrived',
+        JSON.stringify(remoteMessage), LOG_TYPE.SDK_INFO);
+      callback(remoteMessage);
+    }
+  );
+}
+
+export function getInitialNotification(callback: messageReceived) {
+  messaging().getInitialNotification().then(async (remoteMessage) => {
+    if (remoteMessage) {
+      Logger.getInstance().logEvent('getInitialNotification Notification Arrived',
+        JSON.stringify(remoteMessage), LOG_TYPE.SDK_INFO);
+      callback(remoteMessage);
+    }
+  });
+}
+
+export function onTokenRefresh(callback: tokenRefreshed) {
+  messaging().onTokenRefresh(
+    async (token) => {
+      await cache.setKeyInCache(
+        DispatchSdkCache.KEYS.FIREBASE_REGISTRATION_TOKEN,
+        token
+      );
+      Logger.getInstance().logEvent('onTokenRefresh Called',
+      token, LOG_TYPE.SDK_INFO);
+      callback(token);
+    }
+  );
+}

package/src/utils/helper.ts

@@ -0,0 +1,67 @@
+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/';
+
+/**
+ *
+ * @class Helper
+ */
+export default class Helper {
+
+  private static instance: Helper;
+
+
+  public static getInstance(): Helper {
+    if (!Helper.instance) {
+      Helper.instance = new Helper();
+    }
+    return Helper.instance;
+  }
+
+  /**
+   * Check the availability of a network for an app.
+   *
+   * @returns {Promise<boolean>}
+   */
+  async checkNetwork(): Promise<boolean> {
+    try {
+      await Network.heartBeat();
+      return true;
+    } catch (e: any) {
+      // console.log('checkNetwork catch', e);
+      return false;
+    }
+  }
+
+
+  async isSelfLoopExistOnET(workflowId: string,
+    sourceTaskName: string): Promise<boolean> {
+    try {
+      console.log("isSelfLoopExistOnET::sourceTaskName => ", sourceTaskName)
+      //
+      let isSelfLoopExist: boolean = false;
+      const dummyETTransitionObj = [{ sourceTaskName: "", targetTaskName: "", condition: "" }]
+      const transitionsFromCurrentET = await dispatchExecutor.queryWorkflowTransitionData(workflowId, sourceTaskName);
+
+      outerLoop: for (const obj of transitionsFromCurrentET ?? dummyETTransitionObj) {
+        if ((obj.targetTaskName as string).toLocaleLowerCase() === sourceTaskName.toLowerCase()) {
+          isSelfLoopExist = true;
+          break outerLoop;
+        }
+      }
+
+      // transitionsFromCurrentET?.forEach( (obj) => {
+      //   if((obj.targetTaskName as string).toLocaleLowerCase() === sourceTaskName.toLowerCase()){
+      //     isSelfLoopExist = true;
+      //     break;
+      //   }                    
+      // });          
+      return isSelfLoopExist;
+    } catch (e: any) {
+      console.log("isSelfLoopExistOnET-Error", JSON.stringify(e));
+      return false;
+    }
+  }
+
+}
+

package/src/utils/hooks/useModal.tsx

@@ -0,0 +1,67 @@
+import { ViewStyle, TextStyle } from 'react-native';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import ModalWidget, { ModalProps } from '../../components/widgets/ModalWidget';
+
+interface ButtonProps {
+  label: string;
+  onPress: (() => void) | (() => Promise<any>);
+  styles?: ViewStyle;
+  labelStyles?: TextStyle;
+}
+
+interface TitleProps {
+  label: string;
+  styles?: TextStyle;
+}
+
+export type ModalHookProps = Omit<ModalProps, 'showModal'>;
+
+// export interface ModalHookProps {
+//   dismissable?: boolean;
+//   title: TitleProps;
+//   subTitle?: TitleProps;
+//   contentContainerStyle?: ViewStyle;
+//   modalStyle?: ViewStyle;
+//   bodyStyle?: ViewStyle;
+//   renderChildren?: () => JSX.Element;
+//   buttonStyle?: ViewStyle;
+//   primaryButton: ButtonProps;
+//   secondaryButton: ButtonProps;
+//   renderAdditionalButtons?: () => JSX.Element;
+//   renderAdditionalHeader?: () => JSX.Element;
+// }
+
+const useModal = (
+  props: ModalHookProps
+): [() => void, () => void, () => JSX.Element, any] => {
+  const [showModal, setShowModal] = useState(false);
+
+  const showModalRef: any = useRef(null);
+  const hideModalRef: any = useRef(null);
+
+  useEffect(() => {
+    if (!showModalRef.renderModal) showModalRef.current = renderModal;
+    if (!hideModalRef.resetModal) hideModalRef.current = resetModal;
+  });
+
+  const renderModal = useCallback(() => {
+    setShowModal(true);
+  }, []);
+
+  const resetModal = useCallback(() => {
+    setShowModal(false);
+  }, []);
+
+  const ModalComponent = (): JSX.Element => {
+    return <ModalWidget showModal={showModal} {...props} />;
+  };
+
+  return [
+    renderModal,
+    resetModal,
+    ModalComponent,
+    { showRef: showModalRef, hideRef: hideModalRef },
+  ];
+};
+
+export default useModal;

package/src/utils/hooks/useTimer.ts

@@ -0,0 +1,44 @@
+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);
+  useEffect(() => {
+    let myInterval = setInterval(() => {
+      if (seconds > 0) {
+        setSeconds(seconds - 1);
+      }
+      if (seconds === 0) {
+        if (minutes === 0) {
+          clearInterval(myInterval);
+        } else {
+          setMinutes(minutes - 1);
+          setSeconds(59);
+        }
+      }
+    }, 1000);
+    return () => {
+      clearInterval(myInterval);
+    };
+  });
+
+  const resetTimer = () => {
+    if (!minutes && !seconds) {
+      setMinutes(initialMinute);
+      setSeconds(initialSeconds);
+    }
+  };
+
+  const timer =
+    minutes === 0 && seconds === 0
+      ? null
+      : `${minutes}: ${seconds < 10 ? `0${seconds}` : seconds}`;
+
+  return [timer, resetTimer];
+};
+
+export default useTimer;

package/src/utils/loginHelper.ts

@@ -0,0 +1,51 @@
+/**
+ * Creating a wrapper arround localstorage as https://reactnative.dev/docs/asyncstorage
+ *
+ *
+ * @class LoginHelper
+ */
+import type { LoginPayload, LoginType } from '../models/auth';
+import Auth from '../resources/Login';
+class LoginHelper {
+  async initLogin(loginPayload: LoginPayload, loginType: LoginType) {
+    try {
+      let loginResponse: any;
+      switch (loginType) {
+        case 'mobilePassword':
+          loginResponse = await Auth.loginMobilePassword(loginPayload);
+          break;
+        case 'mobileOtp':
+          loginResponse = await Auth.loginMobileOtp(loginPayload);
+          break;
+        case 'mPin':
+          loginResponse = await Auth.loginMpin(loginPayload);
+          break;
+        case 'usernamePassword':
+          loginResponse = await Auth.loginUserName(loginPayload);
+          break;
+        case 'clientCredential':
+          loginResponse = await Auth.loginCredential(loginPayload);
+          break;
+        default:
+          break;
+      }
+      // await Storage.setObject('LoginResponse', loginResponse);
+      return loginResponse;
+    } catch (e: any) {
+      // Flush all storage
+      throw new Error(e);
+    }
+  }
+
+  async handleAccessTokenExpiry() {
+    const data: any = {
+      tenant: 'delhivery',
+      appName: 'user-auth',
+      applicationSecret: 'c8fda076-c0ab-4afd-b357-ecfba4dad6f8',
+    };
+    await Auth.refreshToken(data);
+  }
+}
+
+const loginHelper = new LoginHelper();
+export default loginHelper;