@os1-platform/dispatch-mobile 2.1.2 → 2.1.3

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

@@ -0,0 +1,490 @@
+import ETEventsManager from './ETEventsManager';
+import type {
+  BulkEvent,
+  DispatchSyncType,
+  EventRow,
+  ExecEngineSyncType,
+} from '../DBConfig';
+import SyncHttpClient from './SyncHttpClient';
+import { isEmptyOrBlank } from '../../../utils/utils';
+import { BaseError } from '../../../errors/BaseError';
+import BaseErrorCodes, {
+  InvalidArgumentsError,
+  InvalidBaseURL,
+  SyncManagerNotInitialized,
+} from '../../../errors/ErrorCodes';
+import NetworkUtil from '../../../utils/NetworkUtil';
+import Logger, { LOG_TYPE } from '../../../utils/Logger';
+import { IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
+const SyncType = IDispatch.SyncType;
+
+import DispatchSdkCache from '../../sdk/DispatchSdkCache';
+import Storage from '../../../utils/storage';
+import { LAST_SYNCED_EVENT_ID } from '../constants';
+
+const TAG = 'EventsSyncManager';
+export default class EventsSyncManager {
+  private syncHttpClient: SyncHttpClient | undefined;
+  private static instance: EventsSyncManager;
+  private inProgress: boolean = false;
+  private cScanInProgress: boolean = false;
+  private eventsManager: ETEventsManager | undefined;
+  private maxRetryCount: number = 3;
+  private _retries = 0;
+
+  get retries(): number {
+    return this._retries;
+  }
+
+  set retries(value: number) {
+    this._retries = value;
+  }
+
+  private constructor() {}
+
+  public initSyncManager(baseURL: string, retryCount: number) {
+    if (isEmptyOrBlank(baseURL))
+      throw new BaseError(BaseErrorCodes.InvalidBaseURL, InvalidBaseURL);
+    this.maxRetryCount = retryCount;
+    this.syncHttpClient = new SyncHttpClient(baseURL);
+  }
+
+  public static getInstance(): EventsSyncManager {
+    if (!EventsSyncManager.instance) {
+      EventsSyncManager.instance = new EventsSyncManager();
+    }
+    return EventsSyncManager.instance;
+  }
+
+  public async startSync(): Promise<void> {
+    if (!this.inProgress && this._retries < this.maxRetryCount) {
+      this.inProgress = true;
+      const hasNetwork = await NetworkUtil.isAvailableAsync();
+      try {
+        this.checkForInitialization();
+        if (!this.eventsManager) {
+          this.eventsManager = await ETEventsManager.getInstance();
+        }
+        if (hasNetwork) {
+          // NEW CODE
+          const lastSyncedEventId = await Storage.getInstance().getSharedItem(
+            LAST_SYNCED_EVENT_ID
+          );
+          const dspID = await DispatchSdkCache.getInstance().getKeyFromCache(
+            DispatchSdkCache.KEYS.DISPATCH_ID
+          );
+
+          const bulkEventRows = await this.eventsManager.getBulkRowsToSync(
+            lastSyncedEventId,
+            dspID ?? ''
+          );
+
+          if (bulkEventRows.length) {
+            await this.syncBulkEventToServer(bulkEventRows, lastSyncedEventId);
+          } else {
+            Logger.getInstance().logEvent(
+              'startSync',
+              'No data to sync in Events Manager',
+              LOG_TYPE.SDK_INFO
+            );
+          }
+
+          // OLD CODE
+          // const promises: any[] = [
+          //   this.JobRemovalEvent(this.eventsManager),
+          //   this.CustodyBatchEvent(this.eventsManager),
+          //   this.WorkflowUpdateEvent(this.eventsManager),
+          // ];
+          // await Promise.all(promises);
+        } else {
+          Logger.getInstance().logEvent(
+            'startSync',
+            'NO NETWORK AVAILABLE!!',
+            LOG_TYPE.SDK_INFO
+          );
+        }
+      } catch (error: any) {
+      } finally {
+        this.inProgress = false;
+        if ((await this.isSyncPending()) && hasNetwork) {
+          await this.startSync();
+        }
+      }
+    } else {
+      Logger.getInstance().logEvent(
+        'startSync',
+        'WORKFLOW/TASK ALREADY IN PROGRESS || Max Retries reached',
+        LOG_TYPE.SDK_INFO
+      );
+    }
+  }
+
+  // private async WorkflowUpdateEvent(eventsManager: ETEventsManager) {
+  //   const unsyncedData = await eventsManager.getWorkflowUpdateEvents(
+  //     SyncType.WORKFLOW
+  //   );
+  //   if (unsyncedData?.length > 0) {
+  //     await this.syncEventToServer(unsyncedData, SyncType.WORKFLOW);
+  //   } else {
+  //     Logger.getInstance().logEvent(
+  //       'startSync',
+  //       'No workflow/task data to sync in Events Manager',
+  //       LOG_TYPE.SDK_INFO
+  //     );
+  //   }
+  // }
+
+  // private async CustodyBatchEvent(eventsManager: ETEventsManager) {
+  //   const dspID = await DispatchSdkCache.getInstance().getKeyFromCache(
+  //     DispatchSdkCache.KEYS.DISPATCH_ID
+  //   );
+  //   const custodyScans = await eventsManager.getCustodyBatch(dspID ?? '');
+  //   if (custodyScans && custodyScans.length > 0) {
+  //     await this.startCustodyScans(custodyScans);
+  //   }
+  // }
+
+  // private async JobRemovalEvent(eventsManager: ETEventsManager) {
+  //   const unsyncedJobRemovalData = await eventsManager.getJobRemovalEvents(
+  //     SyncType.JOB_REMOVAL
+  //   );
+  //   if (unsyncedJobRemovalData?.length > 0) {
+  //     await this.syncEventToServer(
+  //       unsyncedJobRemovalData,
+  //       SyncType.JOB_REMOVAL
+  //     );
+  //   }
+  // }
+
+  // public async startCustodyScans(custodyScans: EventRow[]) {
+  //   if (!this.cScanInProgress) {
+  //     this.cScanInProgress = true;
+  //     try {
+  //       const inScans = custodyScans.filter(
+  //         (scan) => scan.sync_type === SyncType.CUSTODY_IN_SCAN
+  //       );
+  //       const outScans = custodyScans.filter(
+  //         (scans) => scans.sync_type === SyncType.CUSTODY_OUT_SCAN
+  //       );
+  //       if (inScans && inScans.length > 0) {
+  //         await this.syncEventToServer(inScans, SyncType.CUSTODY_IN_SCAN);
+  //       } else if (outScans && outScans.length > 0) {
+  //         await this.syncEventToServer(outScans, SyncType.CUSTODY_OUT_SCAN);
+  //       } else {
+  //         Logger.getInstance().logEvent(
+  //           'startCustodyScans',
+  //           'NO CUSTODY SCANS LEFT TO SYNC',
+  //           LOG_TYPE.SDK_INFO
+  //         );
+  //       }
+  //     } catch (error: any) {
+  //     } finally {
+  //       this.cScanInProgress = false;
+  //       if (await this.isSyncPending()) await this.startSync();
+  //     }
+  //   } else {
+  //     Logger.getInstance().logEvent(
+  //       'startCustodyScans',
+  //       'Custody Scan already in Progress',
+  //       LOG_TYPE.SDK_INFO
+  //     );
+  //   }
+  // }
+
+  private async updateEventError(
+    eventRows: EventRow[],
+    errorString: string
+  ): Promise<void> {
+    if (!eventRows || eventRows.length === 0) return;
+    if (!this.eventsManager) {
+      this.eventsManager = await ETEventsManager.getInstance();
+    }
+    const promises: any[] = [];
+    for (const ev of eventRows) {
+      try {
+        promises.push(this.eventsManager.updateError(ev.id, errorString));
+      } catch (err: any) {
+        Logger.getInstance().logEvent(
+          'updateEventError',
+          err.message,
+          LOG_TYPE.SDK_WARNING
+        );
+      }
+    }
+    await Promise.all(promises);
+  }
+
+  /**
+   * force sync events who retry count >3 This function can be called from app UI to sync the events forcefully
+   */
+  public async forceSync() {
+    if (!this.eventsManager)
+      this.eventsManager = await ETEventsManager.getInstance();
+    this._retries = 0;
+    await this.startSync();
+  }
+
+  public async isSyncPending(): Promise<boolean> {
+    if (!this.eventsManager) {
+      this.eventsManager = await ETEventsManager.getInstance();
+    }
+
+    // NEW CODE
+    const lastSyncedEventId = await Storage.getInstance().getSharedItem(
+      LAST_SYNCED_EVENT_ID
+    );
+    const syncEventId = parseInt(lastSyncedEventId) + 1;
+    const dspID = await DispatchSdkCache.getInstance().getKeyFromCache(
+      DispatchSdkCache.KEYS.DISPATCH_ID
+    );
+    const eventRows = await this.eventsManager.getRowToSync(
+      `${syncEventId}`,
+      dspID ?? ''
+    );
+
+    return eventRows.length > 0 && this._retries < this.maxRetryCount;
+
+    // OLD CODE
+    // let unsyncedData = await this.eventsManager.getAllUnsyncedEvents();
+    // return unsyncedData?.length > 0 && this._retries < this.maxRetryCount;
+  }
+
+  private async markEventSynced(eventRows: EventRow[]) {
+    if (!eventRows || eventRows.length === 0) return;
+    if (!this.eventsManager) {
+      this.eventsManager = await ETEventsManager.getInstance();
+    }
+    const promises: any[] = [];
+    for (const ev of eventRows) {
+      try {
+        promises.push(await this.eventsManager.markEventSynced(ev.id));
+      } catch (err: any) {
+        Logger.getInstance().logEvent(
+          'markEventSynced',
+          err.message,
+          LOG_TYPE.SDK_WARNING
+        );
+      }
+    }
+
+    await Promise.all(promises);
+  }
+
+  public async insertEvent(
+    sequence: number,
+    payload: string,
+    dspID: string,
+    syncType: string,
+    objectiveRef: string,
+    config?: string
+  ): Promise<void> {
+    if (
+      !sequence ||
+      isEmptyOrBlank(payload) ||
+      isEmptyOrBlank(dspID) ||
+      isEmptyOrBlank(syncType) ||
+      isEmptyOrBlank(objectiveRef)
+    )
+      throw new BaseError(
+        BaseErrorCodes.InvalidArgumentError,
+        InvalidArgumentsError
+      );
+    if (!this.eventsManager) {
+      this.eventsManager = await ETEventsManager.getInstance();
+    }
+    await this.eventsManager.insertEvent(
+      sequence,
+      payload,
+      dspID,
+      syncType,
+      objectiveRef,
+      config
+    );
+  }
+
+  // NEW CODE
+  public async insertBulkEvent(_bulkData: BulkEvent): Promise<void> {
+    try {
+      if (!this.eventsManager) {
+        this.eventsManager = await ETEventsManager.getInstance();
+      }
+      await this.eventsManager.insertBulkEvent(_bulkData);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  // NEW CODE
+  public async insertQueueEvent(_pushData: BulkEvent): Promise<void> {
+    try {
+      if (!this.eventsManager) {
+        this.eventsManager = await ETEventsManager.getInstance();
+      }
+      await this.eventsManager.insertQueueEvent(_pushData);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  // OLD CODE
+  // public async insertBulkEvent(_bulkData: BulkEvent[]): Promise<void> {
+  //   try {
+  //     /* if (
+  //     !sequence ||
+  //     isEmptyOrBlank(payload) ||
+  //     isEmptyOrBlank(dspID) ||
+  //     isEmptyOrBlank(syncType) ||
+  //     isEmptyOrBlank(objectiveRef)
+  //   )
+  //     throw new BaseError(
+  //       BaseErrorCodes.InvalidArgumentError,
+  //       InvalidArgumentsError
+  //     ); */
+  //     if (!this.eventsManager) {
+  //       this.eventsManager = await ETEventsManager.getInstance();
+  //     }
+  //     await this.eventsManager.insertBulkEvent(_bulkData);
+  //   } catch (err) {
+  //     throw err;
+  //   }
+  // }
+
+  private checkForInitialization() {
+    if (!this.syncHttpClient) {
+      throw new BaseError(
+        BaseErrorCodes.SyncManagerNotInitialized,
+        SyncManagerNotInitialized
+      );
+    }
+  }
+
+  public async getObjectiveSummary(objectiveRef: string): Promise<any> {
+    if (!objectiveRef) return [];
+    if (!this.eventsManager) {
+      this.eventsManager = await ETEventsManager.getInstance();
+    }
+    try {
+      let data = await this.eventsManager.getObjectiveDetails(objectiveRef);
+      let requiredPayload: any = null;
+      for (const row of data) {
+        let payload = JSON.parse(row.payload);
+        if (payload.status === 'CLOSED') {
+          requiredPayload = payload;
+        }
+      }
+      if (requiredPayload) return requiredPayload.data;
+      else return null;
+    } catch (err: any) {
+      Logger.getInstance().logEvent(
+        'getObjectiveSummary',
+        err.message,
+        LOG_TYPE.SDK_WARNING
+      );
+      return null;
+    }
+  }
+
+  private async syncEventToServer(
+    eventRows: EventRow[],
+    syncType: ExecEngineSyncType | DispatchSyncType
+  ) {
+    try {
+      const success = await this.syncHttpClient?.syncEvent(eventRows, syncType);
+
+      if (success) {
+        this._retries = 0;
+        // NEW CODE
+        const lastSyncedEventId = await Storage.getInstance().getSharedItem(
+          LAST_SYNCED_EVENT_ID
+        );
+        const syncEventId = parseInt(lastSyncedEventId) + 1;
+        await Storage.getInstance().setSharedItem(
+          LAST_SYNCED_EVENT_ID,
+          `${syncEventId}`
+        );
+
+        // OLD CODE
+        await this.markEventSynced(eventRows);
+      } else {
+        this._retries++;
+        /* Logger.getInstance().logEvent(
+          'syncEventToServer',
+          `Syncing Error  ${syncType} :- ${JSON.stringify(eventRows)}`,
+          LOG_TYPE.SDK_ERROR
+        ); */
+        await this.updateEventError(eventRows, 'Unexpected error');
+      }
+    } catch (error: any) {
+      this._retries++;
+      /* Logger.getInstance().logEvent(
+        'syncEventToServer',
+        `Syncing Error ${syncType} :- ${JSON.stringify(eventRows)} -: ${
+          error.message
+        }`,
+        LOG_TYPE.SDK_ERROR
+      ); */
+      await this.updateEventError(
+        eventRows,
+        JSON.stringify({
+          error,
+        })
+      );
+    }
+  }
+
+  private async syncBulkEventToServer(
+    eventRows: EventRow[],
+    lastSyncedEventId: string
+  ) {
+    try {
+      const success = await this.syncHttpClient?.syncBulkEvent(eventRows);
+      if (success) {
+        this._retries = 0;
+        // NEW CODE
+
+        const syncEventId = parseInt(lastSyncedEventId) + eventRows.length;
+        await Storage.getInstance().setSharedItem(
+          LAST_SYNCED_EVENT_ID,
+          `${syncEventId}`
+        );
+
+        // OLD CODE
+        await this.markEventSynced(eventRows);
+      } else {
+        this._retries++;
+        /* Logger.getInstance().logEvent(
+          'syncEventToServer',
+          `Syncing Error  ${syncType} :- ${JSON.stringify(eventRows)}`,
+          LOG_TYPE.SDK_ERROR
+        ); */
+        await this.updateEventError(eventRows, 'Unexpected error');
+      }
+    } catch (error) {
+      this._retries++;
+      /* Logger.getInstance().logEvent(
+        'syncEventToServer',
+        `Syncing Error ${syncType} :- ${JSON.stringify(eventRows)} -: ${
+          error.message
+        }`,
+        LOG_TYPE.SDK_ERROR
+      ); */
+      await this.updateEventError(
+        eventRows,
+        JSON.stringify({
+          error,
+        })
+      );
+    }
+  }
+
+  public async getAllEvents(dspID?: string): Promise<EventRow[]> {
+    if (!this.eventsManager)
+      this.eventsManager = await ETEventsManager.getInstance();
+    return this.eventsManager.getAllEvents(dspID);
+  }
+  public async clearEventsDB() {
+    if (!this.eventsManager)
+      this.eventsManager = await ETEventsManager.getInstance();
+    await this.eventsManager.deleteAllEvents();
+  }
+}

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

@@ -0,0 +1,202 @@
+import HttpClient from '../../../network/client';
+import { DispatchSyncType, EventRow } from '../DBConfig';
+import GraphQLClient from '../../../network/GraphQLClient';
+import NetworkClient from '../../../network/NetworkClient';
+import { ExecEngineSyncType } from '../DBConfig';
+
+import { isEmptyOrBlank } from '../../../utils/utils';
+import { ENDPOINTS } from '../../../constants/apiConstants';
+import Logger, { LOG_TYPE } from '../../../utils/Logger';
+
+import { IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
+const SyncType = IDispatch.SyncType;
+
+export default class SyncHttpClient extends HttpClient {
+  protected readonly networkInstance: NetworkClient;
+  constructor(baseURL: string) {
+    super(baseURL);
+    this.networkInstance = new NetworkClient(baseURL);
+  }
+
+  public async syncEvent(
+    eventRow: EventRow[],
+    syncType: ExecEngineSyncType | DispatchSyncType
+  ): Promise<boolean | null> {
+    if (eventRow.length < 1) return null;
+    return new Promise(async (resolve, reject) => {
+      setTimeout(async () => {
+        try {
+          switch (syncType) {
+            case SyncType.CUSTODY_IN_SCAN: {
+              // NEW CODE
+              const requestBody = JSON.parse(eventRow[0].payload);
+              const custodyInResponse = await this.networkInstance.requestPost(
+                ENDPOINTS.BULK_JOB_UPDATE(eventRow[0].dispatch_id),
+                requestBody,
+                { requestId: 'custodyIn: ' + eventRow[0].dispatch_id }
+              );
+
+              if (custodyInResponse.data.error) {
+                resolve(false);
+              } else {
+                resolve(true);
+              }
+              break;
+
+              // OLD CODE
+              // const custodyInScans = [];
+              // for (const ev of eventRow) {
+              //   custodyInScans.push(JSON.parse(ev.payload));
+              // }
+              // const response = await GraphQLClient.getInstance().postCustodyIn(
+              //   custodyInScans,
+              //   eventRow[0].dispatch_id
+              // );
+              // resolve(response?.data?.custodyInBatch?.success === true);
+              // break;
+            }
+            case SyncType.CUSTODY_OUT_SCAN: {
+              // NEW CODE
+              const requestBody = JSON.parse(eventRow[0].payload);
+              const custodyInResponse = await this.networkInstance.requestPost(
+                ENDPOINTS.BULK_JOB_UPDATE(eventRow[0].dispatch_id),
+                requestBody,
+                { requestId: 'custodyIn: ' + eventRow[0].dispatch_id }
+              );
+
+              if (custodyInResponse.data.error) {
+                resolve(false);
+              } else {
+                resolve(true);
+              }
+              break;
+
+              // OLD CODE
+              // const custodyOutScans = [];
+              // for (const ev of eventRow) {
+              //   custodyOutScans.push(JSON.parse(ev.payload));
+              // }
+              // const custodyOutResponse =
+              //   await GraphQLClient.getInstance().postCustodyOut(
+              //     custodyOutScans,
+              //     eventRow[0].dispatch_id
+              //   );
+              // resolve(
+              //   custodyOutResponse?.data?.custodyOutBatch?.success === true
+              // );
+              // break;
+            }
+            case SyncType.WORKFLOW: {
+              // NEW CODE
+              const requestBody = JSON.parse(eventRow[0].payload);
+              const wfiUpdateResponse = await this.networkInstance.requestPost(
+                ENDPOINTS.BULK_JOB_UPDATE(eventRow[0].dispatch_id),
+                requestBody,
+                { requestId: 'wfiUpdate: ' + eventRow[0].dispatch_id }
+              );
+
+              if (wfiUpdateResponse.data.error) {
+                resolve(false);
+              } else {
+                resolve(true);
+              }
+              break;
+
+              // OLD CODE
+              // const workflowResp =
+              //   await GraphQLClient.getInstance().postWorkflowUpdate(
+              //     JSON.parse(eventRow[0].payload),
+              //     JSON.parse(eventRow[0].config).params.workflowInstanceId
+              //   );
+              // resolve(
+              //   !isEmptyOrBlank(workflowResp?.data.updateWorkflowStatus.id)
+              // );
+              // break;
+            }
+            case SyncType.JOB_REMOVAL: {
+              // NEW CODE
+              const requestBody = JSON.parse(eventRow[0].payload);
+              const jobResponse = await this.networkInstance.requestPut(
+                ENDPOINTS.BULK_JOB_UPDATE(eventRow[0].dispatch_id),
+                requestBody,
+                { requestId: 'jobRemoval: ' + eventRow[0].dispatch_id }
+              );
+
+              if (jobResponse.data.error) {
+                resolve(false);
+              } else {
+                resolve(true);
+              }
+              break;
+              // OLD CODE
+              // const requestBody = JSON.parse(eventRow[0].payload);
+              // /* Logger.getInstance().logEvent(
+              //   'REQUEST BODY: ',
+              //   JSON.stringify(requestBody),
+              //   LOG_TYPE.SDK_DEBUG
+              // ); */
+              // const jobResponse = await this.networkInstance.requestPut(
+              //   ENDPOINTS.JOB_REMOVAL(requestBody.dispatchId),
+              //   requestBody.jobs,
+              //   { requestId: 'jobRemoval:' + requestBody.dispatchId }
+              // );
+              // if (jobResponse.data.error) {
+              //   resolve(false);
+              // } else {
+              //   resolve(true);
+              // }
+              // break;
+            }
+            // NEW CODE
+            case DispatchSyncType.DISPATCH_UPDATE: {
+              const requestBody = JSON.parse(eventRow[0].payload);
+              const dispatchUpdateResponse =
+                await this.networkInstance.requestPost(
+                  ENDPOINTS.BULK_JOB_UPDATE(eventRow[0].dispatch_id),
+                  requestBody,
+                  { requestId: 'dispatchUpdate: ' + eventRow[0].dispatch_id }
+                );
+
+              if (dispatchUpdateResponse.data.error) {
+                resolve(false);
+              } else {
+                resolve(true);
+              }
+              break;
+            }
+            default:
+              resolve(null);
+          }
+        } catch (error: any) {
+          reject(error);
+        }
+      }, 0); //1000
+    });
+  }
+
+  public async syncBulkEvent(eventRow: EventRow[]): Promise<boolean | null> {
+    if (eventRow.length < 1) return null;
+    return new Promise(async (resolve, reject) => {
+      setTimeout(async () => {
+        try {
+          const requestBody = eventRow.map((event) => {
+            return JSON.parse(event.payload);
+          });
+          const response = await this.networkInstance.requestPost(
+            ENDPOINTS.BULK_JOB_UPDATE(eventRow[0].dispatch_id),
+            requestBody,
+            { requestId: 'dispatchBulkUpdate: ' + eventRow[0].dispatch_id }
+          );
+
+          if (response.data.error) {
+            resolve(false);
+          } else {
+            resolve(true);
+          }
+        } catch (error: any) {
+          reject(error);
+        }
+      }, 0); //1000
+    });
+  }
+}