@os1-platform/dispatch-mobile 2.1.0 → 2.1.2

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

@@ -1,111 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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

@@ -1,233 +0,0 @@
-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

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