@os1-platform/dispatch-mobile 2.0.8 → 2.1.0

package/src/ui/screens/HttpRequestScreen.tsx

@@ -0,0 +1,47 @@
+import WithBaseDispatchScreen from './WithBaseDispatchScreen';
+import type { BaseETProps } from '../../models/DispatchModels';
+import { HttpRequestET } from '../../components/executiontasks/ExecutionTasksIndex';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import { useEffect } from 'react';
+import { onTaskStart } from '../../utils/ExecTaskUtils';
+
+const HttpRequestScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+  useEffect(() => {
+    onTaskStart(
+      route.params[RouteParams.NEXT_STATES],
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+  }, []);
+  return (
+    <HttpRequestET
+      {...input}
+      mergedObjectiveId={mergedObjectiveId}
+      onSubmitET={async (response) => {
+        await DispatchStateContainer.getInstance().navigateToNextTask(
+          navigation,
+          route,
+          response,
+          response.success,
+          EntityCode.HTTP_REQUEST_ET,
+          ExecutionTaskID.HTTP_REQUEST_ET,
+          baseETProps,
+          false
+        );
+      }}
+    />
+  );
+};
+export default WithBaseDispatchScreen(HttpRequestScreen);

package/src/ui/screens/ImageCaptureScreen.tsx

@@ -0,0 +1,77 @@
+import React, { useEffect, useState } from 'react';
+import ImageCapture from '../../components/executiontasks/imageCapture/ImageCapture';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import type { BaseETProps } from '../../models/DispatchModels';
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import { onTaskStart } from '../../utils/ExecTaskUtils';
+
+import { DispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
+
+const ImageCaptureScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+  const firstInput = input;
+  const [inputs, setInputs] = useState(firstInput);
+  const [captureCount, setCaptureCount] = useState(0);
+
+  const getMergedCaptureCount = async () => {
+    const count = await DispatchExecutor.getScannedShipmentsCount(
+      mergedObjectiveId
+    );
+    setCaptureCount(count.totalCount);
+  };
+
+  useEffect(() => {
+    onTaskStart(
+      route.params[RouteParams.NEXT_STATES],
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+    getMergedCaptureCount();
+  }, []);
+
+  useEffect(() => {
+    let _captureCountLimit = captureCount * input.captureCountLimit;
+
+    setInputs((prev: any) => ({
+      ...prev,
+      captureCountLimit: _captureCountLimit,
+    }));
+  }, [captureCount]);
+
+  return (
+    <ImageCapture
+      {...inputs}
+      captureCount={captureCount}
+      navigation={navigation}
+      taskMeta={taskMeta}
+      mergedObjectiveId={mergedObjectiveId}
+      // jobIds={getJobIDs(route.params[RouteParams.NEXT_STATES])}
+      // objRefs={getObjectiveRefs(route.params[RouteParams.NEXT_STATES])}
+      onSubmitET={async (imageDataList) => {
+        await DispatchStateContainer.getInstance().navigateToNextTask(
+          navigation,
+          route,
+          imageDataList,
+          imageDataList.success,
+          EntityCode.IMAGE_CAPTURE,
+          ExecutionTaskID.IMAGE_CAPTURE,
+          baseETProps,
+          false
+        );
+      }}
+    />
+  );
+};
+
+export default withBaseDispatchScreen(ImageCaptureScreen);

package/src/ui/screens/PaymentScreen.tsx

@@ -0,0 +1,191 @@
+import React, { useCallback, useState } from 'react';
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import type { BaseETProps } from '../../models/DispatchModels';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import {
+  CompletePaymentET,
+  InitPaymentET,
+  ProcessPaymentET,
+} from '../../components/executiontasks/ExecutionTasksIndex';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import { View } from 'react-native';
+import {
+  getBaseETResponse,
+  getEntityCodeByET,
+  onTaskStart,
+} from '../../utils/ExecTaskUtils';
+import CancelOrderDialog from '../../components/widgets/CancelOrderDialog';
+import { getEventCodeByET } from '../../manager/dispatchCodes/EventCodeContainer';
+import { useEffect } from 'react';
+import { IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
+import { GO_BACK_EVENT_CODE } from '../../constants/constants';
+const PaymentScreen = ({
+  navigation,
+  route,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+
+  useEffect(() => {
+    onTaskStart(
+      route.params[RouteParams.NEXT_STATES],
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+  }, []);
+  let currentState = route.params[
+    RouteParams.NEXT_STATES
+  ] as IDispatch.IExecutionTaskQueryResponse;
+  const [showAlert, setShowAlert] = useState(false);
+  const [sResponse, setResponse] = useState<any>();
+
+  const taskId = currentState.taskId as ExecutionTaskID;
+
+  const submitOutput = useCallback(
+    async (etOutput: any) => {
+      await DispatchStateContainer.getInstance().navigateToNextTask(
+        navigation,
+        route,
+        etOutput,
+        etOutput.success,
+        getEntityCodeByET(currentState.taskId),
+        taskId,
+        baseETProps,
+        false
+      );
+    },
+    [baseETProps, currentState.taskId, navigation, route]
+  );
+
+  if (currentState.taskId === ExecutionTaskID.INIT_PAYMENT) {
+    return (
+      <View style={{ flex: 1 }}>
+        <InitPaymentET
+          {...input}
+          navigation={navigation}
+          taskMeta={taskMeta}
+          mergedObjectiveId={mergedObjectiveId}
+          onSubmitET={async (etOutput) => {
+            if (etOutput.success || etOutput.eventCode == GO_BACK_EVENT_CODE) {
+              await submitOutput(etOutput);
+            } else {
+              setResponse((_prevState: any) => {
+                setShowAlert(true);
+                return etOutput;
+              });
+            }
+          }}
+        />
+        <CancelOrderDialog
+          visible={showAlert}
+          onSubmit={async (value) => {
+            if (value) {
+              setShowAlert(false);
+              await submitOutput(sResponse);
+            } else {
+              setShowAlert(false);
+            }
+          }}
+        />
+      </View>
+    );
+  } else if (currentState.taskId === ExecutionTaskID.PROCESS_PAYMENT) {
+    let _input = input;
+    if (_input?.paymentMode === 'CASH') {
+      useEffect(() => {
+        let isMounted = true;
+        (async () => {
+          if (isMounted) {
+            const baseData = await getBaseETResponse(
+              EntityCode.PROCESS_PAYMENT,
+              true,
+              getEventCodeByET(
+                ExecutionTaskID.PROCESS_PAYMENT,
+                true,
+                _input.applicableReasons?.success
+              ),
+              '',
+              mergedObjectiveId,
+              ExecutionTaskID.PROCESS_PAYMENT
+            );
+            _input = {
+              paymentMode: _input.paymentMode,
+              collectedAmount: _input.amount,
+              transactionId: _input.transactionId,
+              tenantTransactionId: _input.transactionId,
+              ...baseData,
+            };
+            await submitOutput(_input);
+          }
+        })();
+        return () => {
+          isMounted = false;
+        };
+      }, []);
+      return <></>;
+    } else
+      return (
+        <View style={{ flex: 1 }}>
+          <ProcessPaymentET
+            {...input}
+            navigation={navigation}
+            mergedObjectiveId={mergedObjectiveId}
+            taskMeta={taskMeta}
+            onSubmitET={async (etOutput) => {
+              if (	
+                etOutput.success ||	
+                etOutput.eventCode == GO_BACK_EVENT_CODE	
+              ) {
+                await submitOutput(etOutput);
+              } else {
+                setResponse((_prevState: any) => {
+                  setShowAlert(true);
+                  return etOutput;
+                });
+              }
+            }}
+          />
+          <CancelOrderDialog
+            visible={showAlert}
+            onSubmit={async (value) => {
+              if (value) {
+                setShowAlert(false);
+                await submitOutput(sResponse);
+              } else {
+                setShowAlert(false);
+              }
+            }}
+          />
+        </View>
+      );
+  } else {
+    return (
+      <CompletePaymentET
+        {...input}
+        navigation={navigation}
+        taskMeta={taskMeta}
+        mergedObjectiveId={mergedObjectiveId}
+        onSubmitET={async (etOut) => {
+          await DispatchStateContainer.getInstance().navigateToNextTask(
+            navigation,
+            route,
+            etOut,
+            etOut.success,
+            EntityCode.COMPLETE_PAYMENT,
+            ExecutionTaskID.COMPLETE_PAYMENT,
+            baseETProps,
+            false
+          );
+        }}
+      />
+    );
+  }
+};
+
+export default withBaseDispatchScreen(PaymentScreen);

package/src/ui/screens/PickupScreen.tsx

@@ -0,0 +1,82 @@
+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 { onTaskStart } from '../../utils/ExecTaskUtils';
+
+import { DispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
+import SLPickupET from '../../components/executiontasks/pickup/SLPickupET';
+
+const PickupScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+
+  const [pickupCount, setPickupCount] = useState(0);
+  const [items, setItems] = useState([]);
+
+  const getMergedPickCount = async () => {
+    const count = await DispatchExecutor.getScannedShipmentsCount(
+      mergedObjectiveId
+    );
+    setPickupCount(count.totalCount);
+  };
+  useEffect(() => {
+    onTaskStart(
+      nextState,
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+    getMergedPickCount();
+  }, []);
+
+  useEffect(() => {
+    if (pickupCount === 1) {
+      setItems(input.items);
+    }
+  }, [pickupCount]);
+
+  const message = input?.message;
+
+  // OLD CODE
+  // const length = route.params[RouteParams.NEXT_STATES].length;
+  // const items =
+  //   length === 1
+  //     ? route.params[RouteParams.NEXT_STATES][0].nextState.data.input.items
+  //     : [];
+
+  return (
+    <SLPickupET
+      {...input}
+      mergedObjectiveId={mergedObjectiveId}
+      message={message}
+      items={items}
+      pickupCount={pickupCount}
+      navigation={navigation}
+      taskMeta={taskMeta}
+      onSubmitET={async (pickupOutput) => {
+        await DispatchStateContainer.getInstance().navigateToNextTask(
+          navigation,
+          route,
+          pickupOutput,
+          pickupOutput.success,
+          EntityCode.PICKUP,
+          ExecutionTaskID.PICKUP,
+          baseETProps,
+          false
+        );
+      }}
+    />
+  );
+};
+export default withBaseDispatchScreen(PickupScreen);

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);