@os1-platform/dispatch-mobile 2.0.7 → 2.1.0

package/src/manager/dispatchCodes/EventCodeContainer.ts

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

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

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

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

@@ -0,0 +1,137 @@
+{
+  "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

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

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