@os1-platform/dispatch-mobile 2.1.6 → 2.1.8

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

@@ -6,6 +6,11 @@ import { FileSystemUploadResult, FileSystemUploadType } from 'expo-file-system';
 import DispatchSdkCache from '../../sdk/DispatchSdkCache';
 import Logger, { LOG_TYPE } from '../../../utils/Logger';
 import type { DispatchSDKConfig } from '../../../models/sdk';
+import RNFS from 'react-native-fs';
+import { stat } from 'react-native-fs';
+import { ScreenNameSdkConstants, SentryEventNameSdkConstants, SeverityLevelValue } from '../../../analytics/sentry/SentrySdkConstants';
+import { fireEventWithScreenName } from '../../../analytics/sentry/SentryAnalyticsUtils';
+import { flattenObject } from '../../../utils/utils';
 
 const cache = DispatchSdkCache.getInstance();
 const cacheKeys = DispatchSdkCache.KEYS;
@@ -16,6 +21,33 @@ export default class DocumentHttpClient extends HttpClient {
   public async uploadDocument(document: DocumentRow): Promise<string | null> {
     if (document.base64 && document.data != null) {
       const response = await this.uploadBase64File(document);
+
+      let info = '';
+      if (
+        response &&
+        response.data !== null &&
+        response.data.body !== null &&
+        response.status !== 202
+      ) {
+        let body = response.data.body;
+        info = body.substring(40);
+      } else {
+        info = String(response.status);
+      }
+      let extraParameters = { response: info };
+
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.LOG,
+        eventName: SentryEventNameSdkConstants.API_RESPONSE,
+        screenName: 'Upload_Base64_File_Response',
+        extraParams: extraParameters,
+      });
+
+      Logger.getInstance().logEvent(
+        'uploadBase64FileResponse',
+        flattenObject(extraParameters),
+        LOG_TYPE.SDK_ERROR
+      );
       if (
         response &&
         response.data != null &&
@@ -29,10 +61,29 @@ export default class DocumentHttpClient extends HttpClient {
       }
     } else {
       const uploadResponse = await this.uploadBinaryFile(document);
+      let info = '';
+      if (
+        uploadResponse &&
+        uploadResponse.body !== null &&
+        uploadResponse.status !== 202
+      ) {
+        let body = uploadResponse.body;
+        info = body.substring(40);
+      } else {
+        info = String(uploadResponse.status);
+      }
+      let extraParams = { response: info };
+
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.LOG,
+        eventName: SentryEventNameSdkConstants.API_RESPONSE,
+        screenName: 'Upload_Binary_File_Response',
+        extraParams: extraParams,
+      });
       Logger.getInstance().logEvent(
-        'uploadDocument',
-        JSON.stringify(uploadResponse),
-        LOG_TYPE.SDK_INFO
+        'uploadBinaryFileResponse',
+        flattenObject(extraParams),
+        LOG_TYPE.SDK_ERROR
       );
       if (
         uploadResponse != null &&
@@ -40,6 +91,8 @@ export default class DocumentHttpClient extends HttpClient {
         uploadResponse.body != null
       ) {
         FileSystem.deleteAsync(document.file_path).then().catch(); // WE DELETE FILE HERE
+        FileSystem.deleteAsync(document.processed_file_path).then().catch(); // WE DELETE FILE HERE
+
         return JSON.parse(uploadResponse.body)?.data?.id;
       } else {
         return null;
@@ -47,11 +100,20 @@ export default class DocumentHttpClient extends HttpClient {
     }
   }
 
+ // This function will upload processed base64 data (overlayed base64 data ) if exist otherwise will uplaod original base 64 data for pod signature.
   public async uploadBase64File(document: DocumentRow): Promise<AxiosResponse> {
+    let dataToUpload = document.data;
+    if (
+      document.processed_file_path !== null &&
+      document.processed_file_path !== undefined &&
+      document.processed_file_path !== ''
+    ) {
+      dataToUpload = document.processed_file_path;
+    }
     let requestBody = JSON.stringify({
       file: {
         type: 'FILE',
-        data: document.data,
+        data: dataToUpload,
       },
       description: document.desc,
       tags: [
@@ -65,6 +127,22 @@ export default class DocumentHttpClient extends HttpClient {
     const sdkConfig = (await cache.getObjectFromCache(
       cacheKeys.SDK_CONFIG
     )) as DispatchSDKConfig;
+    let extraParams = {
+      fileName: document.file_name,
+      folderName: document.fms_folder_id,
+    };
+
+    fireEventWithScreenName({
+      severityLevel: SeverityLevelValue.LOG,
+      eventName: SentryEventNameSdkConstants.API_CALL,
+      screenName: 'Upload_Base64_File_Request',
+      extraParams: extraParams,
+    });
+    Logger.getInstance().logEvent(
+      'uploadBase64FileRequest',
+      flattenObject(extraParams),
+      LOG_TYPE.SDK_ERROR
+    );
     return this.instance.post(
       `/api/folders/${document.fms_folder_id}/files`,
       requestBody,
@@ -79,15 +157,37 @@ export default class DocumentHttpClient extends HttpClient {
       }
     );
   }
+
+  // This function will upload processed (overlayed file) if exist otherwise will uplaod original file for pod images.
   private async uploadBinaryFile(
     document: DocumentRow
   ): Promise<FileSystemUploadResult> {
     const sdkConfig = (await cache.getObjectFromCache(
       cacheKeys.SDK_CONFIG
     )) as DispatchSDKConfig;
+    let filePathToUpload = document.file_path;
+    let processedFileExist = await RNFS.exists(document.processed_file_path);
+    if (processedFileExist) {
+      filePathToUpload = document.processed_file_path;
+    }
     const url =
       sdkConfig.tenantBaseURL + `/api/folders/${document.fms_folder_id}/files`;
-    return FileSystem.uploadAsync(url, document.file_path, {
+    let extraParams = {
+      fileName: document.file_name,
+      folderName: document.fms_folder_id,
+    };
+    fireEventWithScreenName({
+      severityLevel: SeverityLevelValue.LOG,
+      eventName: SentryEventNameSdkConstants.API_CALL,
+      screenName: 'Upload_Binary_File_Request',
+      extraParams: extraParams,
+    });
+    Logger.getInstance().logEvent(
+      'uploadBinaryFileRequest',
+      flattenObject(extraParams),
+      LOG_TYPE.SDK_ERROR
+    );
+    return FileSystem.uploadAsync(url, filePathToUpload, {
       headers: {
         'accept': 'application/json',
         'Content-Type': 'multipart/form-data',

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

@@ -31,11 +31,17 @@ export default class DocumentManager {
                     ${DOCUMENT_COLUMNS.FMS_FOLDER_ID} TEXT,\
                     ${DOCUMENT_COLUMNS.PRIORITY} INTEGER NOT NULL DEFAULT 1,\
                     ${DOCUMENT_COLUMNS.SYNC_ERROR} TEXT,\
+                    ${DOCUMENT_COLUMNS.GEO_TIMESTAMP} TEXT,\
+                    ${DOCUMENT_COLUMNS.PROCESSED_FILE_PATH} TEXT,\
                     ${DOCUMENT_COLUMNS.DESCRIPTION} TEXT);`,
       []
     );
   }
 
+  public async truncateDocumentTable(): Promise<void> {
+    await Database.executeQuery(`DELETE FROM ${DOCUMENT_TABLE};`, []);
+  }
+
   public async insertDocument(
     fmsFolderID: string | null,
     desc: string,
@@ -47,8 +53,11 @@ export default class DocumentManager {
     fileType: string,
     data?: string | null,
     filePath?: string | null,
+    geoTimeStamp?: string | null,
+    processedFilePath?: string | null,
     priority?: number
   ): Promise<SQLResultSet> {
+    console.log('insertDocument2:', fmsFolderID);
     return await Database.executeQuery(
       `INSERT INTO ${DOCUMENT_TABLE}(\
                                     ${DOCUMENT_COLUMNS.DATA},\
@@ -59,8 +68,10 @@ export default class DocumentManager {
                                     ${DOCUMENT_COLUMNS.FILE_NAME},\
                                     ${DOCUMENT_COLUMNS.FILE_TYPE},\
                                     ${DOCUMENT_COLUMNS.DESCRIPTION},\
-                                    ${DOCUMENT_COLUMNS.PRIORITY}) \
-                                    values (?,?,?,?,?,?,?,?,?)`,
+                                    ${DOCUMENT_COLUMNS.PRIORITY},\
+                                    ${DOCUMENT_COLUMNS.GEO_TIMESTAMP},\
+                                    ${DOCUMENT_COLUMNS.PROCESSED_FILE_PATH}) \
+                                    values (?,?,?,?,?,?,?,?,?,?,?)`,
       [
         data,
         dspID,
@@ -71,6 +82,8 @@ export default class DocumentManager {
         fileType,
         desc,
         priority ? priority : 1,
+        geoTimeStamp,
+        processedFilePath,
       ]
     );
   }
@@ -117,6 +130,19 @@ export default class DocumentManager {
     );
   }
 
+    // This function is updating processed_file_path column for the base64 overlayed data and overlayed image file for POD. Also if it is base 64 then it is also storing temprary file path in file_path as original bae64 image.
+  public async updateProcesedFilePath(
+    id: number,
+    origialFilePath: String,
+    processedFilePath: String
+  ): Promise<void> {
+    if (!id || !processedFilePath) return;
+    await Database.executeQuery(
+      `UPDATE ${DOCUMENT_TABLE} SET ${DOCUMENT_COLUMNS.FILE_PATH} = ?, ${DOCUMENT_COLUMNS.PROCESSED_FILE_PATH} = ? WHERE ${DOCUMENT_COLUMNS.ID} = ?;`,
+      [origialFilePath, processedFilePath, id]
+    );
+  }
+
   public async updateDocSyncError(
     id: number,
     uploadError: string

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

@@ -1,7 +1,7 @@
 import type { DocumentRow } from '../DBConfig';
 import DocumentManager from './DocumentManager';
 import DocumentHttpClient from './DocumentHttpClient';
-import { isEmptyOrBlank } from '../../../utils/utils';
+import { isEmptyOrBlank, flattenObject } from '../../../utils/utils';
 import { BaseError } from '../../../errors/BaseError';
 import BaseErrorCodes, {
   InvalidArgumentsError,
@@ -11,6 +11,18 @@ import BaseErrorCodes, {
 import Logger, { LOG_TYPE } from '../../../utils/Logger';
 import type { SQLResultSet } from 'expo-sqlite';
 import NetworkUtil from '../../../utils/NetworkUtil';
+import Marker, {
+  Position,
+  TextBackgroundType,
+  ImageFormat,
+} from 'react-native-image-marker';
+import RNFS from 'react-native-fs';
+import Storage from '../../../utils/storage';
+import { Platform } from 'react-native';
+import { ScreenNameSdkConstants, SentryEventNameSdkConstants, SeverityLevelValue } from '../../../analytics/sentry/SentrySdkConstants';
+import { fireEventWithScreenName } from '../../../analytics/sentry/SentryAnalyticsUtils';
+const latlngToDms = require('latlng-to-dms');
+
 
 export default class DocumentSyncManager {
   private documentHttpClient: DocumentHttpClient | undefined;
@@ -105,6 +117,8 @@ export default class DocumentSyncManager {
     filePath: string | null,
     fileType: string,
     fileName: string,
+    geoTimeStamp: string,
+    processedFilePath: string,
     priority: number = 1
   ): Promise<SQLResultSet> {
     if (
@@ -130,6 +144,7 @@ export default class DocumentSyncManager {
         );
         this.docManager = await DocumentManager.getInstance();
       }
+      console.log('insertDocument1:',fmsFolderID);
       let insertResponse = await this.docManager?.insertDocument(
         fmsFolderID,
         desc,
@@ -141,6 +156,8 @@ export default class DocumentSyncManager {
         fileType,
         data,
         filePath,
+        geoTimeStamp,
+        processedFilePath,
         priority
       );
       return insertResponse;
@@ -166,6 +183,28 @@ export default class DocumentSyncManager {
     }
   }
 
+    // This function is updating processed_file_path column for the base64 overlayed data and overlayed image file for POD. Also if it is base 64 then it is also storing temprary file path in file_path as original bae64 image.
+  private async updateDocumentProcessedPath(
+    documentRow: DocumentRow,
+    origialFilePath: String,
+    processedPath: String
+  ) {
+    if (!this.docManager) this.docManager = await DocumentManager.getInstance();
+    try {
+      await this.docManager.updateProcesedFilePath(
+        documentRow.id,
+        origialFilePath,
+        processedPath
+      );
+    } catch (err: any) {
+      Logger.getInstance().logEvent(
+        'updateDocument',
+        err.message,
+        LOG_TYPE.SDK_WARNING
+      );
+    }
+  }
+
   private async updateDocError(documentRow: DocumentRow, uploadError: string) {
     if (!this.docManager) this.docManager = await DocumentManager.getInstance();
     try {
@@ -187,23 +226,199 @@ export default class DocumentSyncManager {
     }
   }
 
+  // This function will generate overlay image and update documents table for processed_file_path columns with overlayed image path.
+  private async processImageData(documentRow: DocumentRow) {
+    // If processed_file_path of overlayed image already existing then do not generate it again.
+    if (
+      documentRow.processed_file_path === null ||
+      documentRow.processed_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 
+      }
+      let fontSize = 14;
+      if (Platform.OS !== 'android') {
+        fontSize = 28;
+      }
+      const options = {
+        backgroundImage: { // Image for overlay
+          src: documentRow.file_path,
+          scale: 1,
+        },
+        watermarkTexts: [ 
+          {
+            text: `${dateTime}\n${strDMSWithAccuracy}`,  //Overlay text
+            position: {
+              position: Position.topLeft, // Overlay text position
+            },
+            style: { // Style for overlay
+              color: '#ffffff',
+              fontSize: fontSize,
+              fontName: 'Arial',
+              textBackgroundStyle: {
+                padding: '1% 1%',
+                type: TextBackgroundType.none,
+                color: '#444444CC',
+              },
+            },
+          },
+        ],
+        scale: 0,
+        quality: 100, 
+        filename: pFilePath,
+        saveFormat: ImageFormat.jpg, // Saving in jpeg format
+      };
+      let processedFilePath = await Marker.markText(options); // Generating overlay image
+      if (processedFilePath !== null && processedFilePath !== '') {
+        let completeFilePath = processedFilePath;
+        // If processd image file path does not have prefix file:// then we are addding manually
+        if (!processedFilePath.includes('file')) {
+          completeFilePath = 'file://' + processedFilePath;
+        }
+        // Updating document document table with overlayed image path
+        this.updateDocumentProcessedPath(
+          documentRow,
+          documentRow.file_path, //original file path catprued from camera
+          completeFilePath // completeFilePath is the path with file:// of processed file 
+        );
+        documentRow.processed_file_path = completeFilePath; 
+      }
+    }
+    return documentRow;
+  }
+
+  // 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) {
+        // If base64 overlayed data already existing then do not generate it again.
+    if (
+      documentRow.processed_file_path === null ||
+      documentRow.processed_file_path === ''
+    ) {
+      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}`;
+        }
+        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',
+              },
+            },
+          },
+        ],
+        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];
+      }
+    }
+    return documentRow;
+  }
+
+  // This function will calling respective overlay method for base64 (for signature POD) or image (for image POD).
+  private async processPODData(documentRow: DocumentRow) {
+    if (documentRow.base64 && documentRow.data != null) {
+      return await this.processBase64Data(documentRow);
+    } else {
+      return await this.processImageData(documentRow);
+    }
+  }
+
   private async uploadDocToServer(documentRow: DocumentRow) {
     try {
+      let docRow = await this.processPODData(documentRow);
+      console.log('uploadDocToServer999:', docRow);
       let fmsID = await this.documentHttpClient?.uploadDocument(documentRow);
+
+      let extraParameters = {
+        fmsID: fmsID ?? '',
+        fileName: docRow.file_name,
+        folderName: docRow.fms_folder_id
+      };
       // TODO: SOLELY DEPENDS ON FMS_ID WHICH IS WRONG => IT SHOULD BE Response.status = 202
       if (fmsID) {
         this._retries = 0;
-        await this.updateDocument(documentRow, fmsID);
+        await this.updateDocument(docRow, fmsID);
       } else {
         this._retries++;
         Logger.getInstance().logEvent(
-          'uploadDocToServer-sync-error',
-          'Unexpected Error',
+          'uploadDocToServer-empty-fms-id',
+          flattenObject(extraParameters),
           LOG_TYPE.SDK_ERROR
         );
-        await this.updateDocError(documentRow, 'Unexpected Error');
+        await this.updateDocError(docRow, 'Unexpected Error');
       }
     } catch (error: any) {
+      const cta = 'uploadDocToServer-error';
+      fireEventWithScreenName({
+        severityLevel: SeverityLevelValue.ERROR,
+        eventName: SentryEventNameSdkConstants.API_ERROR,
+        screenName: cta,
+        cta: cta,
+        extraParams: {
+          error: error.message,
+        },
+      });
       this._retries++;
       Logger.getInstance().logEvent(
         'uploadDocToServer-sync-error',

package/src/models/sdk.ts

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

package/src/utils/ExecTaskUtils.ts

@@ -149,7 +149,7 @@ export function onTaskStart(
     let lastLocation = LocationManager.getInstance().getLastLocation();
     let location = {
       latitude: lastLocation.latitude,
-      longitude: lastLocation.longitude
+      longitude: lastLocation.longitude,
     }
     console.log("onTaskStart:lastLocation:",location)
     await cache.setKeyInCache(keys.TASK_START_TIME, Date.now().toString());

package/src/utils/SyncManagerUtils.ts

@@ -14,6 +14,7 @@ import type {
   ExecEngineSyncType,
 } from '../manager/syncmanager/DBConfig';
 import Storage from './storage';
+import LocationManager from '../manager/location/LocationManager';
 
 const keys = DispatchSdkCache.KEYS;
 const cache = DispatchSdkCache.getInstance();
@@ -135,8 +136,23 @@ export async function insertDocumentInDB(
   // objRef: string,
   base64Image: string | null,
   imageDesc: string,
-  filePath: string | null
+  filePath: string | null,
+  dateTime: string | null,
+  lat: string,
+  lng: string,
+  accuracy: string
 ): Promise<number | undefined> {
+  let geoTimeStamp = {
+    dateTime: dateTime,
+    lat: lat,
+    lng: lng,
+    accuracy: accuracy,
+  };
+  let geoTimeStampStr = JSON.stringify(geoTimeStamp);
+  console.log('geoTimeStampStr:', geoTimeStampStr);
+  console.log('insertDocumentInDB1:', fmsFolderName);
+
+  let processedFilePath = '';
   try {
     const dspID = await cache.getKeyFromCache(keys.DISPATCH_ID);
     let response = await DocumentSyncManager.getInstance().insertDocument(
@@ -149,7 +165,9 @@ export async function insertDocumentInDB(
       // objRef,
       filePath,
       'image',
-      fileName
+      fileName,
+      geoTimeStampStr,
+      processedFilePath
     );
     AppSyncManager.getInstance().startSDKSyncManager();
     return response.insertId;

package/src/utils/utils.ts

@@ -28,3 +28,26 @@ export function isTokenExpired(accessToken: string) {
   let decodedData: any = jwtDecode(accessToken);
   return !(decodedData && decodedData.exp * 1000 > Date.now());
 }
+
+export function flattenObject(obj: Record<string, any>, prefix = ''): string {
+  return JSON.stringify(obj);
+  // return Object.keys(obj).reduce((acc, key) => {
+  //     const flatKey = prefix ? `${prefix}.${key}` : key;
+  //     if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+  //         return acc ?? '' + flattenObject(obj[key], flatKey);
+  //     } else {
+  //         return acc ?? '' + `${flatKey}: ${JSON.stringify(obj[key])}\n`;
+  //     }
+  // }, '');
+}
+
+
+export function createObjectWithoutNullValues<T extends { [key: string]: any }>(obj: T): Partial<T> {
+  const newObj: Partial<T> = {};
+  for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== null && obj[key] !== 'request' && obj[key] !== 'headers') {
+          newObj[key] = obj[key];
+      }
+  }
+  return newObj;
+}