@os1-platform/dispatch-mobile 2.1.2 → 2.1.3

package/src/ui/screens/ScanScreen.tsx

@@ -0,0 +1,159 @@
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import React, { useEffect, useState } from 'react';
+import type { BaseETProps } from '../../models/DispatchModels';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import type { ScannerOutput } from '../../components/executiontasks/scan/ScanSchema';
+import ScanET from '../../components/executiontasks/scan/ScanET';
+import { onTaskStart } from '../../utils/ExecTaskUtils';
+import { DispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
+import Storage from '../../utils/storage';
+import { SCAN_MERGED_OBJ_ID_OUTPUT } from '../../manager/syncmanager/constants';
+import {
+  SCANNED_RECORD,
+  SCAN_MERGED_OBJ_ID_INTEFACE,
+} from '../../components/executiontasks/scan/interfaces';
+
+const ScanScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta, taskName } =
+    getDataFromNextState(nextState);
+
+  let _route = JSON.parse(JSON.stringify(route));
+  const firstInput = input;
+
+  const [inputs, setInputs] = useState({
+    ...firstInput,
+    wfMeta,
+    mergedObjectiveId,
+  });
+
+  useEffect(() => {
+    (async () => {
+      // Setup mergedIds in Shared Prefs
+      const prefixedMergedObjectiveId =
+        route.params[RouteParams.ROOT_META_DATA].prefixedMergedObjectiveId;
+
+      let storage = Storage.getInstance();
+      const _mergedIdsOut = await storage.getSharedItem(
+        SCAN_MERGED_OBJ_ID_OUTPUT
+      );
+      const mergedIdsOutput: SCAN_MERGED_OBJ_ID_INTEFACE = JSON.parse(
+        _mergedIdsOut || '{}'
+      );
+
+      if (_mergedIdsOut) {
+        const mergedIds: SCANNED_RECORD =
+          mergedIdsOutput[prefixedMergedObjectiveId];
+        const runningMergedIds = mergedObjectiveId;
+
+        // CHECK IF PREFIXED ID IS PRESENT IN SUCCESS | FAILURE;
+        if (mergedIds) {
+          mergedObjectiveId.forEach((ids: string) => {
+            const isDelivered = mergedIds.success.indexOf(ids) !== -1;
+            const isUnDelivered = mergedIds.failure.indexOf(ids) !== -1;
+            const isAlreadyPending = mergedIds.pending.indexOf(ids) !== -1;
+
+            if (!isDelivered && !isUnDelivered && !isAlreadyPending) {
+              mergedIds.pending.push(ids);
+            }
+          });
+          await storage.setSharedItem(
+            SCAN_MERGED_OBJ_ID_OUTPUT,
+            JSON.stringify({
+              ...mergedIdsOutput,
+              [prefixedMergedObjectiveId]: mergedIds,
+            })
+          );
+        } else {
+          const mergedIds: SCANNED_RECORD = {
+            success: [],
+            failure: [],
+            pending: [],
+          };
+          mergedObjectiveId.forEach((ids: string) => {
+            mergedIds.pending.push(ids);
+          });
+
+          await storage.setSharedItem(
+            SCAN_MERGED_OBJ_ID_OUTPUT,
+            JSON.stringify({
+              ...mergedIdsOutput,
+              [prefixedMergedObjectiveId]: mergedIds,
+            })
+          );
+        }
+      } else {
+        const mergedIds: SCANNED_RECORD = {
+          success: [],
+          failure: [],
+          pending: [],
+        };
+        mergedObjectiveId.forEach((ids: string) => {
+          mergedIds.pending.push(ids);
+        });
+
+        await storage.setSharedItem(
+          SCAN_MERGED_OBJ_ID_OUTPUT,
+          JSON.stringify({
+            ...mergedIdsOutput,
+            [prefixedMergedObjectiveId]: mergedIds,
+          })
+        );
+      }
+
+      onTaskStart(
+        route.params[RouteParams.NEXT_STATES],
+        route.params[RouteParams.ROOT_META_DATA].customEventsData
+      );
+
+      const result = await DispatchExecutor.getScannedShipmentsCount(
+        mergedObjectiveId // need to define and pass to props
+      );
+
+      setInputs((prev: any) => ({
+        ...prev,
+        scanCountLimit: result ? result.totalCount : 0,
+      }));
+    })();
+  }, []);
+
+  return (
+    <ScanET
+      {...inputs}
+      scanToMerge={inputs.scanToMerge || false}
+      mergedObjectiveId={mergedObjectiveId}
+      taskMeta={taskMeta}
+      navigation={navigation}
+      route={route}
+      taskName={taskName}
+      showProgress={baseETProps.showProgress}
+      onSubmitET={async (etOutput: ScannerOutput) => {
+        let scanETOutput: any = etOutput;
+
+        await DispatchStateContainer.getInstance().navigateToNextTask(
+          navigation,
+          _route,
+          scanETOutput,
+          true,
+          EntityCode.SCAN,
+          ExecutionTaskID.SCAN,
+          baseETProps,
+          false,
+          true
+        );
+      }}
+    />
+  );
+};
+
+export default withBaseDispatchScreen(ScanScreen);

package/src/ui/screens/StartWorkFlowScreen.tsx

@@ -0,0 +1,233 @@
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import { Platform, StyleSheet, Text, View } from 'react-native';
+import React, { useCallback, useEffect } from 'react';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import type { BaseETProps } from '../../models/DispatchModels';
+import LocationManager from '../../manager/location/LocationManager';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import { getBaseETResponse, onTaskStart } from '../../utils/ExecTaskUtils';
+import { getEventCodeByET } from '../../manager/dispatchCodes/EventCodeContainer';
+import { RouteParams } from '../uiConfig/RouteParams';
+import { isMandatoryKeysPresent } from '../../utils/utils';
+import Logger, { LOG_TYPE } from '../../utils/Logger';
+import SdkUtils from '../../utils/SdkUtils';
+import { showAlert } from '../../components/widgets/AlertDisplay';
+import ErrorCodes, { MultiObjectiveError } from '../../errors/ErrorCodes';
+import NativeSyncManager from '../../manager/syncmanager/NativeSyncManager';
+import AppSyncManager from '../../manager/syncmanager/AppSyncManager';
+import {
+  IDispatch,
+  IDispatchExecutor,
+} from '@os1-platform/platform-coreos-execution-engine-sdk';
+
+const instance = DispatchStateContainer.getInstance();
+const TAG = 'StartWorkFlowScreen';
+
+const StartWorkFlowScreen = ({
+  baseETProps,
+  route,
+  navigation,
+}: {
+  baseETProps: BaseETProps;
+  route: any;
+  navigation: any;
+}) => {
+  const showAlertMessage = useCallback(
+    (errorMessage: string, title: string) => {
+      showAlert(title, errorMessage, false, 'OK', () => {
+        navigation.goBack();
+      });
+    },
+    [navigation]
+  );
+  const navigateWithError = useCallback(
+    (errorCode: string, errorMessage: string) => {
+      if (route.params.initRoute) {
+        navigation.navigate({
+          name: route.params.initRoute,
+          params: { sdkError: { code: errorCode, message: errorMessage } },
+          merge: true,
+        });
+      } else {
+        showAlertMessage(errorMessage, 'Error');
+      }
+    },
+    [navigation, route.params.initRoute, showAlertMessage]
+  );
+  useEffect(() => {
+    (async () => {
+      try {
+        baseETProps.showProgress(true);
+        await SdkUtils.checkMandatory();
+        if (await LocationManager.getInstance().checkForLocationPermissions()) {
+          if (
+            !isMandatoryKeysPresent(route.params, [
+              'success',
+              // 'objectives',
+              'successRoute',
+              'failureRoute',
+              'mergedWI',
+            ])
+          ) {
+            navigateWithError(
+              ErrorCodes.InvalidArgumentError,
+              'Missing or Invalid Route Params'
+            );
+            return;
+          }
+          if (Platform.OS === 'android') {
+            NativeSyncManager.stopSyncManager();
+            AppSyncManager.getInstance().isForceStartEnabled = false;
+            AppSyncManager.getInstance().isSyncActive = true;
+          }
+
+          instance.setSuccessRoute(route.params.successRoute);
+          instance.setFailureRoute(route.params.failureRoute);
+          // instance._jobObjectives = route.params.objectives;
+          /**
+           * Clear all prev state and Map before starting new objective / Merged Objective
+           */
+          instance.stateKeys = [];
+          instance.mappedStates.clear();
+          /* let nextStateList = await instance.bulkQueryNextET(
+            route.params.objectives
+          ); */
+
+          // const statusFilter =
+          //   route.params.mergedWI.statusFilter.indexOf(
+          //     IDispatchExecutor.ExecutionStatus.COMPLETED_FAILURE
+          //   ) === -1
+          //     ? route.params.mergedWI.statusFilter
+          //     : [
+          //         IDispatchExecutor.ExecutionStatus.READY,
+          //         IDispatchExecutor.ExecutionStatus.IN_PROGRESS,
+          //       ];
+          const statusFilter = route.params.mergedWI.statusFilter;
+
+          const prefixedMergedObjectiveId: string = route.params.mergedWI.mwId;
+          let nextStateData: IDispatch.IExecutionTaskQueryResponse = (
+            await instance.queryNextET(
+              [prefixedMergedObjectiveId],
+              statusFilter
+            )
+          )[0];
+
+          let updatedStatusFilter: IDispatchExecutor.ExecutionStatus[] = [];
+
+          if (
+            statusFilter.includes(
+              `${IDispatchExecutor.ExecutionStatus.COMPLETED_FAILURE}`
+            )
+          ) {
+            route.params.mergedWI.statusFilter = [
+              IDispatchExecutor.ExecutionStatus.READY,
+              IDispatchExecutor.ExecutionStatus.IN_PROGRESS,
+            ];
+            updatedStatusFilter = [
+              IDispatchExecutor.ExecutionStatus.READY,
+              IDispatchExecutor.ExecutionStatus.IN_PROGRESS,
+            ];
+          } else {
+            updatedStatusFilter = [...statusFilter];
+          }
+
+          route.params[RouteParams.ROOT_META_DATA] = {
+            meta: route.params.meta || {},
+            customEventsData: route.params.mergedWI.customEventsData,
+            statusFilter: updatedStatusFilter,
+            prefixedMergedObjectiveId,
+          };
+
+          // if (nextStateList != null && nextStateList.length > 0) {
+          if (nextStateData != null && Object.keys(nextStateData).length > 0) {
+            /* const wfMeta = JSON.parse(
+              nextStateList[0].nextState.data?.wfMeta || '{}'
+            ); */
+
+            const wfMeta = nextStateData.meta?.workflow;
+            if (
+              wfMeta?.enableMultiObjectiveFlow !== undefined &&
+              wfMeta?.enableMultiObjectiveFlow === false
+            ) {
+              navigateWithError(
+                ErrorCodes.MULTI_OBJECTIVE_ERROR,
+                MultiObjectiveError
+              );
+            }
+            if (nextStateData.taskId === ExecutionTaskID.START_WORKFLOW) {
+              const mergedObjectiveIds = nextStateData.mergedObjectiveIds;
+              onTaskStart(
+                nextStateData,
+                route.params[RouteParams.ROOT_META_DATA].customEventsData
+              );
+              const _input: any = nextStateData.input;
+              const _appRC = route.params.success
+                ? _input?.applicableReasons?.success
+                : _input?.applicableReasons?.failure;
+              let etResponse = {
+                ...(await getBaseETResponse(
+                  EntityCode.START_WORKFLOW,
+                  route.params.success,
+                  getEventCodeByET(
+                    ExecutionTaskID.START_WORKFLOW,
+                    route.params.success,
+                    _appRC
+                  ),
+                  '',
+                  mergedObjectiveIds,
+                  ExecutionTaskID.START_WORKFLOW
+                )),
+              };
+
+              route.params[RouteParams.NEXT_STATES] = nextStateData;
+              await instance.navigateToNextTask(
+                navigation,
+                route,
+                etResponse,
+                route.params.success,
+                EntityCode.START_WORKFLOW,
+                ExecutionTaskID.START_WORKFLOW,
+                baseETProps,
+                false
+              );
+            } else {
+              let rParams: any = {};
+              rParams[RouteParams.NEXT_STATES] = nextStateData;
+              rParams[RouteParams.ROOT_META_DATA] =
+                route.params[RouteParams.ROOT_META_DATA];
+              navigation.replace(nextStateData.taskId, rParams);
+            }
+          } else {
+            navigateWithError(
+              ErrorCodes.EXECUTION_ENGINE_ERROR,
+              'Unable to start the given objective'
+            );
+          }
+        } else {
+          navigateWithError(
+            ErrorCodes.LOCATION_PERMISSION_DENIED,
+            'Please enable Location permissions'
+          );
+        }
+      } catch (error: any) {
+        baseETProps.showProgress(false);
+        navigateWithError(ErrorCodes.UNEXPECTED_ERROR, error.message);
+        Logger.getInstance().logEvent(TAG, error.message, LOG_TYPE.SDK_ERROR);
+      }
+    })();
+  }, []);
+  return (
+    <View style={styles.container}>
+      <Text>Please wait...</Text>
+    </View>
+  );
+};
+export default withBaseDispatchScreen(StartWorkFlowScreen);
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+});

package/src/ui/screens/ValidateOTPScreen.tsx

@@ -0,0 +1,62 @@
+import React, { useEffect, useState } from 'react';
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import type { BaseETProps } from '../../models/DispatchModels';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import ValidateOTPET from '../../components/executiontasks/validateOTP/ValidateOTPET';
+import { handleDynamicValues, onTaskStart } from '../../utils/ExecTaskUtils';
+
+const ValidateOTPScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+  const message = input?.message;
+  const firstInput = input;
+  const [_input, setInputs] = useState({ ...firstInput });
+
+  useEffect(() => {
+    onTaskStart(
+      route.params[RouteParams.NEXT_STATES],
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+    if (route.params[RouteParams.ROOT_META_DATA]) {
+      const updatedInput = handleDynamicValues(
+        route?.params[RouteParams.NEXT_STATES].input,
+        route.params[RouteParams.ROOT_META_DATA]
+      );
+      setInputs(updatedInput);
+    }
+  }, []);
+
+  return (
+    <ValidateOTPET
+      {..._input}
+      mergedObjectiveId={mergedObjectiveId}
+      taskMeta={taskMeta}
+      message={message}
+      navigation={navigation}
+      onSubmitET={async (validateOtpOutput) => {
+        await DispatchStateContainer.getInstance().navigateToNextTask(
+          navigation,
+          route,
+          validateOtpOutput,
+          validateOtpOutput.success,
+          EntityCode.VALIDATE_OTP_ET,
+          ExecutionTaskID.VALIDATE_OTP_ET,
+          baseETProps,
+          false
+        );
+      }}
+    />
+  );
+};
+export default withBaseDispatchScreen(ValidateOTPScreen);

package/src/ui/screens/WithBaseDispatchScreen.tsx

@@ -0,0 +1,33 @@
+import React, { useEffect, useState } from 'react';
+import { StyleSheet, View } from 'react-native';
+import type { BaseETProps } from '../../models/DispatchModels';
+import ProgressDialog from '../../components/widgets/ProgressDialog';
+
+const withBaseDispatchScreen = (WrappedComponent: any) => {
+  return (props: any) => {
+    const [loading, setLoading] = useState(false);
+    useEffect(() => {
+      setLoading(false);
+      return () => {
+        setLoading(false);
+      };
+    }, []);
+    let baseProps: BaseETProps = {
+      showProgress: setLoading,
+    };
+
+    return (
+      <View style={styles.mainContainer}>
+        <WrappedComponent {...props} baseETProps={baseProps} />
+        <ProgressDialog visible={loading} label={'Please wait...'} />
+      </View>
+    );
+  };
+};
+export default withBaseDispatchScreen;
+
+const styles = StyleSheet.create({
+  mainContainer: {
+    flex: 1,
+  },
+});

package/src/ui/uiConfig/RouteParams.ts

@@ -0,0 +1,28 @@
+import { IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
+
+export const RouteParams = {
+  NEXT_STATES: 'next_states',
+  REASONS: 'reason_list',
+  ET_SUCCESS: 'etkSuccess',
+  ET_SUCCESS_RESPONSE: 'etkSuccessResponse',
+  CURRENT_ET_NAME: 'currentETName',
+  IS_LAST_ET: 'isLastTask',
+  EVENT_CODES: 'event_list',
+  APPLICABLE_CODES: 'applicable_codes',
+  IS_MERGED_OBJ_BASED_OUTPUT: 'isJobBasedOutput',
+  ROOT_META_DATA: 'rootMetaData',
+  CANCEL_EVENT: 'cancel_event',
+  HAS_MULTIPLE_ET: 'has_multiple_ets',
+};
+
+export function getDataFromNextState(
+  nextState: IDispatch.IExecutionTaskQueryResponse
+) {
+  const taskName = nextState.taskName;
+  const input = nextState.input;
+  const taskMeta = JSON.parse(nextState.meta?.task || '{}'); //nextState.meta?.task || {}; //JSON.parse(nextState.meta?.task || '{}');
+  const mergedObjectiveId = nextState.mergedObjectiveIds;
+  const wfMeta = JSON.parse(nextState.meta?.workflow || '{}'); //nextState.meta?.workflow || {}; //JSON.parse(nextState.meta?.workflow || '{}');
+
+  return { input, taskMeta, mergedObjectiveId, wfMeta, taskName };
+}

package/src/utils/ApiUtils.ts

@@ -0,0 +1,157 @@
+import axios, { AxiosRequestConfig } from 'axios';
+import { API_CONFIG } from '../constants/apiConstants';
+import { getHeaders } from '../network/NetworkUtils';
+
+export type HTTPMethod = 'PUT' | 'POST' | 'GET';
+export type HeaderKey = string;
+export type HeaderValue = string;
+export type QueryParamKey = string;
+export type QueryParamValue = string;
+export type PathParamKey = string;
+export type PathParamValue = string;
+
+/**
+ * API headers
+ */
+export type Headers = {
+  key?: HeaderKey;
+  value?: HeaderValue;
+};
+
+/**
+ * Query Params
+ */
+export type QueryParams = {
+  key?: QueryParamKey;
+  value?: QueryParamValue;
+};
+
+/**
+ * Path Params
+ */
+export type PathParams = {
+  key: PathParamKey;
+  value: PathParamValue;
+};
+
+/**
+ * request body object
+ */
+export interface HTTPRequestBody {
+  [k: string]: unknown;
+}
+
+export interface APIData {
+  uri: string;
+  timeout?: number;
+  httpMethod: HTTPMethod;
+  headers?: Headers[];
+  requestBody?: HTTPRequestBody;
+  queryParams?: QueryParams[];
+  pathParams?: PathParams[];
+  responseJsonPath: string;
+  errorJsonPath: string;
+}
+
+export interface KeyValueArray {
+  key?: string;
+  value?: any;
+}
+
+export function getKeyValueFromArray() {
+  return (array?: KeyValueArray[]) => {
+    if (!array || array.length === 0) return {};
+    else {
+      const addItems: { [k: string]: any } = {};
+      array.forEach((item) => {
+        if (item.key && item.value)
+          addItems[item.key?.toLowerCase()] = item.value;
+      });
+      return addItems;
+    }
+  };
+}
+
+export const getAddHeaders = getKeyValueFromArray();
+export const getQueryParams = getKeyValueFromArray();
+
+export async function getApiResponse(apiData: APIData) {
+  let axiosConfig: AxiosRequestConfig = {
+    method: apiData.httpMethod,
+    timeout: apiData.timeout ?? API_CONFIG.timeout, // timeout in millis i.e 15s
+    url: apiData.uri,
+    headers: {
+      ...getAddHeaders(apiData.headers),
+      ...(await getHeaders('application/json')),
+    },
+  };
+
+  /**
+   * Path params example
+   * uri: {baseURI}/core/api/v1/dispatch-service/dispatches/{dispatchId}/jobs/{captureInput}
+   * pathParams: [
+   *    {key:"baseURI",value:"https://delhivery.coreos-dev.fxtrt.io"},
+   *    {key:"dispatchId",value:"dispatch:a62dc46d-9787-5b32-9b71-ff38bd1bdcae"},
+   *    {key:"captureInput",value:"{{$.userInput.captureInput}}"}
+   * ]
+   */
+
+  if (apiData.pathParams) {
+    const params = apiData.pathParams;
+    params.forEach((param) => {
+      apiData.uri = apiData.uri.replace(`{${param.key}}`, param.value);
+    });
+    axiosConfig.url = apiData.uri;
+  }
+
+  /**
+   * Query params example
+   * uri: https://jsonplaceholder.typicode.com/comments
+   * queryParams: [
+   *    {key:"postId",value:"{{$.userInput.captureInput}}"},
+   * ]
+   * finalURI: https://jsonplaceholder.typicode.com/comments?postId=1
+   */
+  if (apiData.queryParams) {
+    axiosConfig.params = { ...getQueryParams(apiData.queryParams) };
+  }
+
+  if (apiData.requestBody) {
+    axiosConfig.data = { ...apiData.requestBody };
+  }
+
+  return axios(axiosConfig);
+}
+
+export function parseBody(body: any, userInput: any) {
+  const requestBody = JSON.parse(JSON.stringify(body));
+  for (const key in requestBody) {
+    if (Object.prototype.hasOwnProperty.call(requestBody, key)) {
+      const value = requestBody[key];
+      if (typeof value === 'object') {
+        requestBody[key] = parseBody(value, userInput);
+      } else if (Array.isArray(value)) {
+        value.forEach((val) => {
+          requestBody[key] = parseBody(val, userInput);
+        });
+      } else {
+        const _userInputExpr = '$.userInput.';
+        if (typeof value === 'string' && value.includes(_userInputExpr)) {
+          const _userEnteredInput: string = value.split('.').pop() || '';
+          requestBody[key] = userInput[_userEnteredInput] || '';
+        }
+      }
+    }
+  }
+  return requestBody;
+}
+
+export function parseKeyValue(array: KeyValueArray[], userInput: any) {
+  return array.map((item) => {
+    const _userInputExpr = '$.userInput.';
+    if (item.value.includes(_userInputExpr)) {
+      const _userEnteredInput: string = item.value.split('.').pop() || '';
+      item.value = userInput[_userEnteredInput] || '';
+    }
+  });
+}