@os1-platform/dispatch-mobile 3.1.8 → 3.2.0

package/src/manager/dispatch/DispatchStateContainer.tsx

@@ -1,28 +1,12 @@
 import { clearCache, createFmsFolder } from '../../utils/SyncManagerUtils';
-import {
-  DispatchExecutor as dispatchExecutor,
-  IDispatchExecutor,
-  IDispatch,
-} from '@os1-platform/platform-coreos-execution-engine-sdk';
+import { DispatchExecutor as dispatchExecutor, IDispatchExecutor, IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
 import { showToast } from '../../components/widgets/Toaster';
-import {
-  CustomScreens,
-  ExecutionTaskID,
-} from '../../models/execTasks/ETConfig';
-import type {
-  ETSummary,
-  ObjectiveSummary,
-} from '../../models/execTasks/ETBaseModels';
-
+import { CustomScreens, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import type { ETSummary, ObjectiveSummary } from '../../models/execTasks/ETBaseModels';
 import EventsSyncManager from '../syncmanager/events/EventsSyncManager';
 import Logger, { LOG_TYPE } from '../../utils/Logger';
 import DispatchSdkCache from '../sdk/DispatchSdkCache';
-import type {
-  BaseETProps,
-  endEvent,
-  JobObjectiveType,
-  stateParams,
-} from '../../models/DispatchModels';
+import type { BaseETProps, endEvent, JobObjectiveType, stateParams } from '../../models/DispatchModels';
 import { BaseError } from '../../errors/BaseError';
 import { getBaseETResponse } from '../../utils/ExecTaskUtils';
 import ReasonCodeContainer from '../dispatchCodes/ReasonCodeContainer';
@@ -106,11 +90,7 @@ export default class DispatchStateContainer {
       !dispatchWorkflows ||
       Object.keys(dispatchWorkflows).length < 1
     ) {
-      Logger.getInstance().logEvent(
-        'initDispatchExecutor',
-        InvalidArgumentsError,
-        LOG_TYPE.SDK_WARNING
-      );
+      Logger.getInstance().logEvent('initDispatchExecutor', InvalidArgumentsError, LOG_TYPE.SDK_WARNING);
       throw new BaseError(
         BaseErrorCodes.InvalidArgumentError,
         InvalidArgumentsError

package/src/manager/dispatchCodes/EventCodeRepo.ts

@@ -1,9 +1,5 @@
-import * as Database from '../syncmanager/database';
-import {
-  EventsRow,
-  EVENT_CODES_TABLE,
-  EventColumns,
-} from '../syncmanager/DBConfig';
+import Database from '../syncmanager/database';
+import { EventsRow, EVENT_CODES_TABLE, EventColumns } from '../syncmanager/DBConfig';
 import type { EventCodes } from '../../models/ReasonCodes';
 
 export default class EventCodeRepo {
@@ -31,7 +27,7 @@ export default class EventCodeRepo {
     await Promise.all(promises);
   }
   private async insertEvent(event: EventsRow) {
-    await Database.executeQuery(
+    await Database.executeSetDataQuery(
       `INSERT OR REPLACE INTO ${EVENT_CODES_TABLE}(\
                 ${EventColumns.CODE},\
                 ${EventColumns.DESCRIPTION},\
@@ -42,7 +38,7 @@ export default class EventCodeRepo {
   }
 
   private async init(): Promise<void> {
-    await Database.executeQuery(
+    await Database.executeSetDataQuery(
       `CREATE TABLE IF NOT EXISTS ${EVENT_CODES_TABLE} (\
                 ${EventColumns.CODE} TEXT PRIMARY KEY NOT NULL,\
                 ${EventColumns.DESCRIPTION} TEXT,\
@@ -51,20 +47,20 @@ export default class EventCodeRepo {
     );
   }
   public async getAllEventCodes(): Promise<EventsRow[]> {
-    const resultSet = await Database.executeQuery(
+    const resultSet = await Database.executeGetDataQuery(
       `SELECT * FROM ${EVENT_CODES_TABLE};`,
       []
     );
     return resultSet.rows._array;
   }
   public async deleteAll() {
-    return Database.executeQuery(`DELETE FROM ${EVENT_CODES_TABLE};`, []);
+    return Database.executeSetDataQuery(`DELETE FROM ${EVENT_CODES_TABLE};`, []);
   }
 
   public async getEventsByCode(codes: string[]): Promise<EventsRow[]> {
     if (!codes || codes.length < 1) return [];
     const placeholders = codes.map((it) => `'${it}'`).join(',');
-    const resultSet = await Database.executeQuery(
+    const resultSet = await Database.executeGetDataQuery(
       `SELECT * FROM ${EVENT_CODES_TABLE} WHERE ${EventColumns.CODE} IN (${placeholders});`,
       []
     );
@@ -73,7 +69,7 @@ export default class EventCodeRepo {
 
   public async getEventByCode(code: string): Promise<EventsRow[]> {
     if (!code) return [];
-    const resultSet = await Database.executeQuery(
+    const resultSet = await Database.executeGetDataQuery(
       `SELECT * FROM ${EVENT_CODES_TABLE} WHERE ${EventColumns.CODE} = ?;`,
       [code]
     );

package/src/manager/dispatchCodes/ReasonCodeContainer.ts

@@ -2,15 +2,15 @@ import DispatchSdkCache from '../sdk/DispatchSdkCache';
 import Logger, { LOG_TYPE } from '../../utils/Logger';
 import { BaseError } from '../../errors/BaseError';
 import ErrorCodes from '../../errors/ErrorCodes';
-import ReasonCodeRepo from './ReasonCodeRepo';
 import type { ApplicableReasons } from '../../models/execTasks/ETBaseModels';
 import type { ReasonsRow } from '../syncmanager/DBConfig';
 import GraphQLClient from '../../network/GraphQLClient';
+import ReasonCodeRepoIns from './ReasonCodeRepo';
 
 export default class ReasonCodeContainer {
   private static instance: ReasonCodeContainer;
   private cache: DispatchSdkCache = DispatchSdkCache.getInstance();
-  private constructor() {}
+  private constructor() { }
 
   public static getInstance(): ReasonCodeContainer {
     if (!ReasonCodeContainer.instance) {
@@ -31,7 +31,7 @@ export default class ReasonCodeContainer {
     try {
       const codes: string[] = applicableCodes[entityCode];
       let finalApplicableCodes =
-        await ReasonCodeRepo.getInstance().getReasonsByCode(codes);
+        await ReasonCodeRepoIns.getReasonsByCode(codes);
       if (finalApplicableCodes && finalApplicableCodes.length > 0) {
         return finalApplicableCodes;
       } else return [];
@@ -54,7 +54,7 @@ export default class ReasonCodeContainer {
     try {
       if (!code) return null;
       else {
-        const queryResult = await ReasonCodeRepo.getInstance().getReasonByCode(
+        const queryResult = await ReasonCodeRepoIns.getReasonByCode(
           code
         );
         if (queryResult && queryResult.length > 0) {
@@ -84,7 +84,7 @@ export default class ReasonCodeContainer {
           graphlQLResponse.data.reasonList &&
           graphlQLResponse.data.reasonList.data
         ) {
-          await ReasonCodeRepo.getInstance().saveReasonCode(
+          await ReasonCodeRepoIns.saveReasonCode(
             graphlQLResponse.data.reasonList.data
           );
           await this.cache.setKeyInCache(

package/src/manager/dispatchCodes/ReasonCodeRepo.ts

@@ -1,12 +1,9 @@
-import * as Database from '../syncmanager/database';
-import {
-  ReasonColums,
-  REASONS_TABLE,
-  ReasonsRow,
-} from '../syncmanager/DBConfig';
+import Database from '../syncmanager/database';
+import { ReasonColums, REASONS_TABLE, ReasonsRow } from '../syncmanager/DBConfig';
 import type { ReasonCodes } from '../../models/ReasonCodes';
+import { Platform } from 'react-native';
 
-export default class ReasonCodeRepo {
+class ReasonCodeRepo {
   private static instance: ReasonCodeRepo;
   public static getInstance(): ReasonCodeRepo {
     if (!ReasonCodeRepo.instance) {
@@ -32,7 +29,7 @@ export default class ReasonCodeRepo {
     await Promise.all(promises);
   }
   private async insertReason(reason: ReasonsRow) {
-    await Database.executeQuery(
+    await Database.executeSetDataQuery(
       `INSERT OR REPLACE INTO ${REASONS_TABLE}(\
                 ${ReasonColums.CODE},\
                 ${ReasonColums.DESCRIPTION},\
@@ -48,8 +45,8 @@ export default class ReasonCodeRepo {
     );
   }
 
-  private async init(): Promise<void> {
-    await Database.executeQuery(
+  public async init(): Promise<void> {
+    const initResult = await Database.executeSetDataQuery(
       `CREATE TABLE IF NOT EXISTS ${REASONS_TABLE} (\
                 ${ReasonColums.CODE} TEXT PRIMARY KEY NOT NULL,\
                 ${ReasonColums.DESCRIPTION} TEXT,\
@@ -57,23 +54,25 @@ export default class ReasonCodeRepo {
                 ${ReasonColums.SYSTEM_DEFINED} INTEGER);`,
       []
     );
+    return;
   }
   public async getAllReasons(): Promise<ReasonsRow[]> {
-    const resultSet = await Database.executeQuery(
+    const resultSet = await Database.executeGetDataQuery(
       `SELECT * FROM ${REASONS_TABLE};`,
       []
     );
     return resultSet.rows._array;
   }
   public async deleteAll() {
-    return Database.executeQuery(`DELETE FROM ${REASONS_TABLE};`, []);
+    return Database.executeSetDataQuery(`DELETE FROM ${REASONS_TABLE};`, []);
   }
 
   public async getReasonsByCode(codes: string[]): Promise<ReasonsRow[]> {
     if (!codes || codes.length < 1) return [];
     const placeholders = codes.map((it) => `'${it}'`).join(',');
-    const resultSet = await Database.executeQuery(
-      `SELECT * FROM ${REASONS_TABLE} WHERE (${ReasonColums.IS_ENABLED}=1) and  ${ReasonColums.CODE} IN (${placeholders});`,
+    const isEnabled = Platform.OS === 'ios' ? '1' : '1';
+    const resultSet = await Database.executeGetDataQuery(
+      `SELECT * FROM ${REASONS_TABLE} WHERE ${ReasonColums.IS_ENABLED}= '${isEnabled}' AND  ${ReasonColums.CODE} IN (${placeholders});`,
       []
     );
     return resultSet.rows._array;
@@ -81,10 +80,13 @@ export default class ReasonCodeRepo {
 
   public async getReasonByCode(code: string): Promise<ReasonsRow[]> {
     if (!code) return [];
-    const resultSet = await Database.executeQuery(
+    const resultSet = await Database.executeGetDataQuery(
       `SELECT * FROM ${REASONS_TABLE} WHERE ${ReasonColums.CODE} = ?;`,
       [code]
     );
     return resultSet.rows._array;
   }
 }
+
+const ReasonCodeRepoIns = ReasonCodeRepo.getInstance();
+export default ReasonCodeRepoIns;

package/src/manager/location/LocationManager.ts

@@ -1,6 +1,3 @@
-import * as Location from 'expo-location';
-import { Accuracy, LocationObject } from 'expo-location';
-import Logger, { LOG_TYPE } from '../../utils/Logger';
 import { EmitterSubscription, Platform } from 'react-native';
 import PermissionModule from '../../native/PermissionModule';
 import LocationModule, { LocationType } from '../../native/LocationModule';
@@ -13,7 +10,6 @@ export default class LocationManager {
   private subscription: EmitterSubscription | null = null;
 
   public async checkForLocationPermissions(): Promise<boolean> {
-    console.log("checkForLocationPermissions");
     if (Platform.OS === 'ios') {
       // old code checking for permissions using expo-location
       // let permissionResponse = await Location.getForegroundPermissionsAsync();
@@ -63,7 +59,6 @@ export default class LocationManager {
     if (Platform.OS === 'android') {
       LocationModule.startLocationUpdates();
       this.subscription = LocationModule.addLocationListener((location) => {
-        console.log('Location updated:', location);
         if (location != null) {
           this.lastLocationAndroid = location
         }
@@ -84,7 +79,6 @@ export default class LocationManager {
 
   public async getLastLocation(): Promise<DLocation> {
     if (Platform.OS === 'android' && this.lastLocationAndroid != null) {
-      console.log("lastLocationAndroid:", this.lastLocationAndroid);
       return {
         latitude: this.lastLocationAndroid.latitude.toString(),
         longitude: this.lastLocationAndroid.longitude.toString(),
@@ -93,8 +87,7 @@ export default class LocationManager {
     }
     if (Platform.OS === 'ios') {
       this.lastLocationiOS = await LocationModule.getLastLocation();
-      console.log("lastLocationiOS:", this.lastLocationiOS);
-      if(this.lastLocationiOS){
+      if (this.lastLocationiOS) {
         return {
           latitude: this.lastLocationiOS.latitude.toString(),
           longitude: this.lastLocationiOS.longitude.toString(),

package/src/manager/sdk/DispatchSDKManager.ts

@@ -17,6 +17,7 @@ import { pushBulkEventForSync } from '../../utils/SyncManagerUtils';
 import callbackHandler from './callbacksHandler';
 import { DispatchExecutor as dispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
 import { MAX_RETRY_COUNT } from '../syncmanager/constants';
+import { initAndUpdateDatabase } from '../../database/DBManager';
 
 export class DispatchSDKManager {
   private static instance: DispatchSDKManager;
@@ -47,27 +48,33 @@ export class DispatchSDKManager {
         'accessToken',
       ])
     ) {
-      throw new BaseError(
-        ErrorCodes.InvalidArgumentError,
-        'Invalid/Missing Argument Passed in SdkConfig'
-      );
+      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,
+        enableAutoSessionTracking: true,
+        enableAutoPerformanceTracing: false,
+        attachStacktrace: true,
+        maxBreadcrumbs: 50,
       });
     }
+    
     await SdkUtils.checkMandatory();
+    
     await this.cache.setObjectInCache(this.keys.SDK_CONFIG, sdkConfig);
+    await initAndUpdateDatabase()
     GraphQLClient.init(sdkConfig.tenantBaseURL);
     AppSyncManager.initAppSync(
       sdkConfig.tenantBaseURL,
@@ -78,6 +85,7 @@ export class DispatchSDKManager {
       EventCodeRepo.getInstance().saveEventCode(sdkConfig.eventMapping);
     }
     await ReasonCodeContainer.getInstance().fetchReasonCode();
+    
     Logger.getInstance().setLogging(sdkConfig.enableLogging ?? true, sdkConfig);
     let storage = Storage.getInstance();
 

package/src/manager/sdk/callbacksHandler.ts

@@ -1,5 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { DispatchSDKConfig } from 'src/models/sdk';
+import { DispatchSDKConfig } from '../../models/sdk';
 import DispatchSdkCache from './DispatchSdkCache';
 import { BaseError } from '../../errors/BaseError';
 import ErrorCodes from '../../errors/ErrorCodes';
@@ -17,14 +16,10 @@ class CallbacksHandler {
   ) => Promise<Record<string, EmailAndPhoneResponse>>;
 
   public init(
-    phoneCallback: (
-      sdsIds: string[]
-    ) => Promise<{ key: string; value: string[] }>,
+    phoneCallback: (sdsIds: string[]) => Promise<{ key: string; value: string[] }>,
     dateTimeCallBack: () => Promise<string>,
     tokenRefreshCallback: () => Promise<string>,
-    emailAndPhoneCallback: (
-      sdsIds: string[]
-    ) => Promise<Record<string, EmailAndPhoneResponse>>
+    emailAndPhoneCallback: (sdsIds: string[]) => Promise<Record<string, EmailAndPhoneResponse>>
   ) {
     this._callbackToFetchPhoneNumbers = phoneCallback;
     this._callbackToFetchDateTime = dateTimeCallBack;

package/src/manager/syncmanager/DBConfig.ts

@@ -7,7 +7,7 @@ export enum DispatchSyncType {
   DISPATCH_SUB_STATUS_UPDATE = 'DISPATCH_SUB_STATUS_UPDATE',
 }
 
-export const DATABASE_NAME = 'OS1_Driver_App_DB';
+export const DATABASE_NAME = 'DispatchSDK_DB';
 export const EVENTS_TABLE = 'EVENTS_TABLE';
 export const REASONS_TABLE = 'REASONS_TABLE';
 export const EVENT_CODES_TABLE = 'EVENT_CODES_TABLE';
@@ -110,6 +110,11 @@ export const EventColumns = {
   SUCCESS_EVENT: 'successEvent',
 };
 
+export const VERSION_TABLE = 'VERSION_TABLE';
+export const VERSION_COLUMNS = {
+  VERSION_NO: 'versionNo'
+};
+
 // NEW CODE
 export interface BulkEvent {
   syncType: ExecEngineSyncType | DispatchSyncType;

package/src/manager/syncmanager/database.ts

@@ -1,93 +1,152 @@
-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';
+import type { ExecQuery } from '../../utils/Constants';
+import { openDatabaseSync, SQLiteDatabase } from 'expo-sqlite';
 
-let dbConnection: WebSQLDatabase | null;
-
-function openDatabase(): WebSQLDatabase {
-  return SQLite.openDatabase(DBConfig.DATABASE_NAME);
+// Legacy type for backward compatibility
+export interface SQLResultSet {
+  insertId?: number;
+  rowsAffected: number;
+  rows: {
+    _array: any[];
+    length: number;
+    item: (index: number) => any;
+  };
 }
 
-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;
+class SQLDatabase {
+  private static instance: SQLDatabase;
+  private db: SQLiteDatabase;
+
+  private constructor() {
+    this.db = openDatabaseSync(DBConfig.DATABASE_NAME);
+  }
+
+  public static getInstance(): SQLDatabase {
+    if (!SQLDatabase.instance) {
+      SQLDatabase.instance = new SQLDatabase();
     }
-    if (!dbConnection) dbConnection = openDatabase();
-    dbConnection.transaction((tx) => {
-      tx.executeSql(
-        query,
-        args,
-        (_, sqlResultSet) => {
-          resolve(sqlResultSet);
-        },
-        (_, sqlError) => {
-          reject(sqlError);
-          return false;
-        }
-      );
-    });
-  });
-}
+    return SQLDatabase.instance;
+  }
 
-export function executeBulkQuery(_queryData: ExecQuery[]): Promise<boolean> {
-  return new Promise((resolve, reject) => {
-    let _sqlResultSet: SQLResultSet[] = [];
+  executeSetDataQuery(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;
+      }
+      try {
+        const result = this.db.runSync(query, args);
+        const sqlResultSet: SQLResultSet = {
+          insertId: result.lastInsertRowId,
+          rowsAffected: result.changes,
+          rows: {
+            _array: [],
+            length: 0,
+            item: (index: number) => null
+          }
+        };
+        resolve(sqlResultSet);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
 
-    if (!dbConnection) dbConnection = openDatabase();
-    dbConnection.transaction(
-      (tx) => {
-        _queryData.forEach((_q) => {
-          tx.executeSql(
-            _q.query,
-            _q.args,
-            (_, sqlResultSet) => {
-              _sqlResultSet.push(sqlResultSet);
-              // resolve(sqlResultSet);
+  executeGetDataQuery(query: string, args: any[]): Promise<any> {
+    return new Promise((resolve, reject) => {
+      if (isEmptyOrBlank(query)) {
+        reject(new BaseError( BaseErrorCodes.InvalidArgumentError, 'SQL Query is null or empty'));
+        return;
+      }
+      
+      try {
+        const result = this.db.getAllSync(query, args);
+          const sqlResultSet: SQLResultSet = {
+            insertId: undefined,
+            rowsAffected: 0,
+            rows: {
+              _array: result,
+              length: result.length,
+              item: (index: number) => result[index] || null
             }
-            /* (_, sqlError) => {
-              _sqlError.push(sqlError);
-              // reject(sqlError);
-              return false;
-            } */
-          );
+          };
+          resolve(sqlResultSet);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  executeBulkQuery(_queryData: ExecQuery[]): Promise<boolean> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await this.db.withExclusiveTransactionAsync(async () => {
+          for (const _q of _queryData) {
+            this.db.runSync(_q.query, _q.args);
+          }
         });
-      },
-      (error) => {
+        
+        Logger.getInstance().logEvent(
+          'executeBulkQuery success: ',
+          JSON.stringify(_queryData.length + ' queries executed'),
+          LOG_TYPE.SDK_DEBUG
+        );
+        resolve(true);
+      } catch (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);
       }
-    );
-  });
+    });
+  }
+
+  /**
+    * Executes an array of SQL DML statements.
+    *
+    * @param {Array<{query: string, args: any[]}>} input - The array of queries to execute.
+    * @return {Promise<SQLResultSet>} A promise that resolves with the SQL result set.
+    */
+  executeStatementsInTxn(input: { sqlSmt: string; args: any[] }[]): Promise<SQLResultSet[]> {
+    return new Promise(async (resolve, reject) => {
+      if (input.some((_i) => isEmptyOrBlank(_i.sqlSmt))) {
+        reject(new Error('Statement is null or empty'));
+        return;
+      }
+
+      try {
+        const resultSet: SQLResultSet[] = [];
+        
+        await this.db.withExclusiveTransactionAsync(async () => {
+          for (const item of input) {
+            const result = await this.db.runAsync(item.sqlSmt, item.args);
+            const sqlResultSet: SQLResultSet = {
+              insertId: result.lastInsertRowId,
+              rowsAffected: result.changes,
+              rows: {
+                _array: [],
+                length: 0,
+                item: (index: number) => null
+              }
+            };
+            resultSet.push(sqlResultSet);
+          }
+        });
+
+        resolve(resultSet);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
 }
+
+const Database = SQLDatabase.getInstance();
+export default Database;