@os1-platform/dispatch-mobile 2.0.7 → 2.1.0

package/src/utils/ExecTaskUtils.ts

@@ -0,0 +1,214 @@
+import type { BaseETResponse } from '../models/execTasks/ETBaseModels';
+import LocationManager from '../manager/location/LocationManager';
+import DispatchSdkCache from '../manager/sdk/DispatchSdkCache';
+import type { CompletedWFResponse } from '../components/executiontasks/CompletedWFSchema';
+import { EntityCode, ExecutionTaskID } from '../models/execTasks/ETConfig';
+import type { EventRow } from '../manager/syncmanager/DBConfig';
+import type { DispatchSDKConfig } from '../models/sdk';
+import dispatchEvent from '../events/EventDispatcher';
+import type { startEvent } from '../models/DispatchModels';
+import { JSONPath } from 'jsonpath-plus';
+import { IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
+
+export async function getBaseETResponse(
+  entityCode: string,
+  success: boolean,
+  eventCode: string,
+  reasonCode: string,
+  mergedObjectiveIds: Array<string>,
+  taskId: ExecutionTaskID
+): Promise<BaseETResponse> {
+  // let location = LocationManager.getInstance().getLastLocation();
+  let cache = DispatchSdkCache.getInstance();
+  const sdkConfig = (await cache.getObjectFromCache(
+    DispatchSdkCache.KEYS.SDK_CONFIG
+  )) as DispatchSDKConfig;
+  /* const startTime = await cache.getObjectFromCache(
+    DispatchSdkCache.KEYS.TASK_START_TIME
+  ); */
+  let baseResponse: BaseETResponse = {
+    entityCode: entityCode,
+    success: success,
+    eventCode: eventCode,
+    reasonCode: reasonCode,
+    id: taskId,
+    meta: {
+      /* location: {
+        latitude: location.latitude,
+        longitude: location.longitude,
+      },*/
+      userDetails: {
+        id: sdkConfig?.userID ?? '',
+        name: sdkConfig?.userName ?? '',
+      },
+      /*startTime: startTime ? parseInt(startTime) : Date.now(),
+      endTime: Date.now(), */
+    },
+    mergedObjectiveIds,
+  };
+  return baseResponse;
+}
+
+export async function getObjectiveCompleteResp(
+  entityCode: string,
+  success: boolean,
+  eventCode: string,
+  reasonCode: string,
+  mergedObjectiveId: Array<string>,
+  taskId: ExecutionTaskID
+) {
+  let completeResponse: CompletedWFResponse = {
+    ...(await getBaseETResponse(
+      entityCode,
+      success,
+      eventCode,
+      reasonCode,
+      mergedObjectiveId,
+      taskId
+    )),
+  };
+  return completeResponse;
+}
+export function getEntityCodeByET(etId: string): string {
+  switch (etId) {
+    case ExecutionTaskID.CAPTURE_INPUT:
+      return EntityCode.CAPTURE_INPUT;
+    case ExecutionTaskID.IMAGE_CAPTURE:
+      return EntityCode.IMAGE_CAPTURE;
+    case ExecutionTaskID.DELIVER:
+      return EntityCode.DELIVER;
+    case ExecutionTaskID.DOODLE:
+      return EntityCode.DOODLE;
+    case ExecutionTaskID.FORMS:
+      return EntityCode.FORMS;
+    case ExecutionTaskID.SCAN:
+      return EntityCode.SCAN;
+    case ExecutionTaskID.DISPLAY:
+      return EntityCode.DISPLAY;
+    case ExecutionTaskID.PICKUP:
+      return EntityCode.PICKUP;
+    case ExecutionTaskID.START_WORKFLOW:
+      return EntityCode.START_WORKFLOW;
+    case ExecutionTaskID.VERIFY_LOCATION:
+      return EntityCode.VERIFY_LOCATION;
+    case ExecutionTaskID.COMPLETED_FAILURE:
+      return EntityCode.COMPLETED_FAILURE;
+    case ExecutionTaskID.COMPLETED_SUCCESS:
+      return EntityCode.COMPLETED_SUCCESS;
+    case ExecutionTaskID.INIT_PAYMENT:
+      return EntityCode.INIT_PAYMENT;
+    case ExecutionTaskID.PROCESS_PAYMENT:
+      return EntityCode.PROCESS_PAYMENT;
+    case ExecutionTaskID.COMPLETE_PAYMENT:
+      return EntityCode.COMPLETE_PAYMENT;
+    case ExecutionTaskID.DELIVER_CASH:
+      return EntityCode.DELIVER_CASH;
+    case ExecutionTaskID.VERIFY_INPUT:
+      return EntityCode.VERIFY_INPUT;
+    case ExecutionTaskID.VALIDATE_OTP_ET:
+      return EntityCode.VALIDATE_OTP_ET;
+    default:
+      return 'NO_ENTITY_CODE_FOUND';
+  }
+}
+
+// export function checkForImagesInEvents(eventRow: EventRow) {
+//   console.log(eventRow);
+// }
+
+/**
+ * This function will be called on start of every execution task and is being used in ET screens components.
+ * @param eventData nextState: state | objRef: string | jobId: string
+ */
+
+export function onTaskStart(
+  eventData: IDispatch.IExecutionTaskQueryResponse,
+  customData: any,
+  triggerEvent = true
+) {
+  const keys = DispatchSdkCache.KEYS;
+  const cache = DispatchSdkCache.getInstance();
+  (async () => {
+    // await cache.setKeyInCache(keys.TASK_START_TIME, Date.now().toString());
+    await cache.setKeyInCache(keys.CURRENT_WORKING_TASK_ID, eventData.taskId);
+  })();
+  if (triggerEvent) {
+    const customEtName = eventData.taskName;
+    const eventOutputData: startEvent = {
+      etData: eventData.input,
+      taskId: eventData.taskId,
+      timestamp: Date.now(),
+      customData,
+    };
+    /* eventData[0].groupId
+      ? (eventOutputData['groupId'] = eventData[0].groupId)
+      : null; */
+
+    /* eventData.forEach((objItem: stateWithObjRef) => {
+      eventOutputData.etData[objItem.jobId] = {
+        ...(objItem.nextState.data.input || {}),
+        workflowInstanceId: objItem.nextState.workflowInstanceId,
+        additionalData: objItem?.additionalData || {},
+      };
+    }); */
+    dispatchEvent('START', customEtName, eventOutputData);
+  }
+}
+
+const isLeafData = (value: any) => {
+  switch (typeof value) {
+    case 'boolean':
+    case 'number':
+      return true;
+    default:
+      return false;
+  }
+};
+const isDynamicValue = function (input: string) {
+  if (
+    input.charAt(0) === '{' &&
+    input.charAt(1) === '{' &&
+    input.charAt(input.length - 1) === '}' &&
+    input.charAt(input.length - 2) === '}'
+  )
+    return true;
+  else return false;
+};
+
+export function handleDynamicValues(jsonInput: any, dataBlob: any) {
+  for (const key in jsonInput) {
+    let value = jsonInput[key];
+    if (!isLeafData(value)) {
+      if (value && typeof value === 'string' && isDynamicValue(value)) {
+        const path = value.substring(2, value.length - 2);
+        const output = JSONPath({
+          json: dataBlob,
+          path,
+        });
+        const outputResp = output.pop();
+        if (outputResp) jsonInput[key] = outputResp;
+      } else if (typeof value === 'object') {
+        if (Array.isArray(value)) {
+          if (typeof value[0] === 'string') {
+            const dynamicVal = value.filter((_val) => isDynamicValue(_val));
+            if (dynamicVal.length) {
+              const path = dynamicVal[0].substring(2, dynamicVal[0].length - 2);
+              const output = JSONPath({
+                json: dataBlob,
+                path,
+              });
+              const outputResp = output.pop();
+              if (outputResp) jsonInput[key] = outputResp;
+            }
+          } else if (typeof value[0] === 'object') {
+            jsonInput[key] = value.map((val) => {
+              val = handleDynamicValues(val, dataBlob);
+              return val;
+            });
+          }
+        } else handleDynamicValues(value, dataBlob);
+      }
+    }
+  }
+  return jsonInput;
+}

package/src/utils/Logger.ts

@@ -0,0 +1,110 @@
+import DispatchSdkCache from '../manager/sdk/DispatchSdkCache';
+import type { DispatchSDKConfig } from '../models/sdk';
+import * as Sentry from '@sentry/react-native';
+import { Severity } from '@sentry/react-native';
+import crashlytics from '@react-native-firebase/crashlytics';
+
+export const enum LOG_TYPE {
+  SDK_ERROR = 'sdk_error',
+  SDK_WARNING = 'sdk_warning',
+  SDK_INFO = 'sdk_info',
+  SDK_DEBUG = 'sdk_debug',
+  APP_ERROR = 'app_error',
+  APP_WARNING = 'app_warning',
+  APP_DEBUG = 'app_debug',
+  APP_INFO = 'app_info',
+}
+
+class Logger {
+  private static instance: Logger;
+  private enableLogs: boolean = false;
+
+  setLogging(enabled: boolean, sdkConfig: DispatchSDKConfig) {
+    this.enableLogs = enabled;
+    crashlytics().setUserId(sdkConfig.userID).then().catch();
+    crashlytics()
+      .setAttributes({
+        userId: sdkConfig.userID,
+        userName: sdkConfig.userName,
+        tenantId: sdkConfig.tenantID,
+      })
+      .then()
+      .catch();
+  }
+
+  logEvent(TAG: string, message: string, logType: LOG_TYPE) {
+    if (this.enableLogs) console.log(TAG, message);
+    // crashlytics().log(`${TAG} - ${logType} -${message}`);
+    // this.sendSentryMessage(message, TAG, logType);
+    if (
+      logType === LOG_TYPE.SDK_WARNING ||
+      logType === LOG_TYPE.SDK_ERROR ||
+      logType === LOG_TYPE.APP_ERROR ||
+      logType === LOG_TYPE.APP_WARNING
+    ) {
+      crashlytics().recordError(new Error(message), TAG);
+      this.sendSentryException(new Error(message), TAG, logType);
+    }
+  }
+
+  public static getInstance(): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger();
+    }
+    return Logger.instance;
+  }
+
+  public sendSentryException(exception: any, logTag: string, logType: string) {
+    (async () => {
+      try {
+        Sentry.captureException(
+          exception,
+          await this.getUserConfig(Severity.Error, logType, logTag)
+        );
+      } catch (error: any) {}
+    })();
+  }
+
+  public sendSentryMessage(message: string, logTag: string, logType: string) {
+    (async () => {
+      try {
+        Sentry.captureMessage(
+          message,
+          await this.getUserConfig(Severity.Warning, logType, logTag)
+        );
+      } catch (error: any) {}
+    })();
+  }
+
+  private async getUserConfig(
+    logLevel: Severity,
+    logType: string,
+    logTag: string
+  ) {
+    try {
+      const config = (await DispatchSdkCache.getInstance().getObjectFromCache(
+        DispatchSdkCache.KEYS.SDK_CONFIG
+      )) as DispatchSDKConfig;
+      const dspId = await DispatchSdkCache.getInstance().getKeyFromCache(
+        DispatchSdkCache.KEYS.DISPATCH_ID
+      );
+      return {
+        user: {
+          id: config?.userID,
+          username: config?.userName,
+        },
+        tags: {
+          dispatchId: dspId,
+          errorTime: Date.now(),
+          logType: logType,
+          logTag: logTag,
+        },
+        level: logLevel,
+      };
+    } catch (error: any) {
+      return undefined;
+    }
+  }
+}
+
+export default Logger;

package/src/utils/NetworkUtil.ts

@@ -0,0 +1,50 @@
+import NetInfo, { NetInfoState } from '@react-native-community/netinfo';
+
+type ConnectivityListener = (available: boolean) => void;
+
+class NetworkUtils {
+  _isAvailable = true;
+  _listeners = new Set<ConnectivityListener>();
+
+  constructor() {
+    NetInfo.addEventListener(this._handleConnectivityChange);
+    this.isAvailableAsync();
+  }
+
+  isAvailable(): boolean {
+    return this._isAvailable;
+  }
+
+  async isAvailableAsync(): Promise<boolean> {
+    if (this._isAvailable) {
+      return this._isAvailable;
+    }
+
+    try {
+      const netInfo = await NetInfo.fetch();
+      this._isAvailable = netInfo.isConnected ?? false;
+    } catch (e) {
+      this._isAvailable = false;
+      console.warn(`Uncaught error when fetching connectivity status: ${e}`);
+    }
+
+    return this._isAvailable;
+  }
+
+  _handleConnectivityChange = (netInfo: NetInfoState) => {
+    this._isAvailable = netInfo.isConnected ?? false;
+    this._listeners.forEach((listener) => {
+      listener(this._isAvailable);
+    });
+  };
+
+  addListener(listener: ConnectivityListener): void {
+    this._listeners.add(listener);
+  }
+
+  removeListener(listener: ConnectivityListener): void {
+    this._listeners.delete(listener);
+  }
+}
+
+export default new NetworkUtils();

package/src/utils/SdkUtils.ts

@@ -0,0 +1,155 @@
+import remoteConfig from '@react-native-firebase/remote-config';
+import Logger, { LOG_TYPE } from './Logger';
+import type { DownloadProgressData } from 'expo-file-system';
+import * as FileSystem from 'expo-file-system';
+import { NativeModules, Platform } from 'react-native';
+import * as Location from 'expo-location';
+import NetworkUtil from './NetworkUtil';
+import { BaseError } from '../errors/BaseError';
+import ErrorCodes from '../errors/ErrorCodes';
+
+const { DispatchSdkUtils } = NativeModules;
+
+interface DispatchUtilsInterface {
+  openAndInstallApk(apkUri: String): Promise<boolean>;
+  openSettings(): Promise<boolean>;
+  showAndroidDialog(
+    title: string,
+    message: string,
+    positiveText: string,
+    negativeText: string | null,
+    cancelable: boolean
+  ): Promise<boolean>;
+  isAutomaticDateTimeEnabled(): Promise<boolean>;
+}
+
+export { DispatchSdkUtils as DispatchUtilsInterface };
+
+export default class SdkUtils {
+  /**
+   * number of seconds to cache the firebase config
+   * @param expiration
+   */
+  static async getRemoteConfig(expiration: number): Promise<any> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await remoteConfig().fetch(expiration);
+        remoteConfig()
+          .fetchAndActivate()
+          .then((fetchedRemotely) => {
+            let config = remoteConfig().getAll();
+            if (fetchedRemotely) {
+              Logger.getInstance().logEvent(
+                'Remote Config',
+                'Configs were retrieved from the backend and activated.',
+                LOG_TYPE.SDK_INFO
+              );
+              resolve(config);
+            } else {
+              Logger.getInstance().logEvent(
+                'Remote Config',
+                'No configs were fetched from the backend, and the local configs were already activated',
+                LOG_TYPE.SDK_INFO
+              );
+              resolve(config);
+            }
+          })
+          .catch((err) => {
+            reject(err);
+          });
+      } catch (error: any) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Function to download apk file from a public URL
+   * @param apkURL - URL where apk is hosted
+   * @param version - expected version of apk (used for naming the file)
+   * @param callback - callback for getting progress of download
+   */
+  public static async downloadAPK(
+    apkURL: string,
+    version: string,
+    callback: (progress: DownloadProgressData) => any
+  ): Promise<string | undefined> {
+    const fileUri = FileSystem.cacheDirectory + `${version}.apk`;
+    const fileInfo = await FileSystem.getInfoAsync(fileUri);
+    const currentDate = new Date().toLocaleDateString();
+    const fileDate = new Date(
+      fileInfo.modificationTime ? fileInfo.modificationTime * 1000 : 0
+    ).toLocaleDateString();
+    if (fileInfo.exists && currentDate === fileDate) {
+      return fileInfo.uri;
+    }
+    const downloadResumable = FileSystem.createDownloadResumable(
+      apkURL,
+      FileSystem.cacheDirectory + `${version}.apk`,
+      {},
+      callback
+    );
+    const downloadResult = await downloadResumable.downloadAsync();
+    return downloadResult?.uri;
+  }
+
+  /**
+   * Opens & Install an APK file
+   * @param uri - source of apk file
+   */
+  public static async deleteApk(version: string) {
+    await FileSystem.deleteAsync(FileSystem.cacheDirectory + `${version}.apk`);
+  }
+
+  public static async openAPKFile(uri: string) {
+    return await (DispatchSdkUtils as DispatchUtilsInterface).openAndInstallApk(
+      uri
+    );
+  }
+
+  public static openAppSettings() {
+    (DispatchSdkUtils as DispatchUtilsInterface)
+      .openSettings()
+      .then()
+      .catch((error) => {
+        Logger.getInstance().logEvent(
+          'Intent error',
+          error.message,
+          LOG_TYPE.SDK_ERROR
+        );
+      });
+  }
+
+  public static async checkMandatory() {
+    if (Platform.OS === 'ios') return;
+    // if (Platform.OS === 'ios') return true;
+    const dateTimeCheck = await (
+      DispatchSdkUtils as DispatchUtilsInterface
+    ).isAutomaticDateTimeEnabled();
+    if (!dateTimeCheck) {
+      throw new BaseError(
+        ErrorCodes.SYSTEM_TIME_CHECK_FAILED,
+        'Automatic date/time not enabled!'
+      );
+    }
+    if (Platform.OS === 'android') {
+      await Location.enableNetworkProviderAsync();
+      let locationServicesCheck = await Location.hasServicesEnabledAsync();
+      const foregroundLocation =
+        await Location.requestForegroundPermissionsAsync();
+      const bgLocation = await Location.requestBackgroundPermissionsAsync();
+      if (!(locationServicesCheck && foregroundLocation && bgLocation)) {
+        throw new BaseError(
+          ErrorCodes.LOCATION_OR_GPS_NOT_ENABLED,
+          'Location or GPS not enabled'
+        );
+      }
+    }
+    let internet = await NetworkUtil.isAvailableAsync();
+    if (!internet)
+      throw new BaseError(
+        ErrorCodes.INTERNET_NOT_ENABLED,
+        'Internet is disabled! Please enable internet and try again '
+      );
+  }
+}