@os1-platform/dispatch-mobile 2.0.8 → 2.1.0

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

@@ -0,0 +1,633 @@
+import { isEmptyOrBlank } from '../../../utils/utils';
+import {
+  BulkEvent,
+  CustodyData,
+  DispatchSyncType,
+  EventETData,
+  EventRow,
+  EVENTS_COLUMNS,
+  EVENTS_TABLE,
+  SyncManagerPayload,
+  ExecEngineSyncType,
+  WFUpdateBulkEventData,
+  WIUpdateOutputPayload,
+  WORKFLOW_INSTANCE_COLUMNS,
+  WORKFLOW_INSTANCE_TABLE,
+} from '../DBConfig';
+import type { ExecQuery } from '../database';
+import * as Database from '../database';
+import { BaseError } from '../../../errors/BaseError';
+import BaseErrorCodes, {
+  InvalidArgumentsError,
+} from '../../../errors/ErrorCodes';
+import Logger, { LOG_TYPE } from '../../../utils/Logger';
+import { BULK_DATA_LIMIT } from '../constants';
+import Storage from '../../../utils/storage';
+
+// NEW CODE
+import {
+  DispatchExecutor,
+  IDispatch,
+} from '@os1-platform/platform-coreos-execution-engine-sdk';
+const SyncType = IDispatch.SyncType;
+
+export default class ETEventsManager {
+  private static instance: ETEventsManager;
+  private maxRetryCount: number = 3;
+  private _retries = 0;
+
+  private constructor() {}
+
+  public static async getInstance(): Promise<ETEventsManager> {
+    if (!ETEventsManager.instance) {
+      let manager = new ETEventsManager();
+      await ETEventsManager.init();
+      ETEventsManager.instance = manager;
+    }
+    return ETEventsManager.instance;
+  }
+
+  // NEED TO REMOVE SYNCED, CONFIG, OBJECTIVE_REF
+  private static async init(): Promise<void> {
+    await Database.executeQuery(
+      `CREATE TABLE IF NOT EXISTS ${EVENTS_TABLE} (\
+                ${EVENTS_COLUMNS.ID} INTEGER PRIMARY KEY AUTOINCREMENT,\
+                ${EVENTS_COLUMNS.DISPATCH_ID} TEXT NOT NULL,\
+                ${EVENTS_COLUMNS.PAYLOAD} TEXT NOT NULL,\
+                ${EVENTS_COLUMNS.CONFIG} TEXT,\
+                ${EVENTS_COLUMNS.SYNC_TYPE} TEXT NOT NULL,\
+                ${EVENTS_COLUMNS.DATA_LENGTH} INTEGER DEFAULT 0 NOT NULL,\
+                ${EVENTS_COLUMNS.META} TEXT NOT NULL,\
+                ${EVENTS_COLUMNS.SYNCED} INTEGER DEFAULT 0 NOT NULL,\
+                ${EVENTS_COLUMNS.SYNC_ERROR} TEXT);`,
+      []
+    );
+  }
+
+  async insertEvent(
+    sequence: number,
+    payload: string,
+    dspID: string,
+    syncType: string,
+    objectiveRef: string,
+    config?: string
+  ): Promise<void> {
+    await Database.executeQuery(
+      `INSERT INTO ${EVENTS_TABLE}(\
+                ${EVENTS_COLUMNS.PAYLOAD},\
+                ${EVENTS_COLUMNS.DISPATCH_ID},\
+                ${EVENTS_COLUMNS.SEQUENCE},\
+                ${EVENTS_COLUMNS.CONFIG},\
+                ${EVENTS_COLUMNS.SYNC_TYPE},\
+                ${EVENTS_COLUMNS.META}) \
+                values (?,?,?,?,?,?)`,
+      [payload, dspID, sequence, config ?? null, syncType, objectiveRef]
+    );
+  }
+
+  private async getWFIPayload(
+    _bulkEventData: BulkEvent
+  ): Promise<Array<WIUpdateOutputPayload>> {
+    const result: Array<WIUpdateOutputPayload> = [];
+    const dispatchId = _bulkEventData.dispatchId;
+    const { status, timestamp, code, attemptId, updatedBy, mergedObjectiveId } =
+      _bulkEventData.meta;
+    const outData: any = {};
+    const output: WFUpdateBulkEventData = _bulkEventData.data;
+
+    let offset = 0;
+    let jobMapping: Array<{ jobId: string; workflowInstanceId: string }> =
+      await DispatchExecutor.getJobMapping(
+        mergedObjectiveId,
+        BULK_DATA_LIMIT,
+        offset
+      );
+    do {
+      const __unmerged: Array<{ jobId: string; workflowInstanceId: string }> =
+        jobMapping;
+
+      Object.keys(output).forEach((customETName: string) => {
+        outData[customETName] = output[customETName];
+      });
+
+      result.push({
+        dispatchId,
+        updatedBy,
+        workflows: [
+          {
+            status,
+            attemptId,
+            timestamp,
+            code,
+            data: outData,
+            __unmerged,
+            meta: {},
+          },
+        ],
+      });
+
+      offset += BULK_DATA_LIMIT;
+      jobMapping = await DispatchExecutor.getJobMapping(
+        mergedObjectiveId,
+        BULK_DATA_LIMIT,
+        offset
+      );
+    } while (jobMapping.length > 0);
+
+    return result;
+  }
+
+  private getCustodyPayload(_bulkEventData: BulkEvent) {
+    const data: Array<CustodyData> = _bulkEventData.data;
+    return data;
+  }
+
+  private getJobRemovalPayload(_bulkEventData: BulkEvent) {
+    const data: any = _bulkEventData.data;
+    return data;
+  }
+
+  private getDispatchUpdatePayload(_bulkEventData: BulkEvent) {
+    const data: any = _bulkEventData.data;
+    const payload = data.payload;
+    return payload;
+  }
+
+  private async _modifyEventData(
+    _bulkEventData: BulkEvent
+  ): Promise<Array<SyncManagerPayload>> {
+    const syncType: ExecEngineSyncType | DispatchSyncType =
+      _bulkEventData.syncType;
+    switch (syncType) {
+      case SyncType.CUSTODY_IN_SCAN: {
+        const custodyInScans = this.getCustodyPayload(_bulkEventData);
+        return [
+          {
+            data: {
+              action: SyncType.CUSTODY_IN_SCAN,
+              payload: { output: custodyInScans },
+            },
+            length: custodyInScans.length,
+          },
+        ];
+      }
+      case SyncType.CUSTODY_OUT_SCAN: {
+        const custodyOutScans = this.getCustodyPayload(_bulkEventData);
+
+        return [
+          {
+            data: {
+              action: SyncType.CUSTODY_OUT_SCAN,
+              payload: { output: custodyOutScans },
+            },
+            length: custodyOutScans.length,
+          },
+        ];
+      }
+      case SyncType.WORKFLOW: {
+        const payload = await this.getWFIPayload(_bulkEventData);
+        return payload.map((_payload) => ({
+          data: { action: SyncType.WORKFLOW, payload: _payload },
+          length: _payload.workflows[0].__unmerged?.length || 0,
+        }));
+      }
+      case SyncType.JOB_REMOVAL: {
+        const jobRemoval = this.getJobRemovalPayload(_bulkEventData);
+        const length =
+          jobRemoval?.success?.length + jobRemoval?.failure?.length;
+        return [
+          {
+            data: {
+              action: SyncType.JOB_REMOVAL,
+              payload: jobRemoval,
+            },
+            length: length || 0,
+          },
+        ];
+      }
+      case DispatchSyncType.DISPATCH_UPDATE: {
+        return [
+          {
+            data: {
+              action: DispatchSyncType.DISPATCH_UPDATE,
+              payload: this.getDispatchUpdatePayload(_bulkEventData),
+            },
+            length: 1,
+          },
+        ];
+      }
+      default: {
+        return [
+          {
+            data: {
+              action: DispatchSyncType.DEFAULT,
+              payload: {},
+            },
+            length: 0,
+          },
+        ];
+      }
+    }
+  }
+
+  private splitData(data: any, chunkSize: number, splitKey: string): any[] {
+    const result: any = [];
+    const splitArray = data[splitKey];
+
+    if (!splitArray || !Array.isArray(splitArray)) {
+      return result;
+    }
+
+    for (let i = 0; i < splitArray.length; i += chunkSize) {
+      const chunk: any = {};
+
+      for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+          chunk[key] =
+            key === splitKey ? splitArray.slice(i, i + chunkSize) : data[key];
+        }
+      }
+
+      result.push(chunk);
+    }
+
+    return result;
+  }
+
+  // NEW CODE
+  async insertQueueEvent(_eventData: BulkEvent): Promise<void> {
+    let args: any[] = [];
+    let values: any[] = [];
+    let queryData: ExecQuery[] = []; //final data to pass to db
+    try {
+      values.push(`(?,?,?,?)`);
+      const _meta = JSON.stringify(_eventData.meta);
+      args.push(
+        _eventData.data,
+        _eventData.dispatchId,
+        _eventData.syncType,
+        _meta
+        // ? _evData.meta.jobId + _evData.meta.objectiveReference
+        // : 'NO_REF_FOUND'
+      );
+      queryData.push({
+        query: `INSERT INTO ${EVENTS_TABLE}(\
+              ${EVENTS_COLUMNS.PAYLOAD},\
+              ${EVENTS_COLUMNS.DISPATCH_ID},\
+              ${EVENTS_COLUMNS.SYNC_TYPE},\
+              ${EVENTS_COLUMNS.META}) \
+              values ${values.join(',')};`,
+        args,
+      });
+      await Database.executeBulkQuery(queryData);
+      this._retries = 0;
+    } catch (err) {
+      if (this._retries < this.maxRetryCount) {
+        Logger.getInstance().logEvent(
+          'insertQueueEvent ',
+          this._retries.toString(),
+          LOG_TYPE.SDK_DEBUG
+        );
+        this._retries++;
+        await this.insertQueueEvent(_eventData);
+      } else {
+        this._retries = 0;
+        throw err;
+      }
+    }
+  }
+
+  // NEW CODE
+  async insertBulkEvent(_eventData: BulkEvent): Promise<void> {
+    try {
+      const output: Array<SyncManagerPayload> = await this._modifyEventData(
+        _eventData
+      );
+      let args: any[] = [];
+      let values: any[] = [];
+      let queryData: ExecQuery[] = []; //final data to pass to db
+      const _meta = JSON.stringify(_eventData.meta || {});
+
+      if (
+        _eventData.syncType === SyncType.WORKFLOW ||
+        _eventData.syncType === SyncType.CUSTODY_IN_SCAN ||
+        _eventData.syncType === SyncType.CUSTODY_OUT_SCAN ||
+        _eventData.syncType === DispatchSyncType.DISPATCH_UPDATE
+      ) {
+        output.forEach(
+          (syncManagerPayload: SyncManagerPayload, index: number) => {
+            const _payload = JSON.stringify(syncManagerPayload.data);
+            if (
+              isEmptyOrBlank(syncManagerPayload.data.action) ||
+              isEmptyOrBlank(_payload)
+            ) {
+              throw new BaseError(
+                BaseErrorCodes.InvalidArgumentError,
+                InvalidArgumentsError
+              );
+            }
+            values.push(`(?,?,?,?,?)`);
+            args.push(
+              _payload,
+              _eventData.dispatchId,
+              _eventData.syncType,
+              syncManagerPayload.length,
+              _meta
+            );
+            queryData.push({
+              query: `INSERT INTO ${EVENTS_TABLE}(\
+              ${EVENTS_COLUMNS.PAYLOAD},\
+              ${EVENTS_COLUMNS.DISPATCH_ID},\
+              ${EVENTS_COLUMNS.SYNC_TYPE},\
+              ${EVENTS_COLUMNS.DATA_LENGTH},\
+              ${EVENTS_COLUMNS.META}) \
+              values ${values.join(',')};`,
+              args,
+            });
+            values = [];
+            args = [];
+          }
+        );
+
+        await Database.executeBulkQuery(queryData);
+        this._retries = 0;
+      }
+      // else if (
+      //   _eventData.syncType === SyncType.CUSTODY_IN_SCAN ||
+      //   _eventData.syncType === SyncType.CUSTODY_OUT_SCAN
+      // ) {
+      //   output.forEach(
+      //     (syncManagerPayload: SyncManagerPayload, index: number) => {
+      //       const _payload = JSON.stringify(syncManagerPayload);
+      //       if (
+      //         isEmptyOrBlank(syncManagerPayload.action) ||
+      //         isEmptyOrBlank(_payload)
+      //       ) {
+      //         throw new BaseError(
+      //           BaseErrorCodes.InvalidArgumentError,
+      //           InvalidArgumentsError
+      //         );
+      //       }
+      //       values.push(`(?,?,?,?)`);
+      //       args.push(
+      //         _payload,
+      //         _eventData.dispatchId,
+      //         _eventData.syncType,
+      //         _meta
+      //       );
+      //       queryData.push({
+      //         query: `INSERT INTO ${EVENTS_TABLE}(\
+      //         ${EVENTS_COLUMNS.PAYLOAD},\
+      //         ${EVENTS_COLUMNS.DISPATCH_ID},\
+      //         ${EVENTS_COLUMNS.SYNC_TYPE},\
+      //         ${EVENTS_COLUMNS.OBJECTIVE_REF}) \
+      //         values ${values.join(',')};`,
+      //         args,
+      //       });
+      //       values = [];
+      //       args = [];
+      //     }
+      //   );
+
+      //   await Database.executeBulkQuery(queryData);
+      //   this._retries = 0;
+      // } else if (_eventData.syncType === DispatchSyncType.DISPATCH_UPDATE) {
+      // }
+      else {
+        const chunkedData = this.splitData(output, BULK_DATA_LIMIT, 'payload');
+
+        chunkedData.forEach((_evData, index) => {
+          const _payload = JSON.stringify(_evData.payload);
+          if (isEmptyOrBlank(_evData.action) || isEmptyOrBlank(_payload))
+            throw new BaseError(
+              BaseErrorCodes.InvalidArgumentError,
+              InvalidArgumentsError
+            );
+          values.push(`(?,?,?,?,?)`);
+          args.push(_evData, _eventData.dispatchId, _eventData.syncType, _meta);
+          queryData.push({
+            query: `INSERT INTO ${EVENTS_TABLE}(\
+              ${EVENTS_COLUMNS.PAYLOAD},\
+              ${EVENTS_COLUMNS.DISPATCH_ID},\
+              ${EVENTS_COLUMNS.SYNC_TYPE},\
+              ${EVENTS_COLUMNS.DATA_LENGTH},\
+              ${EVENTS_COLUMNS.META}) \
+              values ${values.join(',')};`,
+            args,
+          });
+          values = [];
+          args = [];
+        });
+        await Database.executeBulkQuery(queryData);
+        this._retries = 0;
+      }
+    } catch (err) {
+      if (this._retries < this.maxRetryCount) {
+        Logger.getInstance().logEvent(
+          'insertBulkEvent ',
+          this._retries.toString(),
+          LOG_TYPE.SDK_DEBUG
+        );
+        this._retries++;
+        await this.insertBulkEvent(_eventData);
+      } else {
+        this._retries = 0;
+        throw err;
+      }
+    }
+  }
+
+  // OLD CODE
+  // async insertBulkEvent(_eventData: BulkEvent[]): Promise<void> {
+  //   try {
+  //     let args: any[] = [];
+  //     let values: any[] = [];
+  //     let queryData: ExecQuery[] = []; //final data to pass to db
+  //     let evIndex = 100;
+
+  //     _eventData.forEach((_evData, index) => {
+  //       if (
+  //         !_evData.sequence ||
+  //         isEmptyOrBlank(_evData.data) ||
+  //         isEmptyOrBlank(_evData.dispatchId) ||
+  //         isEmptyOrBlank(_evData.syncType)
+  //       )
+  //         throw new BaseError(
+  //           BaseErrorCodes.InvalidArgumentError,
+  //           InvalidArgumentsError
+  //         );
+
+  //       values.push(`(?,?,?,?,?)`);
+  //       args.push(
+  //         _evData.data,
+  //         _evData.dispatchId,
+  //         // _evData.sequence,
+  //         _evData.config ? JSON.stringify(_evData.config) : null,
+  //         _evData.syncType,
+  //         _evData.meta
+  //           ? _evData.meta.jobId + _evData.meta.objectiveReference
+  //           : 'NO_REF_FOUND'
+  //       );
+  //       if (index === evIndex || index === _eventData.length - 1) {
+  //         queryData.push({
+  //           query: `INSERT INTO ${EVENTS_TABLE}(\
+  //         ${EVENTS_COLUMNS.PAYLOAD},\
+  //         ${EVENTS_COLUMNS.DISPATCH_ID},\
+  //         ${EVENTS_COLUMNS.CONFIG},\
+  //         ${EVENTS_COLUMNS.SYNC_TYPE},\
+  //         ${EVENTS_COLUMNS.OBJECTIVE_REF}) \
+  //         values ${values.join(',')};`,
+  //           args,
+  //         });
+  //         values = [];
+  //         args = [];
+  //         evIndex = evIndex + evIndex;
+  //       }
+  //     });
+
+  //     await Database.executeBulkQuery(queryData);
+  //     this._retries = 0;
+  //   } catch (err) {
+  //     if (this._retries < this.maxRetryCount) {
+  //       Logger.getInstance().logEvent(
+  //         'insertBulkEvent ',
+  //         this._retries.toString(),
+  //         LOG_TYPE.SDK_DEBUG
+  //       );
+  //       this._retries++;
+  //       await this.insertBulkEvent(_eventData);
+  //     } else {
+  //       this._retries = 0;
+  //       throw err;
+  //     }
+  //   }
+  // }
+
+  async getAllEvents(dispatchID?: string): Promise<EventRow[]> {
+    if (dispatchID) {
+      const resultSet = await Database.executeQuery(
+        `SELECT * FROM ${EVENTS_TABLE}\
+            WHERE ${EVENTS_COLUMNS.DISPATCH_ID} = ?;`,
+        [dispatchID]
+      );
+      return resultSet.rows._array;
+    } else {
+      const resultSet = await Database.executeQuery(
+        `SELECT * FROM ${EVENTS_TABLE};`,
+        []
+      );
+      return resultSet.rows._array;
+    }
+  }
+
+  async getAllUnsyncedEvents(): Promise<EventRow[]> {
+    let resultSet = await Database.executeQuery(
+      `SELECT * FROM ${EVENTS_TABLE} \
+            where ${EVENTS_COLUMNS.SYNCED} = 0;`,
+      []
+    );
+    return resultSet.rows._array;
+  }
+
+  public deleteAllEvents() {
+    const deleteEventsQuery = {
+      query: `DELETE FROM ${EVENTS_TABLE};`,
+      args: [],
+    };
+    const resetAutoIncrementSequence = {
+      query: `UPDATE sqlite_sequence SET seq = 0 WHERE name
+     = '${EVENTS_TABLE}';`,
+      args: [],
+    };
+
+    return Database.executeBulkQuery([
+      deleteEventsQuery,
+      resetAutoIncrementSequence,
+    ]);
+  }
+
+  async updateError(id: number, syncError: string): Promise<void> {
+    if (!id) throw new TypeError('Event ID cannot be null');
+    await Database.executeQuery(
+      `UPDATE ${EVENTS_TABLE} \
+            SET \
+            ${EVENTS_COLUMNS.SYNC_ERROR} = ?  WHERE ${EVENTS_COLUMNS.ID} = ?;`,
+      [syncError, id]
+    );
+  }
+
+  async markEventSynced(id: number): Promise<void> {
+    if (!id) throw new TypeError('Event ID cannot be null');
+    await Database.executeQuery(
+      `UPDATE ${EVENTS_TABLE} SET ${EVENTS_COLUMNS.SYNCED} = 1 WHERE ${EVENTS_COLUMNS.ID} = ?;`,
+      [id]
+    );
+  }
+
+  async getWorkflowUpdateEvents(syncType: string): Promise<EventRow[]> {
+    let sqlResultSet = await Database.executeQuery(
+      `SELECT * from ${EVENTS_TABLE}\
+            WHERE ${EVENTS_COLUMNS.SYNCED} = 0\
+            and ${EVENTS_COLUMNS.SYNC_TYPE} = ?\
+            ORDER BY ${EVENTS_COLUMNS.ID} ASC LIMIT 1;`,
+      [syncType]
+    );
+    return sqlResultSet.rows._array;
+  }
+  async getJobRemovalEvents(syncType: string): Promise<EventRow[]> {
+    let sqlResultSet = await Database.executeQuery(
+      `SELECT * from ${EVENTS_TABLE}\
+            WHERE ${EVENTS_COLUMNS.SYNCED} = 0\
+            and ${EVENTS_COLUMNS.SYNC_TYPE} = ?\
+            ORDER BY ${EVENTS_COLUMNS.ID} ASC LIMIT 1;`,
+      [syncType]
+    );
+    return sqlResultSet.rows._array;
+  }
+  async getCustodyBatch(dispatchID: string): Promise<EventRow[]> {
+    const sqlResult = await Database.executeQuery(
+      `SELECT * from ${EVENTS_TABLE}\
+            WHERE ${EVENTS_COLUMNS.SYNCED} = 0 and \
+            (${EVENTS_COLUMNS.SYNC_TYPE} = ? or ${EVENTS_COLUMNS.SYNC_TYPE} = ?) \
+            and ${EVENTS_COLUMNS.DISPATCH_ID} = ? \
+            ORDER BY ${EVENTS_COLUMNS.ID} ASC;`,
+      [SyncType.CUSTODY_IN_SCAN, SyncType.CUSTODY_OUT_SCAN, dispatchID]
+    );
+    return sqlResult.rows._array;
+  }
+  async getObjectiveDetails(objectiveRef: string): Promise<EventRow[]> {
+    let rs = await Database.executeQuery(
+      `SELECT * from ${EVENTS_TABLE} WHERE ${EVENTS_COLUMNS.META} = ?;`,
+      [objectiveRef]
+    );
+    return rs.rows._array;
+  }
+
+  async getRowToSync(id: string, dispatchId: string): Promise<EventRow[]> {
+    const sqlResult = await Database.executeQuery(
+      `SELECT * from ${EVENTS_TABLE}\
+            WHERE ${EVENTS_COLUMNS.ID} = ? and \
+            ${EVENTS_COLUMNS.DISPATCH_ID} = ? \
+            ORDER BY ${EVENTS_COLUMNS.ID} ASC;`,
+      [id, dispatchId]
+    );
+    return sqlResult.rows._array;
+  }
+
+  async getBulkRowsToSync(id: string, dispatchId: string): Promise<EventRow[]> {
+    const query = `SELECT * FROM \
+        (SELECT *, \ 
+          (SELECT SUM(${EVENTS_COLUMNS.DATA_LENGTH}) \
+              FROM ${EVENTS_TABLE} \
+                WHERE id <= t.id and ${EVENTS_COLUMNS.ID} > ${id} and ${EVENTS_COLUMNS.DISPATCH_ID} \ = '${dispatchId}' and ${EVENTS_COLUMNS.DATA_LENGTH} > 0 \
+                ) total \
+                FROM ${EVENTS_TABLE} t \
+                ) q \
+                WHERE total <= ${BULK_DATA_LIMIT} \
+                ORDER BY ${EVENTS_COLUMNS.ID};`;
+
+    const sqlResult = await Database.executeQuery(query, []);
+
+    return sqlResult.rows._array;
+  }
+}