@os1-platform/dispatch-mobile 2.1.2 → 2.1.4

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

@@ -0,0 +1,111 @@
+import HttpClient from '../../../network/client';
+import type { DocumentRow } from '../DBConfig';
+import type { AxiosResponse } from 'axios';
+import * as FileSystem from 'expo-file-system';
+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';
+
+const cache = DispatchSdkCache.getInstance();
+const cacheKeys = DispatchSdkCache.KEYS;
+export default class DocumentHttpClient extends HttpClient {
+  constructor(baseURL: string) {
+    super(baseURL);
+  }
+  public async uploadDocument(document: DocumentRow): Promise<string | null> {
+    if (document.base64 && document.data != null) {
+      const response = await this.uploadBase64File(document);
+      if (
+        response &&
+        response.data != null &&
+        response.data.data != null &&
+        response.data.data.id &&
+        response.status === 202
+      ) {
+        return response.data.data.id;
+      } else {
+        return null;
+      }
+    } else {
+      const uploadResponse = await this.uploadBinaryFile(document);
+      Logger.getInstance().logEvent(
+        'uploadDocument',
+        JSON.stringify(uploadResponse),
+        LOG_TYPE.SDK_INFO
+      );
+      if (
+        uploadResponse != null &&
+        uploadResponse.status === 202 &&
+        uploadResponse.body != null
+      ) {
+        FileSystem.deleteAsync(document.file_path).then().catch(); // WE DELETE FILE HERE
+        return JSON.parse(uploadResponse.body)?.data?.id;
+      } else {
+        return null;
+      }
+    }
+  }
+
+  public async uploadBase64File(document: DocumentRow): Promise<AxiosResponse> {
+    let requestBody = JSON.stringify({
+      file: {
+        type: 'FILE',
+        data: document.data,
+      },
+      description: document.desc,
+      tags: [
+        { key: 'dispatchId', value: document.dispatch_id },
+        // { key: 'jobId', value: document.job_id },
+        // { key: 'objectiveRef', value: document.objective_ref },
+        { key: 'fileName', value: document.file_name },
+      ],
+      fileName: document.file_name,
+    });
+    const sdkConfig = (await cache.getObjectFromCache(
+      cacheKeys.SDK_CONFIG
+    )) as DispatchSDKConfig;
+    return this.instance.post(
+      `/api/folders/${document.fms_folder_id}/files`,
+      requestBody,
+      {
+        headers: {
+          'accept': 'application/json',
+          'X-COREOS-REQUEST-ID': document.dispatch_id,
+          'X-COREOS-ACCESS': sdkConfig.accessToken ?? '',
+          'X-COREOS-TID': sdkConfig.tenantID ?? '',
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+  }
+  private async uploadBinaryFile(
+    document: DocumentRow
+  ): Promise<FileSystemUploadResult> {
+    const sdkConfig = (await cache.getObjectFromCache(
+      cacheKeys.SDK_CONFIG
+    )) as DispatchSDKConfig;
+    const url =
+      sdkConfig.tenantBaseURL + `/api/folders/${document.fms_folder_id}/files`;
+    return FileSystem.uploadAsync(url, document.file_path, {
+      headers: {
+        'accept': 'application/json',
+        'Content-Type': 'multipart/form-data',
+        'X-COREOS-REQUEST-ID': document.dispatch_id,
+        'X-COREOS-TID': sdkConfig.tenantID ?? '',
+        'X-COREOS-ACCESS': sdkConfig.accessToken ?? '',
+      },
+      httpMethod: 'POST',
+      uploadType: FileSystemUploadType.MULTIPART,
+      fieldName: 'file',
+      parameters: {
+        tags: JSON.stringify([
+          { key: 'dispatchId', value: document.dispatch_id },
+          // { key: 'jobId', value: document.job_id },
+          // { key: 'objectiveRef', value: document.objective_ref },
+          { key: 'fileName', value: document.file_name },
+        ]),
+      },
+    });
+  }
+}

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

@@ -0,0 +1,143 @@
+import { DOCUMENT_COLUMNS, DOCUMENT_TABLE, DocumentRow } from '../DBConfig';
+import * as Database from '../database';
+import type { SQLResultSet } from 'expo-sqlite';
+
+export default class DocumentManager {
+  private static instance: DocumentManager;
+
+  private constructor() {}
+
+  public static async getInstance(): Promise<DocumentManager> {
+    if (!DocumentManager.instance) {
+      let managerInstance = new DocumentManager();
+      await managerInstance.init();
+      DocumentManager.instance = managerInstance;
+    }
+    return DocumentManager.instance;
+  }
+
+  public async init(): Promise<void> {
+    await Database.executeQuery(
+      `CREATE TABLE IF NOT EXISTS ${DOCUMENT_TABLE} (\
+                    ${DOCUMENT_COLUMNS.ID} INTEGER PRIMARY KEY AUTOINCREMENT,\
+                    ${DOCUMENT_COLUMNS.DATA} TEXT,\
+                    ${DOCUMENT_COLUMNS.BASE64} INTEGER NOT NULL DEFAULT 0,\
+                    ${DOCUMENT_COLUMNS.FILE_PATH} TEXT,\
+                    ${DOCUMENT_COLUMNS.DISPATCH_ID} TEXT NOT NULL,\
+                    ${DOCUMENT_COLUMNS.FILE_NAME} TEXT,\
+                    ${DOCUMENT_COLUMNS.FILE_TYPE} TEXT,\
+                    ${DOCUMENT_COLUMNS.SYNCED} INTEGER DEFAULT 0 NOT NULL,\
+                    ${DOCUMENT_COLUMNS.FMS_ID} TEXT,\
+                    ${DOCUMENT_COLUMNS.FMS_FOLDER_ID} TEXT,\
+                    ${DOCUMENT_COLUMNS.PRIORITY} INTEGER NOT NULL DEFAULT 1,\
+                    ${DOCUMENT_COLUMNS.SYNC_ERROR} TEXT,\
+                    ${DOCUMENT_COLUMNS.DESCRIPTION} TEXT);`,
+      []
+    );
+  }
+
+  public async insertDocument(
+    fmsFolderID: string | null,
+    desc: string,
+    dspID: string,
+    // jobID: string,
+    // objectiveRef: string,
+    base64: boolean,
+    fileName: string,
+    fileType: string,
+    data?: string | null,
+    filePath?: string | null,
+    priority?: number
+  ): Promise<SQLResultSet> {
+    return await Database.executeQuery(
+      `INSERT INTO ${DOCUMENT_TABLE}(\
+                                    ${DOCUMENT_COLUMNS.DATA},\
+                                    ${DOCUMENT_COLUMNS.DISPATCH_ID},\
+                                    ${DOCUMENT_COLUMNS.FMS_FOLDER_ID},\
+                                    ${DOCUMENT_COLUMNS.BASE64},\
+                                    ${DOCUMENT_COLUMNS.FILE_PATH},\
+                                    ${DOCUMENT_COLUMNS.FILE_NAME},\
+                                    ${DOCUMENT_COLUMNS.FILE_TYPE},\
+                                    ${DOCUMENT_COLUMNS.DESCRIPTION},\
+                                    ${DOCUMENT_COLUMNS.PRIORITY}) \
+                                    values (?,?,?,?,?,?,?,?,?)`,
+      [
+        data,
+        dspID,
+        fmsFolderID,
+        base64,
+        filePath,
+        fileName,
+        fileType,
+        desc,
+        priority ? priority : 1,
+      ]
+    );
+  }
+
+  public async getAllDocuments(dispatchID?: string): Promise<DocumentRow[]> {
+    if (!dispatchID) {
+      const resultSet = await Database.executeQuery(
+        `SELECT * FROM ${DOCUMENT_TABLE};`,
+        []
+      );
+      return resultSet.rows._array;
+    } else {
+      const resultSet = await Database.executeQuery(
+        `SELECT * FROM ${DOCUMENT_TABLE}\
+              WHERE ${DOCUMENT_COLUMNS.DISPATCH_ID} =?;`,
+        [dispatchID]
+      );
+      return resultSet.rows._array;
+    }
+  }
+
+  public async getAllUnsyncedDocs(): Promise<DocumentRow[]> {
+    let resultSet = await Database.executeQuery(
+      `SELECT * FROM ${DOCUMENT_TABLE} \
+            where ${DOCUMENT_COLUMNS.SYNCED} = 0;`,
+      []
+    );
+    return resultSet.rows._array;
+  }
+
+  public deleteAllSyncedDocuments(dispatchID: string) {
+    return Database.executeQuery(
+      `DELETE FROM ${DOCUMENT_TABLE}\
+            WHERE ${DOCUMENT_COLUMNS.SYNCED} = 1 and ${DOCUMENT_COLUMNS.DISPATCH_ID} = ?;`,
+      [dispatchID]
+    );
+  }
+
+  public async markDocumentSynced(id: number, fmsID: string): Promise<void> {
+    if (!id || !fmsID) return;
+    await Database.executeQuery(
+      `UPDATE ${DOCUMENT_TABLE} SET ${DOCUMENT_COLUMNS.SYNCED} = 1,${DOCUMENT_COLUMNS.FMS_ID} = ?  WHERE ${DOCUMENT_COLUMNS.ID} = ?;`,
+      [fmsID, id]
+    );
+  }
+
+  public async updateDocSyncError(
+    id: number,
+    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} = ?;`,
+      [uploadError, id]
+    );
+  }
+
+  public async getUnsyncedDocument(): Promise<DocumentRow[]> {
+    let rs = await Database.executeQuery(
+      `SELECT * from ${DOCUMENT_TABLE}\
+            WHERE ${DOCUMENT_COLUMNS.SYNCED} = 0 \
+            ORDER BY ${DOCUMENT_COLUMNS.PRIORITY} ASC LIMIT 1;`,
+      []
+    );
+    return rs.rows._array;
+  }
+}

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

@@ -0,0 +1,233 @@
+import type { DocumentRow } from '../DBConfig';
+import DocumentManager from './DocumentManager';
+import DocumentHttpClient from './DocumentHttpClient';
+import { isEmptyOrBlank } from '../../../utils/utils';
+import { BaseError } from '../../../errors/BaseError';
+import BaseErrorCodes, {
+  InvalidArgumentsError,
+  InvalidBaseURL,
+  SyncManagerNotInitialized,
+} from '../../../errors/ErrorCodes';
+import Logger, { LOG_TYPE } from '../../../utils/Logger';
+import type { SQLResultSet } from 'expo-sqlite';
+import NetworkUtil from '../../../utils/NetworkUtil';
+
+export default class DocumentSyncManager {
+  private documentHttpClient: DocumentHttpClient | undefined;
+  private inProgress: boolean = false;
+  private static instance: DocumentSyncManager;
+  private docManager: DocumentManager | undefined;
+  private maxRetryCount: number = 3;
+  private _retries = 0;
+
+  get retries(): number {
+    return this._retries;
+  }
+
+  set retries(value: number) {
+    this._retries = value;
+  }
+
+  private constructor() {}
+
+  public init(baseURL: string, retryCount: number) {
+    if (isEmptyOrBlank(baseURL))
+      throw new BaseError(BaseErrorCodes.InvalidBaseURL, InvalidBaseURL);
+    this.maxRetryCount = retryCount;
+    this.documentHttpClient = new DocumentHttpClient(baseURL);
+  }
+
+  public static getInstance(): DocumentSyncManager {
+    if (!DocumentSyncManager.instance) {
+      DocumentSyncManager.instance = new DocumentSyncManager();
+    }
+    return DocumentSyncManager.instance;
+  }
+
+  public async startDocumentSync(): Promise<void> {
+    if (!this.inProgress && this._retries < this.maxRetryCount) {
+      this.inProgress = true;
+      const hasNetwork = await NetworkUtil.isAvailableAsync();
+      try {
+        this.checkForInitialization();
+        if (!this.docManager) {
+          this.docManager = await DocumentManager.getInstance();
+        }
+        if (hasNetwork) {
+          let documentRows: DocumentRow[] =
+            await this.docManager.getUnsyncedDocument();
+          if (documentRows?.length > 0) {
+            await this.uploadDocToServer(documentRows[0]);
+          } else {
+            Logger.getInstance().logEvent(
+              'startDocumentSync',
+              'No data to sync',
+              LOG_TYPE.SDK_INFO
+            );
+          }
+        } else {
+          Logger.getInstance().logEvent(
+            'startDocumentSync',
+            'No Network',
+            LOG_TYPE.SDK_INFO
+          );
+        }
+      } catch (error: any) {
+      } finally {
+        this.inProgress = false;
+        if ((await this.isSyncPending()) && hasNetwork) {
+          await this.startDocumentSync();
+        }
+      }
+    } else {
+      Logger.getInstance().logEvent(
+        'startDocumentSync',
+        'sync already in progress ',
+        LOG_TYPE.SDK_INFO
+      );
+    }
+  }
+
+  public async isSyncPending(): Promise<boolean> {
+    if (!this.docManager) this.docManager = await DocumentManager.getInstance();
+    let leftDocuments = await this.docManager.getAllUnsyncedDocs();
+    return leftDocuments?.length > 0 && this._retries < this.maxRetryCount;
+  }
+
+  public async insertDocument(
+    fmsFolderID: string | null,
+    data: string | null,
+    base64: boolean,
+    desc: string,
+    dspID: string,
+    // jobID: string,
+    // objRef: string,
+    filePath: string | null,
+    fileType: string,
+    fileName: string,
+    priority: number = 1
+  ): Promise<SQLResultSet> {
+    if (
+      isEmptyOrBlank(desc) ||
+      isEmptyOrBlank(dspID) ||
+      // isEmptyOrBlank(jobID) ||
+      // isEmptyOrBlank(objRef) ||
+      isEmptyOrBlank(fileType) ||
+      isEmptyOrBlank(fileName) ||
+      (base64 && isEmptyOrBlank(data)) ||
+      (!base64 && isEmptyOrBlank(filePath))
+    )
+      throw new BaseError(
+        BaseErrorCodes.InvalidArgumentError,
+        InvalidArgumentsError
+      );
+    else {
+      if (!this.docManager) {
+        Logger.getInstance().logEvent(
+          'insertDocument',
+          'INIT DOC SYNC AGAIN',
+          LOG_TYPE.SDK_INFO
+        );
+        this.docManager = await DocumentManager.getInstance();
+      }
+      let insertResponse = await this.docManager?.insertDocument(
+        fmsFolderID,
+        desc,
+        dspID,
+        // jobID,
+        // objRef,
+        base64,
+        fileName,
+        fileType,
+        data,
+        filePath,
+        priority
+      );
+      return insertResponse;
+    }
+  }
+
+  public async forceDocumentSync() {
+    if (!this.docManager) this.docManager = await DocumentManager.getInstance();
+    this._retries = 0;
+    await this.startDocumentSync();
+  }
+
+  private async updateDocument(documentRow: DocumentRow, fmsID: string) {
+    if (!this.docManager) this.docManager = await DocumentManager.getInstance();
+    try {
+      await this.docManager.markDocumentSynced(documentRow.id, fmsID);
+    } 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 {
+      await this.docManager.updateDocSyncError(documentRow.id, uploadError);
+    } catch (err: any) {
+      Logger.getInstance().logEvent(
+        'updateDocError',
+        err.message,
+        LOG_TYPE.SDK_WARNING
+      );
+    }
+  }
+  private checkForInitialization() {
+    if (!this.documentHttpClient) {
+      throw new BaseError(
+        BaseErrorCodes.SyncManagerNotInitialized,
+        SyncManagerNotInitialized
+      );
+    }
+  }
+
+  private async uploadDocToServer(documentRow: DocumentRow) {
+    try {
+      let fmsID = await this.documentHttpClient?.uploadDocument(documentRow);
+      // 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);
+      } else {
+        this._retries++;
+        Logger.getInstance().logEvent(
+          'uploadDocToServer-sync-error',
+          'Unexpected Error',
+          LOG_TYPE.SDK_ERROR
+        );
+        await this.updateDocError(documentRow, 'Unexpected Error');
+      }
+    } catch (error: any) {
+      this._retries++;
+      Logger.getInstance().logEvent(
+        'uploadDocToServer-sync-error',
+        error.message,
+        LOG_TYPE.SDK_ERROR
+      );
+      await this.updateDocError(
+        documentRow,
+        JSON.stringify({
+          message: error.message,
+          error: JSON.stringify(error?.response?.data),
+          status: error?.response?.status,
+        })
+      );
+    }
+  }
+
+  public async getAllDocuments(dispatchID?: string): Promise<DocumentRow[]> {
+    if (!this.docManager) this.docManager = await DocumentManager.getInstance();
+    return this.docManager.getAllDocuments(dispatchID);
+  }
+
+  public async clearSyncedDocs(dspID: string) {
+    if (!this.docManager) this.docManager = await DocumentManager.getInstance();
+    if (dspID) await this.docManager.deleteAllSyncedDocuments(dspID);
+  }
+}

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

@@ -0,0 +1,4 @@
+export type FILE_TAGS = {
+  key: string;
+  value: string;
+};