@os1-platform/dispatch-mobile 3.1.9 → 3.2.1

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;

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

@@ -1,7 +1,6 @@
 import { DOCUMENT_COLUMNS, DOCUMENT_TABLE, DocumentRow } from '../DBConfig';
 import { MAX_RETRY_COUNT, PROCESS_MAX_RETRIED_ROWS } from '../constants';
-import * as Database from '../database';
-import type { SQLResultSet } from 'expo-sqlite';
+import Database from '../database';
 
 export default class DocumentManager {
   private static instance: DocumentManager;
@@ -18,7 +17,7 @@ export default class DocumentManager {
   }
 
   public async init(): Promise<void> {
-    await Database.executeQuery(
+    await Database.executeSetDataQuery(
       `CREATE TABLE IF NOT EXISTS ${DOCUMENT_TABLE} (\
                     ${DOCUMENT_COLUMNS.ID} INTEGER PRIMARY KEY AUTOINCREMENT,\
                     ${DOCUMENT_COLUMNS.DATA} TEXT,\
@@ -41,7 +40,7 @@ export default class DocumentManager {
   }
 
   public async truncateDocumentTable(): Promise<void> {
-    await Database.executeQuery(`DELETE FROM ${DOCUMENT_TABLE};`, []);
+    await Database.executeSetDataQuery(`DELETE FROM ${DOCUMENT_TABLE};`, []);
   }
 
   public async insertDocument(
@@ -56,8 +55,8 @@ export default class DocumentManager {
     geoTimeStamp?: string | null,
     processedFilePath?: string | null,
     priority?: number
-  ): Promise<SQLResultSet> {
-    return await Database.executeQuery(
+  ): Promise<any> {
+    return await Database.executeSetDataQuery(
       `INSERT INTO ${DOCUMENT_TABLE}(\
                                     ${DOCUMENT_COLUMNS.DATA},\
                                     ${DOCUMENT_COLUMNS.DISPATCH_ID},\
@@ -89,13 +88,13 @@ export default class DocumentManager {
 
   public async getAllDocuments(dispatchID?: string): Promise<DocumentRow[]> {
     if (!dispatchID) {
-      const resultSet = await Database.executeQuery(
+      const resultSet = await Database.executeGetDataQuery(
         `SELECT * FROM ${DOCUMENT_TABLE};`,
         []
       );
       return resultSet.rows._array;
     } else {
-      const resultSet = await Database.executeQuery(
+      const resultSet = await Database.executeGetDataQuery(
         `SELECT * FROM ${DOCUMENT_TABLE}\
               WHERE ${DOCUMENT_COLUMNS.DISPATCH_ID} =?;`,
         [dispatchID]
@@ -106,14 +105,13 @@ export default class DocumentManager {
 
   public async getAllUnsyncedDocs(): Promise<DocumentRow[]> {
     if (PROCESS_MAX_RETRIED_ROWS) {
-      let resultSet = await Database.executeQuery(
-        `SELECT * from ${DOCUMENT_TABLE}\
-              WHERE ${DOCUMENT_COLUMNS.SYNCED} = 0;`,
+      let resultSet = await Database.executeGetDataQuery(
+        `SELECT * from ${DOCUMENT_TABLE} WHERE ${DOCUMENT_COLUMNS.SYNCED} = 0;`,
         []
       );
       return resultSet.rows._array;
     } else {
-      let resultSet = await Database.executeQuery(
+      let resultSet = await Database.executeGetDataQuery(
         `SELECT * from ${DOCUMENT_TABLE}\
               WHERE ${DOCUMENT_COLUMNS.SYNCED} = 0 AND ${DOCUMENT_COLUMNS.ATTEMPT_COUNT} < ${MAX_RETRY_COUNT};`,
         []
@@ -123,7 +121,7 @@ export default class DocumentManager {
   }
 
   public deleteAllSyncedDocuments(dispatchID: string) {
-    return Database.executeQuery(
+    return Database.executeSetDataQuery(
       `DELETE FROM ${DOCUMENT_TABLE}\
             WHERE ${DOCUMENT_COLUMNS.SYNCED} = 1 and ${DOCUMENT_COLUMNS.DISPATCH_ID} = ?;`,
       [dispatchID]
@@ -132,7 +130,7 @@ export default class DocumentManager {
 
   public async markDocumentSynced(id: number, fmsID: string): Promise<void> {
     if (!id || !fmsID) return;
-    await Database.executeQuery(
+    await Database.executeSetDataQuery(
       `UPDATE ${DOCUMENT_TABLE} SET ${DOCUMENT_COLUMNS.SYNCED} = 1,${DOCUMENT_COLUMNS.FMS_ID} = ?  WHERE ${DOCUMENT_COLUMNS.ID} = ?;`,
       [fmsID, id]
     );
@@ -146,7 +144,7 @@ export default class DocumentManager {
     sync: number
   ): Promise<void> {
     if (!id) return;
-    await Database.executeQuery(
+    await Database.executeSetDataQuery(
       `UPDATE ${DOCUMENT_TABLE} SET ${DOCUMENT_COLUMNS.SYNCED} = ?,${DOCUMENT_COLUMNS.FMS_ID} = ?,${DOCUMENT_COLUMNS.ATTEMPT_COUNT} = ?  WHERE ${DOCUMENT_COLUMNS.ID} = ?;`,
       [sync, fmsID, attempt, id]
     );
@@ -158,7 +156,7 @@ export default class DocumentManager {
     processedFilePath: String
   ): Promise<void> {
     if (!id || !processedFilePath) return;
-    await Database.executeQuery(
+    await Database.executeSetDataQuery(
       `UPDATE ${DOCUMENT_TABLE} SET ${DOCUMENT_COLUMNS.FILE_PATH} = ?, ${DOCUMENT_COLUMNS.PROCESSED_FILE_PATH} = ? WHERE ${DOCUMENT_COLUMNS.ID} = ?;`,
       [origialFilePath, processedFilePath, id]
     );
@@ -169,11 +167,8 @@ export default class DocumentManager {
     uploadError: string
   ): Promise<void> {
     if (!id) throw new TypeError('Document ID cannot be null');
-    await Database.executeQuery(
-      `UPDATE ${DOCUMENT_TABLE}\
-            SET \
-            ${DOCUMENT_COLUMNS.SYNC_ERROR} = ?\
-            WHERE ${DOCUMENT_COLUMNS.ID} = ?;`,
+    await Database.executeSetDataQuery(
+      `UPDATE ${DOCUMENT_TABLE} SET ${DOCUMENT_COLUMNS.SYNC_ERROR} = ? WHERE ${DOCUMENT_COLUMNS.ID} = ?;`,
       [uploadError, id]
     );
   }
@@ -183,7 +178,7 @@ export default class DocumentManager {
     priority: number
   ): Promise<void> {
     if (!id) throw new TypeError('Document ID cannot be null');
-    await Database.executeQuery(
+    await Database.executeSetDataQuery(
       `UPDATE ${DOCUMENT_TABLE}\
             SET \
             ${DOCUMENT_COLUMNS.PRIORITY} = ?\
@@ -196,7 +191,7 @@ export default class DocumentManager {
   public async getUnsyncedDocument(): Promise<DocumentRow[]> {
     // 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) {
-      let rs = await Database.executeQuery(
+      let rs = await Database.executeGetDataQuery(
         `SELECT * from ${DOCUMENT_TABLE}\
               WHERE ${DOCUMENT_COLUMNS.SYNCED} = 0 \
               ORDER BY ${DOCUMENT_COLUMNS.PRIORITY} ASC LIMIT 1;`,
@@ -204,7 +199,7 @@ export default class DocumentManager {
       );
       return rs.rows._array;
     } else {
-      let rs = await Database.executeQuery(
+      let rs = await Database.executeGetDataQuery(
         `SELECT * from ${DOCUMENT_TABLE}\
               WHERE ${DOCUMENT_COLUMNS.SYNCED} = 0 AND ${DOCUMENT_COLUMNS.ATTEMPT_COUNT} < ${MAX_RETRY_COUNT} \
               ORDER BY ${DOCUMENT_COLUMNS.PRIORITY} ASC LIMIT 1;`,

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

@@ -9,7 +9,6 @@ import BaseErrorCodes, {
   SyncManagerNotInitialized,
 } from '../../../errors/ErrorCodes';
 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';
@@ -162,7 +161,7 @@ export default class DocumentSyncManager {
     geoTimeStamp: string,
     processedFilePath: string,
     priority: number = 1
-  ): Promise<SQLResultSet> {
+  ): Promise<any> {
     if (
       isEmptyOrBlank(desc) ||
       isEmptyOrBlank(dspID) ||
@@ -407,100 +406,114 @@ export default class DocumentSyncManager {
 
   // This function will generate overlay base64 data and update documents table for processed_file_path columns with overlayed base64 data.
   private async processBase64Data(documentRow: DocumentRow) {
+    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) : ''
+    };
     if (
       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 === '') {
-        const imagePath = `${RNFS.TemporaryDirectoryPath}/${documentRow.file_name}`;
-        await RNFS.writeFile(imagePath, documentRow.data, 'base64'); // Write file to temprary location
-        filePath = imagePath;
-        // If file generated frommbase64 data does not have file:// then we are adding manually.
-        if (!imagePath.includes('file')) {
-          filePath = `file://${imagePath}`;
+      try {
+        fireEventWithScreenName({
+          severityLevel: SeverityLevelValue.LOG,
+          eventName: SentryEventNameSdkConstants.APP_LOG,
+          screenName: cta,
+          cta: cta,
+          extraParams: extra,
+        });
+        Logger.getInstance().logEvent(
+          cta,
+          flattenObject(extra),
+          LOG_TYPE.SDK_ERROR
+        );
+
+        // If templrary base 64 file already exist then do not create again
+        if (documentRow.file_path === null || documentRow.file_path === '') {
+          const imagePath = `${RNFS.TemporaryDirectoryPath}/${documentRow.file_name}`;
+          await RNFS.writeFile(imagePath, documentRow.data, 'base64'); // Write file to temprary location
+          filePath = imagePath;
+          // If file generated frommbase64 data does not have file:// then we are adding manually.
+          if (!imagePath.includes('file')) {
+            filePath = `file://${imagePath}`;
+          }
+          documentRow.file_path = filePath;
+        } else {
+          filePath = documentRow.file_path;
         }
-        documentRow.file_path = filePath;
-      } else {
-        filePath = documentRow.file_path;
-      }
-      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
-      let dateTime = objGeoStamp.dateTime; // Date time stamp in UTC format
-      let lat = objGeoStamp.lat; // Latitide
-      let lng = objGeoStamp.lng; // Longitude
-      let accuracy = objGeoStamp.accuracy; // Location accuracy
-      let strDMS = latlngToDms(`${lat}, ${lng}`); // Location in degree format
-      let strDMSWithAccuracy = strDMS;
-      if (accuracy !== '') {
-        strDMSWithAccuracy = strDMS + ' (Accuracy: ' + accuracy + 'm)'; // Appedning accuracy in location 
-      }
-      const options = {
-        backgroundImage: {
-          src: filePath, // Image for overlay
-          scale: 1,
-        },
-        watermarkTexts: [
-          {
-            text: `${dateTime}\n${strDMSWithAccuracy}`, // Ooverlay text
-            position: {
-              position: Position.topLeft, // Overlay text position
-            },
-            style: { // Style for overlay
-              color: '#ffffff',
-              fontSize: 14,
-              fontName: 'Arial',
-              textBackgroundStyle: {
-                padding: '1% 1%',
-                type: TextBackgroundType.none,
-                color: '#444444CC',
+        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
+        let dateTime = objGeoStamp.dateTime; // Date time stamp in UTC format
+        let lat = objGeoStamp.lat; // Latitide
+        let lng = objGeoStamp.lng; // Longitude
+        let accuracy = objGeoStamp.accuracy; // Location accuracy
+        let strDMS = latlngToDms(`${lat}, ${lng}`); // Location in degree format
+        let strDMSWithAccuracy = strDMS;
+        if (accuracy !== '') {
+          strDMSWithAccuracy = strDMS + ' (Accuracy: ' + accuracy + 'm)'; // Appedning accuracy in location 
+        }
+        const options = {
+          backgroundImage: {
+            src: filePath, // Image for overlay
+            scale: 1,
+          },
+          watermarkTexts: [
+            {
+              text: `${dateTime}\n${strDMSWithAccuracy}`, // Ooverlay text
+              position: {
+                position: Position.topLeft, // Overlay text position
+              },
+              style: { // Style for overlay
+                color: '#ffffff',
+                fontSize: 14,
+                fontName: 'Arial',
+                textBackgroundStyle: {
+                  padding: '1% 1%',
+                  type: TextBackgroundType.none,
+                  color: '#444444CC',
+                },
               },
             },
-          },
-        ],
-        scale: 1,
-        quality: 100,
-        filename: pFilePath,
-        saveFormat: ImageFormat.base64, // Saving in base6 format
-      };
-      let processedBase64 = await Marker.markText(options); // Generating overlay image
-      if (processedBase64 !== null && processedBase64 !== '') {
-        // Fetching base64 data from processed data.
-        var splittedDase64Data = processedBase64.split(
-          'data:image/png;base64,'
-        );
-        // Updating document document table with overlayed base64 data
+          ],
+          scale: 1,
+          quality: 100,
+          filename: pFilePath,
+          saveFormat: ImageFormat.base64, // Saving in base6 format
+        };
+        let processedBase64 = await Marker.markText(options); // Generating overlay image
+        if (processedBase64 !== null && processedBase64 !== '') {
+          // Fetching base64 data from processed data.
+          var splittedDase64Data = processedBase64.split(
+            'data:image/png;base64,'
+          );
+          // Updating document document table with overlayed base64 data
+          await this.updateDocumentProcessedPath(
+            documentRow,
+            filePath,
+            splittedDase64Data[1]
+          );
+          documentRow.processed_file_path = splittedDase64Data[1];
+        }
+      } catch (error: any) {
+        console.log('====================================');
+        console.log('processBase64Data-error:', error);
+        console.log('====================================');
+        // Updating document document table with original base64 data
         await this.updateDocumentProcessedPath(
           documentRow,
           filePath,
-          splittedDase64Data[1]
+          filePath
         );
-        documentRow.processed_file_path = splittedDase64Data[1];
+        documentRow.processed_file_path = "";
       }
     }
-    let cta = 'processBase64Data-completed';
-    let extra = {
+    cta = 'processBase64Data-completed';
+    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) : '',