@os1-platform/dispatch-mobile 2.1.1 → 2.1.2

package/src/manager/dispatchCodes/EventCodeContainer.ts

@@ -1,75 +0,0 @@
-import type {
-  ApplicableReasons,
-  NewApplicableReasons,
-} from '../../models/execTasks/ETBaseModels';
-import { BaseEventCodes } from '../../models/execTasks/ETConfig';
-import type { EventsRow } from '../syncmanager/DBConfig';
-import EventCodeRepo from './EventCodeRepo';
-
-export function getEventCodeByET(
-  _etName: string,
-  success: boolean,
-  events?: { [k: string]: string[] } | string[]
-): string {
-  if (events && Object.keys(events).length) {
-    return Object.keys(events).length > 1 ? '' : Object.keys(events)[0];
-  } else {
-    return success
-      ? BaseEventCodes.ENTITY_SUCCESS
-      : BaseEventCodes.ENTITY_FAILURE;
-  }
-}
-
-export default class EventCodeContainer {
-  private static instance: EventCodeContainer;
-  private constructor() {}
-
-  public static getInstance(): EventCodeContainer {
-    if (!EventCodeContainer.instance) {
-      EventCodeContainer.instance = new EventCodeContainer();
-    }
-    return EventCodeContainer.instance;
-  }
-
-  public async getEventCodes(applicableCodes: object): Promise<EventsRow[]> {
-    if (!applicableCodes || !Object.keys(applicableCodes).length) return [];
-    try {
-      const codes: string[] = Object.keys(applicableCodes);
-      let finalApplicableCodes =
-        await EventCodeRepo.getInstance().getEventsByCode(codes);
-      if (finalApplicableCodes && finalApplicableCodes.length > 0) {
-        return finalApplicableCodes;
-      } else return [];
-    } catch (error: any) {
-      return [];
-    }
-  }
-
-  public static getEventCodeFromText(
-    eventText: string,
-    events: EventsRow[]
-  ): string {
-    for (const r of events) {
-      if (r.description === eventText) {
-        return r.eventCode;
-      }
-    }
-    return '';
-  }
-
-  public async getEventByCode(code: string): Promise<EventsRow | null> {
-    try {
-      if (!code) return null;
-      else {
-        const queryResult = await EventCodeRepo.getInstance().getEventByCode(
-          code
-        );
-        if (queryResult && queryResult.length > 0) {
-          return queryResult[0];
-        } else return null;
-      }
-    } catch (error: any) {
-      return null;
-    }
-  }
-}

package/src/manager/dispatchCodes/EventCodeRepo.ts

@@ -1,82 +0,0 @@
-import * as Database from '../syncmanager/database';
-import {
-  EventsRow,
-  EVENT_CODES_TABLE,
-  EventColumns,
-} from '../syncmanager/DBConfig';
-import type { EventCodes } from '../../models/ReasonCodes';
-
-export default class EventCodeRepo {
-  private static instance: EventCodeRepo;
-  public static getInstance(): EventCodeRepo {
-    if (!EventCodeRepo.instance) {
-      EventCodeRepo.instance = new EventCodeRepo();
-    }
-    return EventCodeRepo.instance;
-  }
-
-  public async saveEventCode(eventsList: EventCodes[]) {
-    if (!eventsList || eventsList.length < 1) return;
-    await this.init();
-    await this.deleteAll();
-    const promises: any[] = [];
-    for (let r of eventsList) {
-      const eventRow: EventsRow = {
-        eventCode: r.eventCode,
-        description: r.description,
-        successEvent: r.successEvent,
-      };
-      promises.push(this.insertEvent(eventRow));
-    }
-    await Promise.all(promises);
-  }
-  private async insertEvent(event: EventsRow) {
-    await Database.executeQuery(
-      `INSERT OR REPLACE INTO ${EVENT_CODES_TABLE}(\
-                ${EventColumns.CODE},\
-                ${EventColumns.DESCRIPTION},\
-                ${EventColumns.SUCCESS_EVENT})\
-                values (?,?,?)`,
-      [event.eventCode, event.description, event.successEvent]
-    );
-  }
-
-  private async init(): Promise<void> {
-    await Database.executeQuery(
-      `CREATE TABLE IF NOT EXISTS ${EVENT_CODES_TABLE} (\
-                ${EventColumns.CODE} TEXT PRIMARY KEY NOT NULL,\
-                ${EventColumns.DESCRIPTION} TEXT,\
-                ${EventColumns.SUCCESS_EVENT} INTEGER);`,
-      []
-    );
-  }
-  public async getAllEventCodes(): Promise<EventsRow[]> {
-    const resultSet = await Database.executeQuery(
-      `SELECT * FROM ${EVENT_CODES_TABLE};`,
-      []
-    );
-    return resultSet.rows._array;
-  }
-  public async deleteAll() {
-    return Database.executeQuery(`DELETE FROM ${EVENT_CODES_TABLE};`, []);
-  }
-
-  public async getEventsByCode(codes: string[]): Promise<EventsRow[]> {
-    if (!codes || codes.length < 1) return [];
-    const placeholders = codes.map((it) => `'${it}'`).join(',');
-    const resultSet = await Database.executeQuery(
-      `SELECT * FROM ${EVENT_CODES_TABLE} WHERE ${EventColumns.CODE} IN (${placeholders});`,
-      []
-    );
-    return resultSet.rows._array;
-  }
-
-  public async getEventByCode(code: string): Promise<EventsRow[]> {
-    if (!code) return [];
-    const resultSet = await Database.executeQuery(
-      `SELECT * FROM ${EVENT_CODES_TABLE} WHERE ${EventColumns.CODE} = ?;`,
-      [code]
-    );
-    return resultSet.rows._array;
-  }
-}

package/src/manager/dispatchCodes/ReasonCodeContainer.ts

@@ -1,121 +0,0 @@
-import DispatchSdkCache from '../sdk/DispatchSdkCache';
-import Logger, { LOG_TYPE } from '../../utils/Logger';
-import { BaseError } from '../../errors/BaseError';
-import ErrorCodes from '../../errors/ErrorCodes';
-import ReasonCodeRepo from './ReasonCodeRepo';
-import type { ApplicableReasons } from '../../models/execTasks/ETBaseModels';
-import type { ReasonsRow } from '../syncmanager/DBConfig';
-import GraphQLClient from '../../network/GraphQLClient';
-
-export default class ReasonCodeContainer {
-  private static instance: ReasonCodeContainer;
-  private cache: DispatchSdkCache = DispatchSdkCache.getInstance();
-  private constructor() {}
-
-  public static getInstance(): ReasonCodeContainer {
-    if (!ReasonCodeContainer.instance) {
-      ReasonCodeContainer.instance = new ReasonCodeContainer();
-    }
-    return ReasonCodeContainer.instance;
-  }
-  public async getReasonCodes(
-    applicableCodes: ApplicableReasons,
-    entityCode: string
-  ): Promise<ReasonsRow[]> {
-    if (
-      !applicableCodes ||
-      applicableCodes[entityCode] == null ||
-      applicableCodes[entityCode].length < 1
-    )
-      return [];
-    try {
-      const codes: string[] = applicableCodes[entityCode];
-      let finalApplicableCodes =
-        await ReasonCodeRepo.getInstance().getReasonsByCode(codes);
-      if (finalApplicableCodes && finalApplicableCodes.length > 0) {
-        return finalApplicableCodes;
-      } else return [];
-    } catch (error: any) {
-      return [];
-    }
-  }
-  public static getReasonCodeFromText(
-    reasonText: string,
-    reasons: ReasonsRow[]
-  ): string {
-    for (const r of reasons) {
-      if (r.description === reasonText) {
-        return r.reasonCode;
-      }
-    }
-    return '';
-  }
-  public async getReasonByCode(code: string): Promise<ReasonsRow | null> {
-    try {
-      if (!code) return null;
-      else {
-        const queryResult = await ReasonCodeRepo.getInstance().getReasonByCode(
-          code
-        );
-        if (queryResult && queryResult.length > 0) {
-          return queryResult[0];
-        } else return null;
-      }
-    } catch (error: any) {
-      return null;
-    }
-  }
-
-  public async fetchReasonCode() {
-    const currentDate = new Date().toLocaleDateString();
-    const lastFetchedTime = await this.cache.getKeyFromCache(
-      DispatchSdkCache.KEYS.REASON_FETCH_TIME
-    );
-    const reasonFetchDate = new Date(
-      lastFetchedTime ? parseInt(lastFetchedTime) : 0
-    ).toLocaleDateString();
-    if (currentDate !== reasonFetchDate) {
-      try {
-        let graphlQLResponse =
-          await GraphQLClient.getInstance().fetchReasonCodes();
-        if (
-          graphlQLResponse &&
-          graphlQLResponse.data &&
-          graphlQLResponse.data.reasonList &&
-          graphlQLResponse.data.reasonList.data
-        ) {
-          await ReasonCodeRepo.getInstance().saveReasonCode(
-            graphlQLResponse.data.reasonList.data
-          );
-          await this.cache.setKeyInCache(
-            DispatchSdkCache.KEYS.REASON_FETCH_TIME,
-            Date.now().toString()
-          );
-        } else {
-          Logger.getInstance().logEvent(
-            'fetchReasonCode',
-            JSON.stringify(graphlQLResponse),
-            LOG_TYPE.SDK_ERROR
-          );
-          throw new BaseError(
-            ErrorCodes.REASON_CODE_API_ERROR,
-            'Unexpected error'
-          );
-        }
-      } catch (error: any) {
-        Logger.getInstance().logEvent(
-          'fetchReasonCode',
-          JSON.stringify(error),
-          LOG_TYPE.SDK_ERROR
-        );
-        throw new BaseError(ErrorCodes.REASON_CODE_API_ERROR, error.message);
-      }
-    } else {
-      Logger.getInstance().logEvent(
-        'fetchReasonCode',
-        'NO Fetch REQUIRED',
-        LOG_TYPE.SDK_INFO
-      );
-    }
-  }
-}

package/src/manager/dispatchCodes/ReasonCodeRepo.ts

@@ -1,90 +0,0 @@
-import * as Database from '../syncmanager/database';
-import {
-  ReasonColums,
-  REASONS_TABLE,
-  ReasonsRow,
-} from '../syncmanager/DBConfig';
-import type { ReasonCodes } from '../../models/ReasonCodes';
-
-export default class ReasonCodeRepo {
-  private static instance: ReasonCodeRepo;
-  public static getInstance(): ReasonCodeRepo {
-    if (!ReasonCodeRepo.instance) {
-      ReasonCodeRepo.instance = new ReasonCodeRepo();
-    }
-    return ReasonCodeRepo.instance;
-  }
-
-  public async saveReasonCode(reasonsList: ReasonCodes[]) {
-    if (!reasonsList || reasonsList.length < 1) return;
-    await this.init();
-    await this.deleteAll();
-    const promises: any[] = [];
-    for (let r of reasonsList) {
-      const reasonRow: ReasonsRow = {
-        reasonCode: r.reasonCode,
-        description: r.description,
-        isEnabled: r.isEnabled,
-        isSystemDefined: r.isSystemDefined,
-      };
-      promises.push(this.insertReason(reasonRow));
-    }
-    await Promise.all(promises);
-  }
-  private async insertReason(reason: ReasonsRow) {
-    await Database.executeQuery(
-      `INSERT OR REPLACE INTO ${REASONS_TABLE}(\
-                ${ReasonColums.CODE},\
-                ${ReasonColums.DESCRIPTION},\
-                ${ReasonColums.IS_ENABLED},\
-                ${ReasonColums.SYSTEM_DEFINED})\
-                values (?,?,?,?)`,
-      [
-        reason.reasonCode,
-        reason.description,
-        reason.isEnabled,
-        reason.isSystemDefined,
-      ]
-    );
-  }
-
-  private async init(): Promise<void> {
-    await Database.executeQuery(
-      `CREATE TABLE IF NOT EXISTS ${REASONS_TABLE} (\
-                ${ReasonColums.CODE} TEXT PRIMARY KEY NOT NULL,\
-                ${ReasonColums.DESCRIPTION} TEXT,\
-                ${ReasonColums.IS_ENABLED} INTEGER,\
-                ${ReasonColums.SYSTEM_DEFINED} INTEGER);`,
-      []
-    );
-  }
-  public async getAllReasons(): Promise<ReasonsRow[]> {
-    const resultSet = await Database.executeQuery(
-      `SELECT * FROM ${REASONS_TABLE};`,
-      []
-    );
-    return resultSet.rows._array;
-  }
-  public async deleteAll() {
-    return Database.executeQuery(`DELETE FROM ${REASONS_TABLE};`, []);
-  }
-
-  public async getReasonsByCode(codes: string[]): Promise<ReasonsRow[]> {
-    if (!codes || codes.length < 1) return [];
-    const placeholders = codes.map((it) => `'${it}'`).join(',');
-    const resultSet = await Database.executeQuery(
-      `SELECT * FROM ${REASONS_TABLE} WHERE (${ReasonColums.IS_ENABLED}=1) and  ${ReasonColums.CODE} IN (${placeholders});`,
-      []
-    );
-    return resultSet.rows._array;
-  }
-
-  public async getReasonByCode(code: string): Promise<ReasonsRow[]> {
-    if (!code) return [];
-    const resultSet = await Database.executeQuery(
-      `SELECT * FROM ${REASONS_TABLE} WHERE ${ReasonColums.CODE} = ?;`,
-      [code]
-    );
-    return resultSet.rows._array;
-  }
-}

package/src/manager/dispatchCodes/reasonCodes.json

@@ -1,137 +0,0 @@
-{
-  "006": {
-    "010": [],
-    "011": [
-      {
-        "reason": "DELIVERY_RESCHEDULED",
-        "text": "I want to reschedule this delivery",
-        "code": "0013"
-      },
-      {
-        "reason": "NOT_DELIVERED",
-        "text": "I want to cancel this task",
-        "code": "0014"
-      },
-      {
-        "reason": "REATTEMPT_DROP",
-        "text": "I want to re-attempt delivery for this package",
-        "code": "0015"
-      }
-    ]
-  },
-  "010": {
-    "010": [
-      {
-        "reason": "DELIVERED_TO_CONSIGNEE",
-        "text": "The shipment has been delivered to the consignee",
-        "code": "0041"
-      },
-      {
-        "reason": "DELIVERED_TO_SECURITY",
-        "text": "The shipment has been delivered to the security",
-        "code": "0042"
-      },
-      {
-        "reason": "DELIVERED_TO_OTHER_AS_PER_CONSIGNEE",
-        "text": "The shipment has been delivered to someone as told by consignee",
-        "code": "0043"
-      }
-    ],
-    "011": []
-  },
-  "017": {
-    "011": [
-      {
-        "reason": "PAYMENT_MODE/AMT_DISPUTE",
-        "text": "Amount dispute with consignee",
-        "code": "0020"
-      },
-      {
-        "reason": "PAYMENT_MODE/AMT_DISPUTE",
-        "text": "Payment mode dispute with consignee",
-        "code": "0020"
-      }
-    ],
-    "010": []
-  },
-  "021": {
-    "010": [
-      {
-        "reason": "CONSIGNEE_UNAVAILABLE",
-        "text": "Consignee is not available",
-        "code": "0029"
-      },
-      {
-        "reason": "CUSTOMER_ASKED_FOR_OPEN_DELIVERY",
-        "text": "Consignee has asked for open delivery",
-        "code": "0022"
-      },
-      {
-        "reason": "CONSIGNEE_OPEN_PACKAGE_AND_REFUSED_TO_ACCEPT",
-        "text": "Consignee has opened package and refused to accept",
-        "code": "0023"
-      },
-      {
-        "reason": "ENTRY_RESTRICTED_AREA",
-        "text": "This is an Entry restricted area",
-        "code": "0024"
-      },
-      {
-        "reason": "ADDRESS_QUALITY_ISSUE",
-        "text": "The address quality is not acceptable",
-        "code": "0025"
-      },
-      {
-        "reason": "NOT_ATTEMPTED",
-        "text": "I don't want to attempt this task",
-        "code": "0012"
-      },
-      {
-        "reason": "CONSIGNEE_REFUSED_ORDER",
-        "text": "Consignee refused to accept the package",
-        "code": "0027"
-      },
-      {
-        "reason": "CONSIGNEE_SEIZED_PACKAGE",
-        "text": "Consignee has forcefully taken the package",
-        "code": "0028"
-      }
-    ],
-    "011": [
-      {
-        "reason": "NOT_ATTEMPTED",
-        "text": "I don't want to attempt this task",
-        "code": "0012"
-      },
-      {
-        "reason": "ENTRY_RESTRICTED_AREA",
-        "text": "This is an Entry restricted area",
-        "code": "0024"
-      },
-      {
-        "reason": "ADDRESS_QUALITY_ISSUE",
-        "text": "The address quality is not acceptable",
-        "code": "0025"
-      },
-      {
-        "reason": "CONSIGNEE_REFUSED_ORDER",
-        "text": "Consignee refused to accept the package",
-        "code": "0027"
-      },
-      {
-        "reason": "CONSIGNEE_SEIZED_PACKAGE",
-        "text": "Consignee has forcefully taken the package",
-        "code": "0028"
-      }
-    ]
-  },
-  "022": {
-    "010": [
-      {
-        "reason": "CONSIGNEE_REFUSED_ORDER",
-        "text": "Consignee refused to accept the package",
-        "code": "0027"
-      }
-    ]
-  }
-}

package/src/manager/jobRemoval/JobRemovalManager.ts

@@ -1,21 +0,0 @@
-// TODO: Move to execution-engine for Job Removal Manager
-
-// const dispatchExecutor = new ExecutionEngine();
-
-// export default class JobRemovalManager {
-//   private static instance: JobRemovalManager;
-
-//   private constructor() {}
-
-//   public static getInstance(): JobRemovalManager {
-//     if (!JobRemovalManager.instance) {
-//       let managerInstance = new JobRemovalManager();
-//       JobRemovalManager.instance = managerInstance;
-//     }
-//     return JobRemovalManager.instance;
-//   }
-
-//   public async handleRemoval(dispatchId: string, jobs: string[]) {
-//     return await dispatchExecutor.validateJobRemoval(dispatchId, jobs);
-//   }
-// }

package/src/manager/location/LocationManager.ts

@@ -1,77 +0,0 @@
-import * as Location from 'expo-location';
-import { Accuracy, LocationObject } from 'expo-location';
-import Logger, { LOG_TYPE } from '../../utils/Logger';
-
-export default class LocationManager {
-  private static instance: LocationManager;
-  private lastLocation: LocationObject | null = null;
-  private stopUpdate: { remove(): void } | undefined;
-
-  public async checkForLocationPermissions(): Promise<boolean> {
-    let permissionResponse = await Location.getForegroundPermissionsAsync();
-    if (permissionResponse.status === 'granted') {
-      this.startUpdates();
-      return true;
-    } else {
-      let { status } = await Location.requestForegroundPermissionsAsync();
-      if (status === 'granted') {
-        this.startUpdates();
-        return true;
-      } else {
-        this.stopLocationUpdates();
-        return false;
-      }
-    }
-  }
-
-  public static getInstance(): LocationManager {
-    if (!LocationManager.instance) {
-      LocationManager.instance = new LocationManager();
-    }
-    return LocationManager.instance;
-  }
-  public startUpdates() {
-    Location.watchPositionAsync(
-      {
-        accuracy: Accuracy.Highest,
-        timeInterval: 10000, // in millis
-        distanceInterval: 10, //in metres
-      },
-      (location) => {
-        if (location != null) {
-          this.lastLocation = location;
-        }
-      }
-    )
-      .then((r) => {
-        this.stopUpdate = r;
-      })
-      .catch((error) => {
-        Logger.getInstance().logEvent(
-          'LOCATION_MANAGER',
-          error.message,
-          LOG_TYPE.SDK_WARNING
-        );
-      });
-  }
-  public getLastLocation(): DLocation {
-    if (this.lastLocation != null && this.lastLocation.coords != null) {
-      return {
-        latitude: this.lastLocation.coords.latitude.toString(),
-        longitude: this.lastLocation.coords.longitude.toString(),
-      };
-    } else {
-      return { latitude: 'null', longitude: 'null' };
-    }
-  }
-  public stopLocationUpdates() {
-    try {
-      if (this.stopUpdate) this.stopUpdate.remove();
-    } catch (error: any) {}
-  }
-}
-
-export interface DLocation {
-  latitude: string;
-  longitude: string;
-}