@os1-platform/dispatch-mobile 2.1.1 → 2.1.2

package/src/manager/sdk/DispatchSDKManager.ts

@@ -1,99 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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);
-      }
-    );
-  });
-}