@os1-platform/dispatch-mobile 2.0.8 → 2.1.1

package/src/manager/sdk/DispatchSDKManager.ts

@@ -0,0 +1,99 @@
+import DispatchSdkCache from './DispatchSdkCache';
+import LocationManager from '../location/LocationManager';
+import AppSyncManager from '../syncmanager/AppSyncManager';
+import Logger from '../../utils/Logger';
+import ReasonCodeContainer from '../dispatchCodes/ReasonCodeContainer';
+import GraphQLClient from '../../network/GraphQLClient';
+import { isMandatoryKeysPresent, isTokenExpired } from '../../utils/utils';
+import { BaseError } from '../../errors/BaseError';
+import ErrorCodes from '../../errors/ErrorCodes';
+import SdkUtils from '../../utils/SdkUtils';
+import * as Sentry from '@sentry/react-native';
+import type { DispatchSDKConfig } from '../../models/sdk';
+import EventCodeRepo from '../dispatchCodes/EventCodeRepo';
+import Storage from '../../utils/storage';
+import { pushBulkEventForSync } from '../../utils/SyncManagerUtils';
+import callbackHandler from './callbacksHandler';
+import { DispatchExecutor as dispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
+
+export class DispatchSDKManager {
+  private static instance: DispatchSDKManager;
+  private cache: DispatchSdkCache = DispatchSdkCache.getInstance();
+  private keys = DispatchSdkCache.KEYS;
+
+  private constructor() {}
+
+  public static getInstance(): DispatchSDKManager {
+    if (!DispatchSDKManager.instance) {
+      DispatchSDKManager.instance = new DispatchSDKManager();
+    }
+    return DispatchSDKManager.instance;
+  }
+
+  /**
+   * Call this init method with username,userID & authentication tokens
+   * @param sdkConfig
+   */
+  public async initDispatchSDK(sdkConfig: DispatchSDKConfig) {
+    if (
+      !isMandatoryKeysPresent(sdkConfig, [
+        'tenantID',
+        'userID',
+        'userName',
+        'tenantBaseURL',
+        'accessToken',
+      ])
+    ) {
+      throw new BaseError(
+        ErrorCodes.InvalidArgumentError,
+        'Invalid/Missing Argument Passed in SdkConfig'
+      );
+    }
+    if (isTokenExpired(sdkConfig.accessToken)) {
+      throw new BaseError(
+        ErrorCodes.ACCESS_TOKEN_EXPIRED,
+        'JWT Token Expired!'
+      );
+    }
+    if (sdkConfig.sentry && sdkConfig.sentry?.enabled) {
+      Sentry.init({
+        enableNative: true,
+        environment: sdkConfig.sentry.env,
+        dsn: sdkConfig.sentry.dsn,
+        tracesSampleRate: 1.0,
+      });
+    }
+    await SdkUtils.checkMandatory();
+    await this.cache.setObjectInCache(this.keys.SDK_CONFIG, sdkConfig);
+    GraphQLClient.init(sdkConfig.tenantBaseURL);
+    AppSyncManager.initAppSync(
+      sdkConfig.tenantBaseURL,
+      sdkConfig.syncRetryCount ?? 3
+    );
+    LocationManager.getInstance().startUpdates();
+    if (sdkConfig.eventMapping) {
+      EventCodeRepo.getInstance().saveEventCode(sdkConfig.eventMapping);
+    }
+    await ReasonCodeContainer.getInstance().fetchReasonCode();
+    Logger.getInstance().setLogging(sdkConfig.enableLogging ?? true, sdkConfig);
+    let storage = Storage.getInstance();
+
+    if (sdkConfig.callbacks?.fetchPhoneNumbersCallback) {
+      await callbackHandler.init(sdkConfig.callbacks.fetchPhoneNumbersCallback);
+    }
+    await dispatchExecutor.init(
+      {
+        storeMultipleKeysCallback: storage.setSharedItems,
+        readMultipleKeysCallback: storage.getSharedItems,
+        deleteMultipleKeysCallback: storage.removeSharedItems,
+        eventBulkSyncCallback: pushBulkEventForSync,
+      },
+      sdkConfig.debugLevelLog ? 'debug' : 'emerg'
+    );
+    AppSyncManager.getInstance().startSDKSyncManager();
+  }
+
+  public removeLocationUpdates() {
+    LocationManager.getInstance().stopLocationUpdates();
+  }
+}

package/src/manager/sdk/DispatchSdkCache.ts

@@ -0,0 +1,47 @@
+import Storage from '../../utils/storage';
+
+export default class DispatchSdkCache {
+  private storage: Storage = Storage.getInstance();
+  private static instance: DispatchSdkCache;
+
+  public static getInstance() {
+    if (!DispatchSdkCache.instance) {
+      DispatchSdkCache.instance = new DispatchSdkCache();
+    }
+    return DispatchSdkCache.instance;
+  }
+  public static KEYS = {
+    SDK_CONFIG: 'dsc_sdk_config',
+    DISPATCH_ID: 'dsc_dispatch_id',
+    FMS_FOLDER: 'dsc_fms_folder',
+    FIREBASE_REGISTRATION_TOKEN: 'dsc_firebase_token',
+    REASON_FETCH_TIME: 'dsc_reasons_fetch_time',
+    CURRENT_WORKING_TASK_ID: 'current_working_task_id',
+    // TASK_START_TIME: 'task_start_time',
+  };
+  public async setObjectInCache(keyName: string, obj: any) {
+    await this.storage.setObject(keyName, obj);
+  }
+  public async getObjectFromCache(keyName: string): Promise<any> {
+    return await this.storage.getObject(keyName);
+  }
+  public async setKeyInCache(keyName: string, keyValue: string) {
+    await this.storage.setItem(keyName, keyValue);
+  }
+  public async getKeyFromCache(keyName: string): Promise<string | null> {
+    try {
+      let keyValue = await this.storage.getItem(keyName);
+      if (keyValue != null) return keyValue;
+      else return null;
+    } catch (error: any) {
+      return null;
+    }
+  }
+  public async clearKeys(keys: string[]) {
+    try {
+      for (let i = 0; i < keys.length; i++) {
+        await this.storage.deleteItem(keys[i]);
+      }
+    } catch (error: any) {}
+  }
+}

package/src/manager/sdk/callbacksHandler.ts

@@ -0,0 +1,25 @@
+class CallbacksHandler {
+  private _callbackToFetchPhoneNumbers!: (
+    sdsIds: string[]
+  ) => Promise<{ key: string; value: string[] }>;
+
+  public init(
+    phoneCallback: (
+      sdsIds: string[]
+    ) => Promise<{ key: string; value: string[] }>
+  ) {
+    this._callbackToFetchPhoneNumbers = phoneCallback;
+  }
+
+  public async getPhoneNumbers(
+    sdsIds: string[]
+  ): Promise<{ key: string; value: string[] } | null> {
+    if (!this._callbackToFetchPhoneNumbers) return null;
+    else {
+      return await this._callbackToFetchPhoneNumbers(sdsIds);
+    }
+  }
+}
+
+const callbackHandler = new CallbacksHandler();
+export default callbackHandler;

package/src/manager/syncmanager/AppSyncManager.ts

@@ -0,0 +1,187 @@
+import DocumentSyncManager from './document/DocumentSyncManager';
+import EventsSyncManager from './events/EventsSyncManager';
+import NetworkUtil from '../../utils/NetworkUtil';
+import Logger, { LOG_TYPE } from '../../utils/Logger';
+import NativeSyncManager from './NativeSyncManager';
+import DispatchSdkCache from '../sdk/DispatchSdkCache';
+import { AppRegistry, Platform } from 'react-native';
+import { BaseError } from '../../errors/BaseError';
+import ErrorCodes from '../../errors/ErrorCodes';
+import type { SdkSyncType } from '../../models/DispatchModels';
+import type { BulkEvent, DocumentRow, EventRow } from './DBConfig';
+import {
+  DEFAULT_INTERVAL,
+  DEFAULT_NOTIFICATION_DESCRIPTION,
+  DEFAULT_NOTIFICATION_TITLE,
+} from '../../constants/constants';
+import type { DispatchSDKConfig } from '../../models/sdk';
+
+export default class AppSyncManager {
+  private constructor(tenantBaseURL: string, retryCount: number) {
+    DocumentSyncManager.getInstance().init(tenantBaseURL, retryCount);
+    EventsSyncManager.getInstance().initSyncManager(tenantBaseURL, retryCount);
+  }
+  private static instance: AppSyncManager;
+  public isSyncActive = false;
+  public isForceStartEnabled = true;
+
+  /**
+   *
+   * @param forceSync - true/false - if true resets the retry count key and start the sync
+   * @param syncType
+   */
+  public async startSyncing(forceSync: boolean, _syncType?: SdkSyncType) {
+    if (await NetworkUtil.isAvailableAsync()) {
+      if (forceSync) {
+        EventsSyncManager.getInstance().forceSync();
+        DocumentSyncManager.getInstance().forceDocumentSync();
+      } else {
+        EventsSyncManager.getInstance().startSync();
+        DocumentSyncManager.getInstance().startDocumentSync();
+      }
+    } else {
+      Logger.getInstance().logEvent(
+        'startSync',
+        'No network',
+        LOG_TYPE.SDK_INFO
+      );
+    }
+  }
+
+  public async isAppSyncPending(): Promise<boolean> {
+    return (
+      (await EventsSyncManager.getInstance().isSyncPending()) ||
+      (await DocumentSyncManager.getInstance().isSyncPending())
+    );
+  }
+  public static initAppSync(
+    tenantBaseURL: string,
+    syncRetryCount: number
+  ): AppSyncManager {
+    if (!AppSyncManager.instance) {
+      Logger.getInstance().logEvent(
+        'initAppSync',
+        'CREATING NEW INSTANCE',
+        LOG_TYPE.SDK_INFO
+      );
+      AppSyncManager.instance = new AppSyncManager(
+        tenantBaseURL,
+        syncRetryCount
+      );
+    }
+    return AppSyncManager.instance;
+  }
+  public static getInstance(): AppSyncManager {
+    if (!AppSyncManager.instance)
+      throw new BaseError(
+        ErrorCodes.AppSyncNotInitialized,
+        'SDK sync Manager is not initialized'
+      );
+    else return AppSyncManager.instance;
+  }
+
+  public static async startAppSyncManager() {
+    try {
+      if (!AppSyncManager.instance) {
+        NativeSyncManager.stopSyncManager();
+        let sdkConfig =
+          (await DispatchSdkCache.getInstance().getObjectFromCache(
+            DispatchSdkCache.KEYS.SDK_CONFIG
+          )) as DispatchSDKConfig;
+        const retryCount = sdkConfig.syncRetryCount ?? 3;
+        if (sdkConfig.tenantBaseURL != null && retryCount != null) {
+          AppSyncManager.initAppSync(sdkConfig.tenantBaseURL, +retryCount);
+          AppSyncManager.getInstance().startSDKSyncManager();
+        } else {
+          Logger.getInstance().logEvent(
+            'SYNC_MANAGER_ASM',
+            'TENANT BASE URL IS NULL',
+            LOG_TYPE.SDK_ERROR
+          );
+        }
+      } else if (await AppSyncManager.instance.isAppSyncPending()) {
+        AppSyncManager.instance.startSyncing(false);
+      } else {
+        NativeSyncManager.stopSyncManager();
+        AppSyncManager.getInstance().isSyncActive = false;
+      }
+    } catch (error: any) {
+      Logger.getInstance().logEvent(
+        'startAppSyncManager',
+        `Unable to start App Sync Manager ${error.message}`,
+        LOG_TYPE.SDK_WARNING
+      );
+    }
+  }
+
+  /**
+   * Call this method from index file of the app
+   */
+  public static registerSyncTask() {
+    AppRegistry.registerHeadlessTask(
+      'SYNC_MANAGER',
+      () => AppSyncManager.startAppSyncManager
+    );
+  }
+
+  public async getAllEvents(dispatchID?: string): Promise<EventRow[]> {
+    return EventsSyncManager.getInstance().getAllEvents(dispatchID);
+  }
+  public async getAllDocuments(dispatchID?: string): Promise<DocumentRow[]> {
+    return DocumentSyncManager.getInstance().getAllDocuments(dispatchID);
+  }
+  public startSDKSyncManager() {
+    (async () => {
+      const config = (await DispatchSdkCache.getInstance().getObjectFromCache(
+        DispatchSdkCache.KEYS.SDK_CONFIG
+      )) as DispatchSDKConfig;
+      if (Platform.OS === 'android') {
+        if (!this.isSyncActive && this.isForceStartEnabled) {
+          this.isSyncActive = true;
+
+          /**
+           * Reset Retry Counter
+           */
+          EventsSyncManager.getInstance().retries = 0;
+          DocumentSyncManager.getInstance().retries = 0;
+          NativeSyncManager.startSyncManager(
+            config?.notificationConfig?.interval ?? DEFAULT_INTERVAL,
+            config?.notificationConfig?.title ?? DEFAULT_NOTIFICATION_TITLE,
+            config?.notificationConfig?.description ??
+              DEFAULT_NOTIFICATION_DESCRIPTION
+          );
+        } else {
+          Logger.getInstance().logEvent(
+            'startNativeSyncManager',
+            'ANDROID SYNC SERVICE ALREADY RUNNING',
+            LOG_TYPE.SDK_INFO
+          );
+        }
+      } else {
+        /**
+         * For iOS we have to start Normal Foreground sync
+         */
+        this.startSyncing(true).then().catch();
+      }
+    })();
+  }
+
+  // NEW CODE
+  public async pushToQueue(pushData: BulkEvent): Promise<boolean> {
+    try {
+      await EventsSyncManager.getInstance().insertBulkEvent(pushData);
+
+      AppSyncManager.getInstance().startSDKSyncManager();
+      return true;
+    } catch (error: any) {
+      Logger.getInstance().logEvent(
+        'pushToQueue ',
+        JSON.stringify({
+          errorMessage: error.message,
+        }),
+        LOG_TYPE.SDK_ERROR
+      );
+      return false;
+    }
+  }
+}

package/src/manager/syncmanager/DBConfig.ts

@@ -0,0 +1,181 @@
+import { IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
+export type ExecEngineSyncType = IDispatch.SyncType;
+
+export enum DispatchSyncType {
+  DEFAULT = 'DEFAULT',
+  DISPATCH_UPDATE = 'DISPATCH_UPDATE',
+  DISPATCH_SUB_STATUS_UPDATE = 'DISPATCH_SUB_STATUS_UPDATE',
+}
+
+export const DATABASE_NAME = 'DISPATCH_DB';
+export const EVENTS_TABLE = 'EVENTS_TABLE';
+export const REASONS_TABLE = 'REASONS_TABLE';
+export const EVENT_CODES_TABLE = 'EVENT_CODES_TABLE';
+
+export const EVENTS_COLUMNS = {
+  ID: 'id',
+  SEQUENCE: 'seq_number',
+  PAYLOAD: 'payload',
+  SYNCED: 'synced',
+  CONFIG: 'config',
+  SYNC_TYPE: 'sync_type',
+  META: 'meta',
+  SYNC_ERROR: 'sync_error',
+  DISPATCH_ID: 'dispatch_id',
+  DATA_LENGTH: 'data_length',
+};
+
+export const DOCUMENT_TABLE = 'DOCUMENTS_TABLE';
+export const DOCUMENT_COLUMNS = {
+  ID: 'id',
+  DATA: 'data',
+  BASE64: 'base64',
+  FILE_PATH: 'file_path',
+  FILE_NAME: 'file_name',
+  FILE_TYPE: 'file_type',
+  SYNCED: 'synced',
+  FMS_FOLDER_ID: 'fms_folder_id',
+  FMS_ID: 'fms_id',
+  PRIORITY: 'priority',
+  DESCRIPTION: 'desc',
+  SYNC_ERROR: 'sync_error',
+  DISPATCH_ID: 'dispatch_id',
+  JOB_ID: 'job_id',
+  OBJECTIVE_REF: 'objective_ref',
+};
+export type DocumentRow = {
+  id: number;
+  data: string;
+  base64: boolean;
+  file_path: string;
+  file_name: string;
+  file_type: string;
+  synced: boolean;
+  fms_folder_id: string;
+  fms_id: string;
+  priority: number;
+  desc: string;
+  sync_error: string;
+  dispatch_id: string;
+  job_id: string;
+  objective_ref: string;
+};
+export type EventRow = {
+  id: number;
+  payload: string;
+  synced: boolean;
+  config: string;
+  sync_type: ExecEngineSyncType | DispatchSyncType;
+  objective_ref: string;
+  sync_error: string;
+  dispatch_id: string;
+};
+
+export enum SyncMethod {
+  POST = 'POST',
+  PUT = 'PUT',
+  GET = 'GET',
+  DELETE = 'DELETE',
+}
+export const ReasonColums = {
+  CODE: 'reasonCode',
+  DESCRIPTION: 'description',
+  IS_ENABLED: 'isEnabled',
+  SYSTEM_DEFINED: 'isSystemDefined',
+};
+export interface ReasonsRow {
+  description: string;
+  isEnabled: boolean;
+  reasonCode: string;
+  isSystemDefined: boolean;
+}
+
+export interface EventsRow {
+  description: string;
+  successEvent: boolean;
+  eventCode: string;
+}
+
+export const EventColumns = {
+  CODE: 'eventCode',
+  DESCRIPTION: 'description',
+  SUCCESS_EVENT: 'successEvent',
+};
+
+// NEW CODE
+export interface BulkEvent {
+  syncType: ExecEngineSyncType | DispatchSyncType;
+  dispatchId: string;
+  data: any;
+  meta?: any; // updatedBy, code, status, timestamp, [{jobId,wfId}]
+}
+
+// OLD CODE
+// export interface BulkEvent {
+//   syncType: SyncType;
+//   dispatchId: string;
+//   data: string;
+//   config: string;
+//   sequence: number;
+//   meta?: any;
+// }
+
+export interface WFUpdateBulkEventData {
+  [customETName: string]: EventETData;
+}
+
+export interface EventETData {
+  output: any;
+}
+
+export interface WIUpdateOutputPayload {
+  dispatchId: string;
+  updatedBy: any;
+  workflows: Array<WorkflowUpdatePayload>;
+}
+
+export interface WorkflowUpdatePayload {
+  status: string;
+  timestamp: number;
+  attemptId: 1;
+  code: string;
+  data: any;
+  meta?: any;
+  __unmerged?: Array<UnmergedData>;
+}
+
+export interface UnmergedData {
+  workflowInstanceId: string;
+  jobId: string;
+  data?: any;
+}
+
+export interface CustodyData {
+  dispatchId: string;
+  jobId: string;
+  custodyEntity: string;
+  custodyLocationId: string;
+  custodyEntityAmount: number;
+  custodyEntityId: string;
+}
+
+export const WORKFLOW_INSTANCE_TABLE = 'WF_INSTANCE_TABLE';
+export const WORKFLOW_INSTANCE_COLUMNS = {
+  WORKFLOW_INSTANCE_ID: 'WFIId',
+  MERGED_WORKFLOW_INSTANCE_ID: 'MWFIId',
+  JOB_ID: 'jobId',
+  SCANNABLE_ID: 'scannableId',
+  INITIAL_MERGED_WORKFLOW_INSTANCE_ID: 'InitialMWFIId',
+  STATUS: 'status',
+  JOB_WF_ID: 'jobWfId',
+  DISPLAY_DATA: 'displayData',
+  WORKFLOW_ID: 'WFId',
+};
+
+export interface SyncManagerPayload {
+  data: {
+    action: ExecEngineSyncType | DispatchSyncType;
+    payload: any;
+  };
+  length: number;
+}

package/src/manager/syncmanager/NativeSyncManager.ts

@@ -0,0 +1,14 @@
+import { NativeModules } from 'react-native';
+
+const { NativeSyncManager } = NativeModules;
+
+interface SyncManagerInterface {
+  startSyncManager(
+    interval: number,
+    notifTitle: string,
+    notifText: string
+  ): void;
+  stopSyncManager(): void;
+}
+
+export default NativeSyncManager as SyncManagerInterface;

package/src/manager/syncmanager/constants.ts

@@ -0,0 +1,5 @@
+export const BULK_DATA_LIMIT = 1000;
+export const LAST_SYNCED_EVENT_ID = 'lastSyncedEventId';
+export const SHARED_PREFERENCE_DISPATCH_ID = 'sharedPreferenceDispatchId';
+export const SHARED_PREFERENCE_SCAN_OUTPUT = 'scanETMappedOutput';
+export const SCAN_MERGED_OBJ_ID_OUTPUT = 'scanMergedObjectiveIDs';

package/src/manager/syncmanager/database.ts

@@ -0,0 +1,93 @@
+import * as SQLite from 'expo-sqlite';
+import * as DBConfig from './DBConfig';
+import type { SQLResultSet, WebSQLDatabase } from 'expo-sqlite';
+import { isEmptyOrBlank } from '../../utils/utils';
+import { BaseError } from '../../errors/BaseError';
+import BaseErrorCodes from '../../errors/ErrorCodes';
+import Logger, { LOG_TYPE } from '../../utils/Logger';
+
+let dbConnection: WebSQLDatabase | null;
+
+function openDatabase(): WebSQLDatabase {
+  return SQLite.openDatabase(DBConfig.DATABASE_NAME);
+}
+
+export interface ExecQuery {
+  query: string;
+  args: any[];
+}
+
+export function executeQuery(
+  query: string,
+  args: any[]
+): Promise<SQLResultSet> {
+  return new Promise((resolve, reject) => {
+    if (isEmptyOrBlank(query)) {
+      reject(
+        new BaseError(
+          BaseErrorCodes.InvalidArgumentError,
+          'SQL Query is null or empty'
+        )
+      );
+      return;
+    }
+    if (!dbConnection) dbConnection = openDatabase();
+    dbConnection.transaction((tx) => {
+      tx.executeSql(
+        query,
+        args,
+        (_, sqlResultSet) => {
+          resolve(sqlResultSet);
+        },
+        (_, sqlError) => {
+          reject(sqlError);
+          return false;
+        }
+      );
+    });
+  });
+}
+
+export function executeBulkQuery(_queryData: ExecQuery[]): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+    let _sqlResultSet: SQLResultSet[] = [];
+
+    if (!dbConnection) dbConnection = openDatabase();
+    dbConnection.transaction(
+      (tx) => {
+        _queryData.forEach((_q) => {
+          tx.executeSql(
+            _q.query,
+            _q.args,
+            (_, sqlResultSet) => {
+              _sqlResultSet.push(sqlResultSet);
+              // resolve(sqlResultSet);
+            }
+            /* (_, sqlError) => {
+              _sqlError.push(sqlError);
+              // reject(sqlError);
+              return false;
+            } */
+          );
+        });
+      },
+      (error) => {
+        Logger.getInstance().logEvent(
+          'executeBulkQuery err: ',
+          JSON.stringify(error),
+          LOG_TYPE.SDK_ERROR
+        );
+        reject(error);
+        // return false;
+      },
+      () => {
+        Logger.getInstance().logEvent(
+          'executeBulkQuery success: ',
+          JSON.stringify(_sqlResultSet),
+          LOG_TYPE.SDK_DEBUG
+        );
+        resolve(true);
+      }
+    );
+  });
+}