@os1-platform/dispatch-mobile 2.1.8 → 2.1.10

package/src/manager/syncmanager/events/EventsSyncManager.ts

@@ -6,7 +6,7 @@ import type {
   ExecEngineSyncType,
 } from '../DBConfig';
 import SyncHttpClient from './SyncHttpClient';
-import { isEmptyOrBlank } from '../../../utils/utils';
+import { flattenObject, isEmptyOrBlank } from '../../../utils/utils';
 import { BaseError } from '../../../errors/BaseError';
 import BaseErrorCodes, {
   InvalidArgumentsError,
@@ -20,7 +20,8 @@ const SyncType = IDispatch.SyncType;
 
 import DispatchSdkCache from '../../sdk/DispatchSdkCache';
 import Storage from '../../../utils/storage';
-import { LAST_SYNCED_EVENT_ID } from '../constants';
+import { LAST_SYNCED_EVENT_ID, MAX_RETRY_COUNT } from '../constants';
+import { POD_DOC } from '../constants';
 
 const TAG = 'EventsSyncManager';
 export default class EventsSyncManager {
@@ -29,7 +30,7 @@ export default class EventsSyncManager {
   private inProgress: boolean = false;
   private cScanInProgress: boolean = false;
   private eventsManager: ETEventsManager | undefined;
-  private maxRetryCount: number = 3;
+  private maxRetryCount: number = MAX_RETRY_COUNT;
   private _retries = 0;
 
   get retries(): number {
@@ -79,13 +80,38 @@ export default class EventsSyncManager {
             dspID ?? ''
           );
 
-          if (bulkEventRows.length) {
-            await this.syncBulkEventToServer(bulkEventRows, lastSyncedEventId);
+          var arrEventsToSync: EventRow[] = [];
+
+          // Filtering and removing those events which are type of POD_DOC
+          for (var index in bulkEventRows) {
+            let syncType = bulkEventRows[index].sync_type;
+            if (syncType.includes(POD_DOC)) {
+              break;
+            }
+            arrEventsToSync.push(bulkEventRows[index]);
+          }
+          if (arrEventsToSync.length) {
+            await this.syncBulkEventToServer(
+              arrEventsToSync,
+              lastSyncedEventId
+            );
+            let extraParameters = {
+              bulkEventRows: arrEventsToSync.length,
+            };
+            Logger.getInstance().logEvent(
+              'startSync-event-to-sync',
+              flattenObject(extraParameters),
+              LOG_TYPE.SDK_ERROR
+            );
           } else {
+            let extraParameters = {
+              bulkEventRows: bulkEventRows.length,
+              arrEventsToSync: arrEventsToSync.length
+            };
             Logger.getInstance().logEvent(
-              'startSync',
-              'No data to sync in Events Manager',
-              LOG_TYPE.SDK_INFO
+              'startSync-no-event-to-sync',
+              flattenObject(extraParameters),
+              LOG_TYPE.SDK_ERROR
             );
           }
 
@@ -97,24 +123,46 @@ export default class EventsSyncManager {
           // ];
           // await Promise.all(promises);
         } else {
+          let extraParameters = {
+            network: hasNetwork
+          };
           Logger.getInstance().logEvent(
-            'startSync',
-            'NO NETWORK AVAILABLE!!',
-            LOG_TYPE.SDK_INFO
+            'startSync-no network',
+            flattenObject(extraParameters),
+            LOG_TYPE.SDK_ERROR
           );
         }
       } catch (error: any) {
+        Logger.getInstance().logEvent(
+          'startSync-error',
+          flattenObject(error),
+          LOG_TYPE.SDK_ERROR
+        );
       } finally {
         this.inProgress = false;
         if ((await this.isSyncPending()) && hasNetwork) {
           await this.startSync();
+        }else{
+          let extraParameters = {
+            hasNetwork: hasNetwork,
+            pending: this.isSyncPending(),
+          };
+          Logger.getInstance().logEvent(
+            'startSync-inprogress-syncpending-hasnetwork',
+            flattenObject(extraParameters),
+            LOG_TYPE.SDK_ERROR
+          );
         }
       }
     } else {
+      let extraParameters = {
+        isProgress: this.inProgress,
+        retry: this._retries,
+      };
       Logger.getInstance().logEvent(
-        'startSync',
-        'WORKFLOW/TASK ALREADY IN PROGRESS || Max Retries reached',
-        LOG_TYPE.SDK_INFO
+        'startSync-inprogress-maxretries',
+        flattenObject(extraParameters),
+        LOG_TYPE.SDK_ERROR
       );
     }
   }
@@ -206,7 +254,7 @@ export default class EventsSyncManager {
       } catch (err: any) {
         Logger.getInstance().logEvent(
           'updateEventError',
-          err.message,
+          flattenObject(err),
           LOG_TYPE.SDK_WARNING
         );
       }
@@ -261,7 +309,7 @@ export default class EventsSyncManager {
       } catch (err: any) {
         Logger.getInstance().logEvent(
           'markEventSynced',
-          err.message,
+          flattenObject(err),
           LOG_TYPE.SDK_WARNING
         );
       }
@@ -270,6 +318,22 @@ export default class EventsSyncManager {
     await Promise.all(promises);
   }
 
+  // This function will insert POD_DOC type of event in event table.
+  public async insertPODDocEvent(
+    dspID: string,
+    syncType: string
+  ): Promise<void> {
+    if (isEmptyOrBlank(dspID) || isEmptyOrBlank(syncType))
+      throw new BaseError(
+        BaseErrorCodes.InvalidArgumentError,
+        InvalidArgumentsError
+      );
+    if (!this.eventsManager) {
+      this.eventsManager = await ETEventsManager.getInstance();
+    }
+    await this.eventsManager.insertPODDocEvent(dspID, syncType);
+  }
+
   public async insertEvent(
     sequence: number,
     payload: string,
@@ -377,60 +441,60 @@ export default class EventsSyncManager {
     } catch (err: any) {
       Logger.getInstance().logEvent(
         'getObjectiveSummary',
-        err.message,
+        flattenObject(err),
         LOG_TYPE.SDK_WARNING
       );
       return null;
     }
   }
 
-  private async syncEventToServer(
-    eventRows: EventRow[],
-    syncType: ExecEngineSyncType | DispatchSyncType
-  ) {
-    try {
-      const success = await this.syncHttpClient?.syncEvent(eventRows, syncType);
+  // private async syncEventToServer(
+  //   eventRows: EventRow[],
+  //   syncType: ExecEngineSyncType | DispatchSyncType
+  // ) {
+  //   try {
+  //     const success = await this.syncHttpClient?.syncEvent(eventRows, syncType);
 
-      if (success) {
-        this._retries = 0;
-        // NEW CODE
-        const lastSyncedEventId = await Storage.getInstance().getSharedItem(
-          LAST_SYNCED_EVENT_ID
-        );
-        const syncEventId = parseInt(lastSyncedEventId) + 1;
-        await Storage.getInstance().setSharedItem(
-          LAST_SYNCED_EVENT_ID,
-          `${syncEventId}`
-        );
+  //     if (success) {
+  //       this._retries = 0;
+  //       // NEW CODE
+  //       const lastSyncedEventId = await Storage.getInstance().getSharedItem(
+  //         LAST_SYNCED_EVENT_ID
+  //       );
+  //       const syncEventId = parseInt(lastSyncedEventId) + 1;
+  //       await Storage.getInstance().setSharedItem(
+  //         LAST_SYNCED_EVENT_ID,
+  //         `${syncEventId}`
+  //       );
 
-        // OLD CODE
-        await this.markEventSynced(eventRows);
-      } else {
-        this._retries++;
-        /* Logger.getInstance().logEvent(
-          'syncEventToServer',
-          `Syncing Error  ${syncType} :- ${JSON.stringify(eventRows)}`,
-          LOG_TYPE.SDK_ERROR
-        ); */
-        await this.updateEventError(eventRows, 'Unexpected error');
-      }
-    } catch (error: any) {
-      this._retries++;
-      /* Logger.getInstance().logEvent(
-        'syncEventToServer',
-        `Syncing Error ${syncType} :- ${JSON.stringify(eventRows)} -: ${
-          error.message
-        }`,
-        LOG_TYPE.SDK_ERROR
-      ); */
-      await this.updateEventError(
-        eventRows,
-        JSON.stringify({
-          error,
-        })
-      );
-    }
-  }
+  //       // OLD CODE
+  //       await this.markEventSynced(eventRows);
+  //     } else {
+  //       this._retries++;
+  //       /* Logger.getInstance().logEvent(
+  //         'syncEventToServer',
+  //         `Syncing Error  ${syncType} :- ${JSON.stringify(eventRows)}`,
+  //         LOG_TYPE.SDK_ERROR
+  //       ); */
+  //       await this.updateEventError(eventRows, 'Unexpected error');
+  //     }
+  //   } catch (error: any) {
+  //     this._retries++;
+  //     /* Logger.getInstance().logEvent(
+  //       'syncEventToServer',
+  //       `Syncing Error ${syncType} :- ${JSON.stringify(eventRows)} -: ${
+  //         error.message
+  //       }`,
+  //       LOG_TYPE.SDK_ERROR
+  //     ); */
+  //     await this.updateEventError(
+  //       eventRows,
+  //       JSON.stringify({
+  //         error,
+  //       })
+  //     );
+  //   }
+  // }
 
   private async syncBulkEventToServer(
     eventRows: EventRow[],
@@ -438,6 +502,14 @@ export default class EventsSyncManager {
   ) {
     try {
       const success = await this.syncHttpClient?.syncBulkEvent(eventRows);
+      let extraParameters = {
+        success: success,
+      };
+      Logger.getInstance().logEvent(
+        'syncBulkEventToServer-syncBulkEvent-success-true',
+        flattenObject(extraParameters),
+        LOG_TYPE.SDK_ERROR
+      );
       if (success) {
         this._retries = 0;
         // NEW CODE
@@ -450,24 +522,35 @@ export default class EventsSyncManager {
 
         // OLD CODE
         await this.markEventSynced(eventRows);
+
+        let extraParameters = {
+          retries: this._retries,
+          lastSyncEventId: syncEventId
+        };
+        Logger.getInstance().logEvent(
+          'syncBulkEventToServer-markEventSynced',
+          flattenObject(extraParameters),
+          LOG_TYPE.SDK_ERROR
+        );
       } else {
         this._retries++;
-        /* Logger.getInstance().logEvent(
-          'syncEventToServer',
-          `Syncing Error  ${syncType} :- ${JSON.stringify(eventRows)}`,
-          LOG_TYPE.SDK_ERROR
-        ); */
         await this.updateEventError(eventRows, 'Unexpected error');
+        let extraParameters = {
+          success: success,
+        };
+        Logger.getInstance().logEvent(
+          'syncBulkEventToServer-syncBulkEvent-success-false',
+          flattenObject(extraParameters),
+          LOG_TYPE.SDK_ERROR
+        );
       }
-    } catch (error) {
+    } catch (error: any) {
       this._retries++;
-      /* Logger.getInstance().logEvent(
-        'syncEventToServer',
-        `Syncing Error ${syncType} :- ${JSON.stringify(eventRows)} -: ${
-          error.message
-        }`,
+      Logger.getInstance().logEvent(
+        'syncBulkEventToServer-error',
+        flattenObject(error),
         LOG_TYPE.SDK_ERROR
-      ); */
+      );
       await this.updateEventError(
         eventRows,
         JSON.stringify({

package/src/manager/syncmanager/events/SyncHttpClient.ts

@@ -4,7 +4,7 @@ import GraphQLClient from '../../../network/GraphQLClient';
 import NetworkClient from '../../../network/NetworkClient';
 import { ExecEngineSyncType } from '../DBConfig';
 
-import { isEmptyOrBlank } from '../../../utils/utils';
+import { flattenObject, isEmptyOrBlank } from '../../../utils/utils';
 import { ENDPOINTS } from '../../../constants/apiConstants';
 import Logger, { LOG_TYPE } from '../../../utils/Logger';
 
@@ -182,6 +182,14 @@ export default class SyncHttpClient extends HttpClient {
           const requestBody = eventRow.map((event) => {
             return JSON.parse(event.payload);
           });
+          let extraParameters = {
+            endpoint: ENDPOINTS.BULK_JOB_UPDATE(eventRow[0].dispatch_id),
+          };
+          Logger.getInstance().logEvent(
+            'syncBulkEvent-request',
+            flattenObject(extraParameters),
+            LOG_TYPE.SDK_ERROR
+          );
           const response = await this.networkInstance.requestPost(
             ENDPOINTS.BULK_JOB_UPDATE(eventRow[0].dispatch_id),
             requestBody,
@@ -189,11 +197,32 @@ export default class SyncHttpClient extends HttpClient {
           );
 
           if (response.data.error) {
+            let extraParameters = {
+              error: response.data.error,
+            };
+            Logger.getInstance().logEvent(
+              'syncBulkEvent-api-error',
+              flattenObject(extraParameters),
+              LOG_TYPE.SDK_ERROR
+            );
             resolve(false);
           } else {
+            let extraParameters = {
+              response: '1',
+            };
+            Logger.getInstance().logEvent(
+              'syncBulkEvent-api-success',
+              flattenObject(extraParameters),
+              LOG_TYPE.SDK_ERROR
+            );
             resolve(true);
           }
         } catch (error: any) {
+          Logger.getInstance().logEvent(
+            'syncBulkEvent-error',
+            flattenObject(error),
+            LOG_TYPE.SDK_ERROR
+          );
           reject(error);
         }
       }, 0); //1000

package/src/models/auth.ts

@@ -41,3 +41,4 @@ export type LoginType =
 export interface Headers {
   requestId: string;
 }
+

package/src/models/sdk.ts

@@ -26,6 +26,7 @@ export interface DispatchSDKConfig {
       sdsIds: string[]
     ) => Promise<{ key: string; value: string[] }>;
     fetchDateTimeCallback?: () => Promise<string>;
+    tokenRefreshCallback?: () => Promise<string>;
   };
 }
 

package/src/network/NetworkClient.ts

@@ -2,6 +2,8 @@ import HttpClient from './client';
 import DispatchSdkCache from '../manager/sdk/DispatchSdkCache';
 import type { DispatchSDKConfig } from '../models/sdk';
 import type { Headers } from '../models/auth';
+import { isTokenExpired } from '../utils/utils';
+import callbackHandler from '../manager/sdk/callbacksHandler';
 
 const cache = DispatchSdkCache.getInstance();
 const cacheKeys = DispatchSdkCache.KEYS;
@@ -18,10 +20,17 @@ export default class NetworkClient extends HttpClient {
     requestBody: any,
     headers: Headers
   ) {
-    const sdkConfig = (await cache.getObjectFromCache(
+    let sdkConfig = (await cache.getObjectFromCache(
       cacheKeys.SDK_CONFIG
     )) as DispatchSDKConfig;
 
+    if(isTokenExpired(sdkConfig.accessToken)){
+      await callbackHandler.refresheAndUpdateToken();
+      sdkConfig = (await cache.getObjectFromCache(
+        cacheKeys.SDK_CONFIG
+      )) as DispatchSDKConfig;
+    }
+
     return this.instance.post(endpoint, requestBody, {
       headers: {
         'accept': 'application/json',
@@ -39,10 +48,17 @@ export default class NetworkClient extends HttpClient {
     requestBody: any,
     headers: Headers
   ) {
-    const sdkConfig = (await cache.getObjectFromCache(
+    let sdkConfig = (await cache.getObjectFromCache(
       cacheKeys.SDK_CONFIG
     )) as DispatchSDKConfig;
 
+    if(isTokenExpired(sdkConfig.accessToken)){
+      await callbackHandler.refresheAndUpdateToken();
+      sdkConfig = (await cache.getObjectFromCache(
+        cacheKeys.SDK_CONFIG
+      )) as DispatchSDKConfig;
+    }
+
     return this.instance.put(endpoint, requestBody, {
       headers: {
         'accept': 'application/json',

package/src/network/NetworkUtils.ts

@@ -1,12 +1,20 @@
 import DispatchSdkCache from '../manager/sdk/DispatchSdkCache';
 import type { Headers } from '../components/executiontasks/httpRequest/HttpRequestETSchema';
 import type { DispatchSDKConfig } from '../models/sdk';
+import { isTokenExpired } from '../utils/utils';
+import callbackHandler from '../manager/sdk/callbacksHandler';
 
 export async function getHeaders(contentType: string) {
   const cache = DispatchSdkCache.getInstance();
-  const sdkConfig: DispatchSDKConfig = await cache.getObjectFromCache(
+  let sdkConfig: DispatchSDKConfig = await cache.getObjectFromCache(
     DispatchSdkCache.KEYS.SDK_CONFIG
   );
+  if(isTokenExpired(sdkConfig.accessToken)){
+    await callbackHandler.refresheAndUpdateToken();
+    sdkConfig = await cache.getObjectFromCache(
+      DispatchSdkCache.KEYS.SDK_CONFIG
+    );
+  }
   const newHeadersObj = sdkConfig?.headers
     ? Object.fromEntries(
         Object.entries(sdkConfig.headers || {}).map(([k, v]) => [

package/src/network/client.ts

@@ -8,7 +8,7 @@ export default abstract class HttpClient {
   protected constructor(baseURL: string) {
     this.instance = axios.create({
       baseURL,
-      timeout: 15000, // timeout of 15s
+      timeout: 60000, // timeout of 60s
     });
 
     this._initializeResponseInterceptor();

package/src/ui/screens/DeliverScreen.tsx

@@ -18,6 +18,7 @@ import { GO_BACK_EVENT_CODE } from '../../constants/constants';
 import Helper from '../../utils/helper';
 import { ScreenNameSdkConstants, SentryEventNameSdkConstants, SeverityLevelValue } from '../../analytics/sentry/SentrySdkConstants';
 import { fireEventWithScreenName } from '../../analytics/sentry/SentryAnalyticsUtils';
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
 const DeliverScreen = ({
   navigation,
@@ -41,11 +42,11 @@ const DeliverScreen = ({
   useEffect(() => {
     (async () => {
       //fire sentry event
-      if(input?.title != null && input?.title?.toString()?.length > 0 && input?.title?.toString()?.toLowerCase()?.includes("return")){
-        fireEventWithScreenName({severityLevel:SeverityLevelValue.LOG, eventName:SentryEventNameSdkConstants.RETURN_ORDER_ET_OPENED, screenName:ScreenNameSdkConstants.RETURN_ORDER_ET_SCREEN});
-      }else{
-        fireEventWithScreenName({severityLevel:SeverityLevelValue.LOG, eventName:SentryEventNameSdkConstants.DELIVER_ET_OPENED, screenName:ScreenNameSdkConstants.DELIVER_ET_SCREEN});
-      }  
+      if (input?.title != null && input?.title?.toString()?.length > 0 && input?.title?.toString()?.toLowerCase()?.includes("return")) {
+        fireEventWithScreenName({ severityLevel: SeverityLevelValue.LOG, eventName: SentryEventNameSdkConstants.RETURN_ORDER_ET_OPENED, screenName: ScreenNameSdkConstants.RETURN_ORDER_ET_SCREEN });
+      } else {
+        fireEventWithScreenName({ severityLevel: SeverityLevelValue.LOG, eventName: SentryEventNameSdkConstants.DELIVER_ET_OPENED, screenName: ScreenNameSdkConstants.DELIVER_ET_SCREEN });
+      }
       //
       onTaskStart(
         nextState,

package/src/ui/screens/FormsScreen.tsx

@@ -16,6 +16,7 @@ import { AjvError } from '@rjsf/core';
 import Helper from '../../utils/helper';
 import { ScreenNameSdkConstants, SentryEventNameSdkConstants, SeverityLevelValue } from '../../analytics/sentry/SentrySdkConstants';
 import { fireEventWithScreenName } from '../../analytics/sentry/SentryAnalyticsUtils';
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
 const FormsScreen = ({
   route,
@@ -40,18 +41,19 @@ const FormsScreen = ({
 
   useEffect(() => {
     (async () => {
-      fireEventWithScreenName({severityLevel:SeverityLevelValue.LOG, eventName:SentryEventNameSdkConstants.FORM_ET_OPENED, screenName:ScreenNameSdkConstants.FORM_ET_SCREEN});      
+      fireEventWithScreenName({ severityLevel: SeverityLevelValue.LOG, eventName: SentryEventNameSdkConstants.FORM_ET_OPENED, screenName: ScreenNameSdkConstants.FORM_ET_SCREEN });
       onTaskStart(
         route.params[RouteParams.NEXT_STATES],
         route.params[RouteParams.ROOT_META_DATA].customEventsData
       );
 
       if (route.params[RouteParams.ROOT_META_DATA]) {
-        //Call objectiveDetails fn and fetch sds ids
-        const { contact } = await dispatchExecutor.getObjectiveTaskDetails(
-          mergedObjectiveId[0],
-          route.params[RouteParams.ROOT_META_DATA].statusFilter
-        );
+        
+       //Call objectiveDetails fn and fetch sds ids
+       const { contact } = await dispatchExecutor.getObjectiveTaskDetails(
+        mergedObjectiveId[0],
+        route.params[RouteParams.ROOT_META_DATA].statusFilter
+      );
 
         // run callback to get corresponding phone numbers
         const phoneNumbers = await callbackHandler.getPhoneNumbers(contact);

package/src/utils/SyncManagerUtils.ts

@@ -4,7 +4,7 @@ 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 { flattenObject, isEmptyOrBlank } from './utils';
 import { BaseError } from '../errors/BaseError';
 import ErrorCodes from '../errors/ErrorCodes';
 import GraphQLClient from '../network/GraphQLClient';
@@ -14,7 +14,9 @@ import type {
   ExecEngineSyncType,
 } from '../manager/syncmanager/DBConfig';
 import Storage from './storage';
+import { POD_DOC } from '../manager/syncmanager/constants';
 import LocationManager from '../manager/location/LocationManager';
+import  DocumentManager  from '../manager/syncmanager/document/DocumentManager';
 
 const keys = DispatchSdkCache.KEYS;
 const cache = DispatchSdkCache.getInstance();
@@ -113,12 +115,15 @@ 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();
+      // DocumentSyncManager.getInstance()
+      //   .clearSyncedDocs(prevDspID)
+      //   .then()
+      //   .catch();
       EventsSyncManager.getInstance().clearEventsDB().then().catch();
       await Storage.getInstance().clearShared();
+      await Storage.getInstance().deleteItem(keys.FMS_FOLDER);
+      let docManager = await DocumentManager.getInstance();
+      await docManager.truncateDocumentTable();
     }
   } catch (error: any) {
     Logger.getInstance().logEvent(
@@ -169,11 +174,41 @@ export async function insertDocumentInDB(
       geoTimeStampStr,
       processedFilePath
     );
+    if (response.insertId !== 0) {
+      let extraParameters = {
+        fileName: fileName,
+        insertId: response.insertId
+      };
+      Logger.getInstance().logEvent(
+        'insertDocumentInDB-insertDocument-inserted',
+        flattenObject(extraParameters),
+        LOG_TYPE.SDK_ERROR
+      );
+      // calling for inserting POD_DOC type document in Event table.
+      await EventsSyncManager.getInstance().insertPODDocEvent(
+        dspID ?? 'NULL',
+        POD_DOC + '_' + response.insertId // This will be inserted in sync_type column in Event table.
+      );
+    }else{
+      let extraParameters = {
+        fileName: fileName,
+      };
+      Logger.getInstance().logEvent(
+        'insertDocumentInDB-insertDocument-not-inserted',
+        flattenObject(extraParameters),
+        LOG_TYPE.SDK_ERROR
+      );
+      // calling for inserting POD_DOC type document in Event table.
+      await EventsSyncManager.getInstance().insertPODDocEvent(
+        dspID ?? 'NULL',
+        POD_DOC + '_' + response.insertId // This will be inserted in sync_type column in Event table.
+      );
+    }
     AppSyncManager.getInstance().startSDKSyncManager();
     return response.insertId;
   } catch (error: any) {
     Logger.getInstance().logEvent(
-      'insertDocumentInDB',
+      'insertDocumentInDB-error',
       error.message,
       LOG_TYPE.SDK_ERROR
     );