@os1-platform/dispatch-mobile 2.1.0 → 2.1.2

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

@@ -1,633 +0,0 @@
-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;
-  }
-}