@os1-platform/dispatch-mobile 2.1.8 → 2.1.10

package/src/manager/syncmanager/document/DocumentSyncManager.ts

@@ -11,6 +11,9 @@ import BaseErrorCodes, {
 import Logger, { LOG_TYPE } from '../../../utils/Logger';
 import type { SQLResultSet } from 'expo-sqlite';
 import NetworkUtil from '../../../utils/NetworkUtil';
+import ETEventsManager from '../events/ETEventsManager';
+import { LAST_SYNCED_EVENT_ID, MAX_RETRY_COUNT, POD_DOC } from '../../syncmanager/constants';
+import EventsSyncManager from '../events/EventsSyncManager';
 import Marker, {
   Position,
   TextBackgroundType,
@@ -29,9 +32,8 @@ export default class DocumentSyncManager {
   private inProgress: boolean = false;
   private static instance: DocumentSyncManager;
   private docManager: DocumentManager | undefined;
-  private maxRetryCount: number = 3;
+  private maxRetryCount: number = MAX_RETRY_COUNT;
   private _retries = 0;
-
   get retries(): number {
     return this._retries;
   }
@@ -71,31 +73,97 @@ export default class DocumentSyncManager {
           if (documentRows?.length > 0) {
             await this.uploadDocToServer(documentRows[0]);
           } else {
+            let cta = 'startDocumentSync-NoData'
+            fireEventWithScreenName({
+              severityLevel: SeverityLevelValue.LOG,
+              eventName: SentryEventNameSdkConstants.APP_LOG,
+              screenName: cta,
+              cta: cta,
+              extraParams: {
+                msg:'No data to sync'
+              },
+            });
             Logger.getInstance().logEvent(
-              'startDocumentSync',
+              cta,
               'No data to sync',
-              LOG_TYPE.SDK_INFO
+              LOG_TYPE.SDK_ERROR
             );
           }
         } else {
+          let cta = 'startDocumentSync-NoNetwork'
+          fireEventWithScreenName({
+            severityLevel: SeverityLevelValue.LOG,
+            eventName: SentryEventNameSdkConstants.APP_LOG,
+            screenName: cta,
+            cta: cta,
+            extraParams: {
+              msg:'No Network'
+            },
+          });
           Logger.getInstance().logEvent(
-            'startDocumentSync',
+            cta,
             'No Network',
-            LOG_TYPE.SDK_INFO
+            LOG_TYPE.SDK_ERROR
           );
         }
       } catch (error: any) {
+        let cta = 'startDocumentSync-error'
+        fireEventWithScreenName({
+          severityLevel: SeverityLevelValue.LOG,
+          eventName: SentryEventNameSdkConstants.APP_LOG,
+          screenName: cta,
+          cta: cta,
+          extraParams: {
+            msg:flattenObject(error)
+          },
+        });
+        Logger.getInstance().logEvent(
+          cta,
+          flattenObject(error),
+          LOG_TYPE.SDK_ERROR
+        );
       } finally {
         this.inProgress = false;
-        if ((await this.isSyncPending()) && hasNetwork) {
+        let syncPending = await this.isSyncPending();
+        if (syncPending && hasNetwork) {
           await this.startDocumentSync();
+        }else{
+          let cta = 'startDocumentSync-error'
+          let extraParameters = {
+            hasNetwork: hasNetwork,
+            pending: syncPending,
+          };
+          fireEventWithScreenName({
+            severityLevel: SeverityLevelValue.LOG,
+            eventName: SentryEventNameSdkConstants.APP_LOG,
+            screenName: cta,
+            cta: cta,
+            extraParams: {
+              msg:flattenObject(extraParameters)
+            },
+          });
+          Logger.getInstance().logEvent(
+            cta,
+            flattenObject(extraParameters),
+            LOG_TYPE.SDK_ERROR
+          );
         }
       }
     } else {
+      let cta = 'startDocumentSync'
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.LOG,
+        eventName: SentryEventNameSdkConstants.APP_LOG,
+        screenName: cta,
+        cta: cta,
+        extraParams: {
+          msg:'sync already in progress or max count reached'
+        },
+      });
       Logger.getInstance().logEvent(
-        'startDocumentSync',
-        'sync already in progress ',
-        LOG_TYPE.SDK_INFO
+        cta,
+        'sync already in progress or max count reached',
+        LOG_TYPE.SDK_ERROR
       );
     }
   }
@@ -137,10 +205,20 @@ export default class DocumentSyncManager {
       );
     else {
       if (!this.docManager) {
+        let cta = 'insertDocument'
+        fireEventWithScreenName({
+          severityLevel: SeverityLevelValue.LOG,
+          eventName: SentryEventNameSdkConstants.APP_LOG,
+          screenName: cta,
+          cta: cta,
+          extraParams: {
+            msg:'INIT DOC SYNC AGAIN'
+          },
+        });
         Logger.getInstance().logEvent(
-          'insertDocument',
+          cta,
           'INIT DOC SYNC AGAIN',
-          LOG_TYPE.SDK_INFO
+          LOG_TYPE.SDK_ERROR
         );
         this.docManager = await DocumentManager.getInstance();
       }
@@ -170,14 +248,77 @@ export default class DocumentSyncManager {
     await this.startDocumentSync();
   }
 
-  private async updateDocument(documentRow: DocumentRow, fmsID: string) {
+  // private async updateDocument(documentRow: DocumentRow, fmsID: string) {
+  //   if (!this.docManager) this.docManager = await DocumentManager.getInstance();
+  //   try {
+  //     await this.docManager.markDocumentSynced(documentRow.id, fmsID);
+  //     let eventsManager = await ETEventsManager.getInstance();
+  //     let podId = POD_DOC + '_' + documentRow.id;
+  //     await eventsManager.markPODDocEventSynced(1, 1, podId);
+  //     EventsSyncManager.getInstance().startSync();
+  //   } catch (err: any) {
+  //     Logger.getInstance().logEvent(
+  //       'updateDocument',
+  //       err.message,
+  //       LOG_TYPE.SDK_WARNING
+  //     );
+  //   }
+  // }
+
+  // This function will update document row with attempt count and sync status
+  private async updateDocumentWithAttempt(
+    documentRow: DocumentRow,
+    fmsID: string,
+    attempt: number,
+    sync: number
+  ) {
     if (!this.docManager) this.docManager = await DocumentManager.getInstance();
     try {
-      await this.docManager.markDocumentSynced(documentRow.id, fmsID);
+      // Calling document row update method for attempt count and sync.
+      await this.docManager.markDocumentSyncedWithAttempt(
+        documentRow.id,
+        fmsID,
+        attempt,
+        sync
+      );
+      let eventsManager = await ETEventsManager.getInstance();
+      let podId = POD_DOC + '_' + documentRow.id;
+
+      let extraParameters = {
+        podId: podId,
+      };
+      Logger.getInstance().logEvent(
+        'updateDocumentWithAttempt-success',
+        flattenObject(extraParameters),
+        LOG_TYPE.SDK_ERROR
+      );
+      // Calling update method for attempt count and sync to update event row of type POD_DOC
+      await eventsManager.markPODDocEventSynced(sync, attempt, podId);
+      if(sync == 1){
+        const lastSyncedEventId = await Storage.getInstance().getSharedItem(
+          LAST_SYNCED_EVENT_ID
+        );
+        const syncEventId = parseInt(lastSyncedEventId) + 1;
+        await Storage.getInstance().setSharedItem(
+          LAST_SYNCED_EVENT_ID,
+          `${syncEventId}`
+        );
+      }
+      EventsSyncManager.getInstance().startSync();
     } catch (err: any) {
+      let cta = 'updateDocumentWithAttempt'
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.LOG,
+        eventName: SentryEventNameSdkConstants.APP_LOG,
+        screenName: cta,
+        cta: cta,
+        extraParams: {
+          msg:flattenObject(err)
+        },
+      });
       Logger.getInstance().logEvent(
-        'updateDocument',
-        err.message,
+        cta,
+        flattenObject(err),
         LOG_TYPE.SDK_WARNING
       );
     }
@@ -197,9 +338,19 @@ export default class DocumentSyncManager {
         processedPath
       );
     } catch (err: any) {
+      let cta = 'updateDocument-updateDocumentProcessedPath'
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.ERROR,
+        eventName: SentryEventNameSdkConstants.APP_ERROR,
+        screenName: cta,
+        cta: cta,
+        extraParams: {
+          msg:flattenObject(err)
+        },
+      });
       Logger.getInstance().logEvent(
-        'updateDocument',
-        err.message,
+        cta,
+        flattenObject(err),
         LOG_TYPE.SDK_WARNING
       );
     }
@@ -210,9 +361,19 @@ export default class DocumentSyncManager {
     try {
       await this.docManager.updateDocSyncError(documentRow.id, uploadError);
     } catch (err: any) {
+      let cta = 'updateDocError'
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.ERROR,
+        eventName: SentryEventNameSdkConstants.APP_ERROR,
+        screenName: cta,
+        cta: cta,
+        extraParams: {
+          msg:flattenObject(err)
+        },
+      });
       Logger.getInstance().logEvent(
-        'updateDocError',
-        err.message,
+        cta,
+        flattenObject(err),
         LOG_TYPE.SDK_WARNING
       );
     }
@@ -233,6 +394,25 @@ export default class DocumentSyncManager {
       documentRow.processed_file_path === null ||
       documentRow.processed_file_path === ''
     ) {
+      let cta = 'processImageData-started';
+      let extra = {
+        msg: 'processImageData-started',
+        fName: documentRow.file_name && documentRow.file_name.length != 0 ? documentRow.file_name.substring(4): '',
+        dName: documentRow.fms_folder_id && documentRow.fms_folder_id.length != 0 ? documentRow.fms_folder_id.substring(4): '',
+        dispId: documentRow.dispatch_id && documentRow.dispatch_id.length != 0 ? documentRow.dispatch_id.substring(9): ''
+      };
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.LOG,
+        eventName: SentryEventNameSdkConstants.APP_LOG,
+        screenName: cta,
+        cta: cta,
+        extraParams: extra,
+      });
+      Logger.getInstance().logEvent(
+        cta,
+        flattenObject(extra),
+        LOG_TYPE.SDK_ERROR
+      );
       let pFilePath = 'processed_' + documentRow.file_name; // File name for processed file.
       let strGeoStamp = documentRow.geo_timestamp; // Saved geostamp string
       let objGeoStamp = JSON.parse(strGeoStamp); // Conversion to geostamp object
@@ -293,6 +473,25 @@ export default class DocumentSyncManager {
         documentRow.processed_file_path = completeFilePath; 
       }
     }
+    let cta = 'processImageData-completed';
+    let extra = {
+      msg: 'processImageData-completed',
+      fName: documentRow.file_name && documentRow.file_name.length != 0 ? documentRow.file_name.substring(4): '',
+      dName: documentRow.fms_folder_id && documentRow.fms_folder_id.length != 0 ? documentRow.fms_folder_id.substring(4): '',
+      dispId: documentRow.dispatch_id && documentRow.dispatch_id.length != 0 ? documentRow.dispatch_id.substring(9): ''
+    };
+    fireEventWithScreenName({
+      severityLevel: SeverityLevelValue.LOG,
+      eventName: SentryEventNameSdkConstants.APP_LOG,
+      screenName: cta,
+      cta: cta,
+      extraParams: extra,
+    });
+    Logger.getInstance().logEvent(
+      cta,
+      flattenObject(extra),
+      LOG_TYPE.SDK_ERROR
+    );
     return documentRow;
   }
 
@@ -303,6 +502,25 @@ export default class DocumentSyncManager {
       documentRow.processed_file_path === null ||
       documentRow.processed_file_path === ''
     ) {
+      let cta = 'processBase64Data-started';
+      let extra = {
+        msg: 'processBase64Data-started',
+        fName: documentRow.file_name && documentRow.file_name.length != 0 ? documentRow.file_name.substring(4): '',
+        dName: documentRow.fms_folder_id && documentRow.fms_folder_id.length != 0 ? documentRow.fms_folder_id.substring(4): '',
+        dispId: documentRow.dispatch_id && documentRow.dispatch_id.length != 0 ? documentRow.dispatch_id.substring(9): ''
+      };
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.LOG,
+        eventName: SentryEventNameSdkConstants.APP_LOG,
+        screenName: cta,
+        cta: cta,
+        extraParams: extra,
+      });
+      Logger.getInstance().logEvent(
+        cta,
+        flattenObject(extra),
+        LOG_TYPE.SDK_ERROR
+      );
       let filePath = '';
       // If templrary base 64 file already exist then do not create again
       if (documentRow.file_path === null || documentRow.file_path === '') {
@@ -372,6 +590,25 @@ export default class DocumentSyncManager {
         documentRow.processed_file_path = splittedDase64Data[1];
       }
     }
+    let cta = 'processBase64Data-completed';
+    let extra = {
+      msg: 'processBase64Data-completed',
+      fName: documentRow.file_name && documentRow.file_name.length != 0 ? documentRow.file_name.substring(4): '',
+      dName: documentRow.fms_folder_id && documentRow.fms_folder_id.length != 0 ? documentRow.fms_folder_id.substring(4): '',
+      dispId: documentRow.dispatch_id && documentRow.dispatch_id.length != 0 ? documentRow.dispatch_id.substring(9): ''
+    };
+    fireEventWithScreenName({
+      severityLevel: SeverityLevelValue.LOG,
+      eventName: SentryEventNameSdkConstants.APP_LOG,
+      screenName: cta,
+      cta: cta,
+      extraParams: extra,
+    });
+    Logger.getInstance().logEvent(
+      cta,
+      flattenObject(extra),
+      LOG_TYPE.SDK_ERROR
+    );
     return documentRow;
   }
 
@@ -386,29 +623,84 @@ export default class DocumentSyncManager {
 
   private async uploadDocToServer(documentRow: DocumentRow) {
     try {
-      let docRow = await this.processPODData(documentRow);
+      let docRow = documentRow;
+      let cta = 'uploadDocToServer-geoStamp';
+      let geoStampAvailable = false
+      if(documentRow.geo_timestamp && documentRow.geo_timestamp.length != 0){
+        geoStampAvailable = true;
+        docRow = await this.processPODData(documentRow);
+      }
+      let extra = {
+        msg: geoStampAvailable ? "geoStamp availale" : 'geoStamp not availale',
+        fName: docRow.file_name && docRow.file_name.length != 0 ? docRow.file_name.substring(4): '',
+        dName: docRow.fms_folder_id && docRow.fms_folder_id.length != 0 ? docRow.fms_folder_id.substring(4): '',
+        dispId: docRow.dispatch_id && docRow.dispatch_id.length != 0 ? docRow.dispatch_id.substring(9): ''
+      };
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.LOG,
+        eventName: SentryEventNameSdkConstants.APP_LOG,
+        screenName: cta,
+        cta: cta,
+        extraParams: extra,
+      });
+      Logger.getInstance().logEvent(
+        cta,
+        flattenObject(extra),
+        LOG_TYPE.SDK_ERROR
+      );
       console.log('uploadDocToServer999:', docRow);
-      let fmsID = await this.documentHttpClient?.uploadDocument(documentRow);
+      let fmsID = await this.documentHttpClient?.uploadDocument(docRow);
 
       let extraParameters = {
         fmsID: fmsID ?? '',
-        fileName: docRow.file_name,
-        folderName: docRow.fms_folder_id
+        fName: docRow.file_name && docRow.file_name.length != 0 ? docRow.file_name.substring(4): '',
+        dName: docRow.fms_folder_id && docRow.fms_folder_id.length != 0 ? docRow.fms_folder_id.substring(4): '',
+        dispId: docRow.dispatch_id && docRow.dispatch_id.length != 0 ? docRow.dispatch_id.substring(9): ''
       };
       // TODO: SOLELY DEPENDS ON FMS_ID WHICH IS WRONG => IT SHOULD BE Response.status = 202
       if (fmsID) {
+          // Calling function updating document row along with attempt count and sync as true.
+        await this.updateDocumentWithAttempt(
+          documentRow,
+          fmsID,
+          this._retries + 1,
+          1
+        );
         this._retries = 0;
-        await this.updateDocument(docRow, fmsID);
+       // await this.updateDocument(docRow, fmsID);
       } else {
+        // Calling function updating document row withalong  attempt count and sync as false.
+        await this.updateDocumentWithAttempt(
+          documentRow,
+          '',
+          this._retries + 1,
+          0
+        );
         this._retries++;
+        let cta = 'uploadDocToServer-empty-fms-id'
+        fireEventWithScreenName({
+          severityLevel: SeverityLevelValue.LOG,
+          eventName: SentryEventNameSdkConstants.APP_LOG,
+          screenName: cta,
+          cta: cta,
+          extraParams: extraParameters,
+        });
         Logger.getInstance().logEvent(
-          'uploadDocToServer-empty-fms-id',
+          cta,
           flattenObject(extraParameters),
           LOG_TYPE.SDK_ERROR
         );
+        this.startSyncAfterMaxRetry(extraParameters, null);
         await this.updateDocError(docRow, 'Unexpected Error');
       }
     } catch (error: any) {
+        // Calling function updating document row withalong  attempt count and sync as false.
+        await this.updateDocumentWithAttempt(
+        documentRow,
+        '',
+        this._retries + 1,
+        0
+      );
       const cta = 'uploadDocToServer-error';
       fireEventWithScreenName({
         severityLevel: SeverityLevelValue.ERROR,
@@ -416,15 +708,16 @@ export default class DocumentSyncManager {
         screenName: cta,
         cta: cta,
         extraParams: {
-          error: error.message,
+          error: flattenObject(error),
         },
       });
-      this._retries++;
       Logger.getInstance().logEvent(
-        'uploadDocToServer-sync-error',
-        error.message,
+        cta,
+        flattenObject(error),
         LOG_TYPE.SDK_ERROR
       );
+      this._retries++;
+      this.startSyncAfterMaxRetry(null, error);
       await this.updateDocError(
         documentRow,
         JSON.stringify({
@@ -436,6 +729,34 @@ export default class DocumentSyncManager {
     }
   }
 
+  private async startSyncAfterMaxRetry(extraParameters:any, error:any){
+    if(this.retries >= this.maxRetryCount){
+      let cta = 'startSyncAfterMaxRetry-max-retry-reached'
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.LOG,
+        eventName: SentryEventNameSdkConstants.APP_LOG,
+        screenName: cta,
+        cta: cta,
+        extraParams: extraParameters ? extraParameters : error,
+      });
+      Logger.getInstance().logEvent(
+        cta,
+        extraParameters ? flattenObject(extraParameters) : error,
+        LOG_TYPE.SDK_ERROR
+      );
+      if (!this.docManager) {
+        this.docManager = await DocumentManager.getInstance();
+      }
+      let documentRows: DocumentRow[] =
+      await this.docManager.getUnsyncedDocument();
+      if (documentRows?.length > 0) {
+        await this.docManager.updateDocPriority(documentRows[0].id, documentRows[0].priority + 1);
+        this._retries = 0;
+        this.startDocumentSync();
+      }
+    }
+  }
+
   public async getAllDocuments(dispatchID?: string): Promise<DocumentRow[]> {
     if (!this.docManager) this.docManager = await DocumentManager.getInstance();
     return this.docManager.getAllDocuments(dispatchID);

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

@@ -21,7 +21,7 @@ import BaseErrorCodes, {
   InvalidArgumentsError,
 } from '../../../errors/ErrorCodes';
 import Logger, { LOG_TYPE } from '../../../utils/Logger';
-import { BULK_DATA_LIMIT } from '../constants';
+import { BULK_DATA_LIMIT, MAX_RETRY_COUNT, PROCESS_MAX_RETRIED_ROWS } from '../constants';
 import Storage from '../../../utils/storage';
 
 // NEW CODE
@@ -33,7 +33,7 @@ const SyncType = IDispatch.SyncType;
 
 export default class ETEventsManager {
   private static instance: ETEventsManager;
-  private maxRetryCount: number = 3;
+  private maxRetryCount: number = MAX_RETRY_COUNT;
   private _retries = 0;
 
   private constructor() {}
@@ -59,11 +59,20 @@ export default class ETEventsManager {
                 ${EVENTS_COLUMNS.DATA_LENGTH} INTEGER DEFAULT 0 NOT NULL,\
                 ${EVENTS_COLUMNS.META} TEXT NOT NULL,\
                 ${EVENTS_COLUMNS.SYNCED} INTEGER DEFAULT 0 NOT NULL,\
+                ${EVENTS_COLUMNS.ATTEMPT_COUNT} INTEGER DEFAULT 0 NOT NULL,\
                 ${EVENTS_COLUMNS.SYNC_ERROR} TEXT);`,
       []
     );
   }
 
+  // This is the function to insert POD_DOC type event in event table.
+  async insertPODDocEvent(dspID: string, syncType: string): Promise<void> {
+    await Database.executeQuery(
+      `INSERT INTO ${EVENTS_TABLE}(${EVENTS_COLUMNS.DISPATCH_ID},${EVENTS_COLUMNS.SYNC_TYPE},${EVENTS_COLUMNS.PAYLOAD},${EVENTS_COLUMNS.DATA_LENGTH},${EVENTS_COLUMNS.META},${EVENTS_COLUMNS.SYNCED},${EVENTS_COLUMNS.CONFIG},${EVENTS_COLUMNS.SYNC_ERROR}) values (?,?,?,?,?,?,?,?)`,
+      [dspID, syncType, '', 1, '', 0, '', '']
+    );
+  }
+
   async insertEvent(
     sequence: number,
     payload: string,
@@ -570,6 +579,15 @@ export default class ETEventsManager {
     );
   }
 
+  // This function will actualy update the POD_DOC type of event as sync along with attempt count.
+  async markPODDocEventSynced(sync: number, attempt:number, podDocId: String): Promise<void> {
+    if (!podDocId) throw new TypeError('podDocId cannot be null');
+    await Database.executeQuery(
+      `UPDATE ${EVENTS_TABLE} SET ${EVENTS_COLUMNS.SYNCED} = ?, ${EVENTS_COLUMNS.ATTEMPT_COUNT} = ? WHERE ${EVENTS_COLUMNS.SYNC_TYPE} = ?;`,
+      [sync,attempt,podDocId]
+    );
+  }
+
   async markEventSynced(id: number): Promise<void> {
     if (!id) throw new TypeError('Event ID cannot be null');
     await Database.executeQuery(
@@ -629,19 +647,35 @@ export default class ETEventsManager {
   }
 
   async getBulkRowsToSync(id: string, dispatchId: string): Promise<EventRow[]> {
-    const query = `SELECT * FROM \
-        (SELECT *, \ 
-          (SELECT SUM(${EVENTS_COLUMNS.DATA_LENGTH}) \
-              FROM ${EVENTS_TABLE} \
-                WHERE id <= t.id and ${EVENTS_COLUMNS.ID} > ${id} and ${EVENTS_COLUMNS.DISPATCH_ID} \ = '${dispatchId}' and ${EVENTS_COLUMNS.DATA_LENGTH} > 0 \
-                ) total \
-                FROM ${EVENTS_TABLE} t \
-                ) q \
-                WHERE total <= ${BULK_DATA_LIMIT} \
-                ORDER BY ${EVENTS_COLUMNS.ID};`;
-
-    const sqlResult = await Database.executeQuery(query, []);
-
-    return sqlResult.rows._array;
+    // If it is allowed max_retried_rows are allowed to process then it will refetch those data which are even have tried max attempt otherwise it will skip those events.
+    if(PROCESS_MAX_RETRIED_ROWS){
+      const query = `SELECT * FROM \
+      (SELECT *, \ 
+        (SELECT SUM(${EVENTS_COLUMNS.DATA_LENGTH}) \
+            FROM ${EVENTS_TABLE} \
+              WHERE id <= t.id and ${EVENTS_COLUMNS.ID} > ${id} and ${EVENTS_COLUMNS.DISPATCH_ID} \ = '${dispatchId}' and ${EVENTS_COLUMNS.DATA_LENGTH} > 0 and ${EVENTS_COLUMNS.SYNCED} = 0 \
+              ) total \
+              FROM ${EVENTS_TABLE} t \
+              ) q \
+              WHERE total <= ${BULK_DATA_LIMIT} \
+              ORDER BY ${EVENTS_COLUMNS.ID};`;
+
+      const sqlResult = await Database.executeQuery(query, []);
+      return sqlResult.rows._array;
+    }else{
+      const query = `SELECT * FROM \
+      (SELECT *, \ 
+        (SELECT SUM(${EVENTS_COLUMNS.DATA_LENGTH}) \
+            FROM ${EVENTS_TABLE} \
+              WHERE id <= t.id and ${EVENTS_COLUMNS.ID} > ${id} and ${EVENTS_COLUMNS.DISPATCH_ID} \ = '${dispatchId}' and ${EVENTS_COLUMNS.DATA_LENGTH} > 0 and ${EVENTS_COLUMNS.SYNCED} = 0 and ${EVENTS_COLUMNS.ATTEMPT_COUNT} < ${MAX_RETRY_COUNT} \
+              ) total \
+              FROM ${EVENTS_TABLE} t \
+              ) q \
+              WHERE total <= ${BULK_DATA_LIMIT} \
+              ORDER BY ${EVENTS_COLUMNS.ID};`;
+
+      const sqlResult = await Database.executeQuery(query, []);
+      return sqlResult.rows._array;
+    }
   }
 }