@os1-platform/dispatch-mobile 2.1.2 → 2.1.3

package/src/ui/screens/CompleteObjectiveScreen.tsx

@@ -0,0 +1,72 @@
+import { View } from 'react-native';
+import React, { useEffect } from 'react';
+import type { BaseETProps } from '../../models/DispatchModels';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { getObjectiveCompleteResp } from '../../utils/ExecTaskUtils';
+import { getEventCodeByET } from '../../manager/dispatchCodes/EventCodeContainer';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import Logger, { LOG_TYPE } from '../../utils/Logger';
+import { showToast } from '../../components/widgets/Toaster';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+
+const CompleteObjectiveScreen = ({
+  navigation,
+  route,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+  useEffect(() => {
+    (async () => {
+      try {
+        baseETProps.showProgress(true);
+        let etResponse;
+        let nextState = route.params[RouteParams.NEXT_STATES];
+        const entityCode =
+          nextState.taskId === ExecutionTaskID.COMPLETED_SUCCESS
+            ? EntityCode.COMPLETED_SUCCESS
+            : EntityCode.COMPLETED_FAILURE;
+        etResponse = await getObjectiveCompleteResp(
+          entityCode,
+          true,
+          getEventCodeByET(nextState.taskId, true),
+          '',
+          mergedObjectiveId,
+          nextState.taskId
+        );
+        await DispatchStateContainer.getInstance().navigateToNextTask(
+          navigation,
+          route,
+          etResponse,
+          etResponse.success,
+          entityCode,
+          nextState.taskId === ExecutionTaskID.COMPLETED_SUCCESS
+            ? ExecutionTaskID.COMPLETED_SUCCESS
+            : ExecutionTaskID.COMPLETED_FAILURE,
+          baseETProps,
+          true
+        );
+      } catch (error: any) {
+        baseETProps.showProgress(false);
+        Logger.getInstance().logEvent(
+          'COMPLETE_OBJECTIVE',
+          error.message,
+          LOG_TYPE.SDK_ERROR
+        );
+        showToast(error.message);
+      }
+    })();
+
+    return () => {
+      baseETProps.showProgress(false);
+    };
+  }, []);
+  return <View />;
+};
+export default withBaseDispatchScreen(CompleteObjectiveScreen);

package/src/ui/screens/DeliverScreen.tsx

@@ -0,0 +1,136 @@
+import React, { useCallback, 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 SLDeliverET from '../../components/executiontasks/deliver/SLDeliverET';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import { View } from 'react-native';
+import CancelOrderDialog from '../../components/widgets/CancelOrderDialog';
+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,
+  SHARED_PREFERENCE_SCAN_OUTPUT,
+} from '../../manager/syncmanager/constants';
+import { GO_BACK_EVENT_CODE } from '../../constants/constants';
+import Helper from '../../utils/helper';
+
+const DeliverScreen = ({
+  navigation,
+  route,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const helperInstance = Helper.getInstance();
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta, taskName } =
+    getDataFromNextState(nextState);
+
+  const [returnPackageCount, setReturnPackageCount] = useState(0);
+  const [shipCount, setShipCount] = useState(0);
+  const [items, setItems] = useState([]);
+  const [isSelfLoopTrue, setSelfLoop] = useState(false);
+
+  useEffect(() => {
+    (async () => {
+      onTaskStart(
+        nextState,
+        route.params[RouteParams.ROOT_META_DATA].customEventsData
+      );
+      getMergedReturnPackageCount();
+      await getSelfLoopBool();
+    })();
+  }, [])
+
+  const getSelfLoopBool = async () => {
+    try {
+      const splitArr = mergedObjectiveId[0]?.split('#');
+      const isSelfLoopTrue: boolean = await helperInstance.isSelfLoopExistOnET(splitArr[1], taskName)
+      setSelfLoop(isSelfLoopTrue);
+      console.log('isSelfLoopTrue code execution successful!');
+    } catch (error) {
+      console.log('isSelfLoopTrue code execution error', error);
+    }
+  }
+
+  const getMergedReturnPackageCount = async () => {
+    const count = await DispatchExecutor.getScannedShipmentsCount(
+      mergedObjectiveId
+    );
+    setReturnPackageCount(count.totalCount);
+    setShipCount(count.shipCount);
+  };
+
+  useEffect(() => {
+    if (returnPackageCount === 1) {
+      setItems(input.items);
+    }
+  }, [returnPackageCount]);
+
+  const [showDeliverModal, setShowDeliverModal] = useState(true);
+  const [showAlert, setShowAlert] = useState(false);
+  const [sResponse, setResponse] = useState<any>();
+  const submitOutput = useCallback(
+    async (deliverOutput: any) => {
+      await DispatchStateContainer.getInstance().navigateToNextTask(
+        navigation,
+        route,
+        deliverOutput,
+        deliverOutput.success,
+        EntityCode.DELIVER,
+        ExecutionTaskID.DELIVER,
+        baseETProps,
+        false
+      );
+    },
+    [baseETProps, navigation, route]
+  );
+
+  return (
+    <View style={{ flex: 1 }}>
+      <SLDeliverET
+        {...input}
+        items={items}
+        navigation={navigation}
+        isSelfLoop={isSelfLoopTrue}
+        taskMeta={taskMeta}
+        mergedObjectiveId={mergedObjectiveId}
+        returnPackageCount={returnPackageCount}
+        shipCount={shipCount}
+        showDeliverModal={showDeliverModal}
+        setShowDeliverModal={setShowDeliverModal}
+        onSubmitET={async (deliverOutput) => {
+          if (
+            deliverOutput.success ||
+            deliverOutput.eventCode == GO_BACK_EVENT_CODE
+          ) {
+            await submitOutput(deliverOutput);
+          } else {
+            setResponse((_prevState: any) => {
+              setShowAlert(true);
+              return deliverOutput;
+            });
+          }
+        }}
+      />
+      <CancelOrderDialog
+        visible={showAlert}
+        onSubmit={async (value) => {
+          if (value) {
+            setShowAlert(false);
+            await submitOutput(sResponse);
+          } else {
+            setShowAlert(false);
+            setShowDeliverModal(true);
+          }
+        }}
+      />
+    </View>
+  );
+};
+export default withBaseDispatchScreen(DeliverScreen);

package/src/ui/screens/DisplayScreen.tsx

@@ -0,0 +1,52 @@
+import React, { useEffect } from 'react';
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import { DisplayModalET } from '../../components/executiontasks/ExecutionTasksIndex';
+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';
+
+const DisplayScreen = ({
+  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(
+      nextState,
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+  }, []);
+  return (
+    <DisplayModalET
+      {...input}
+      mergedObjectiveId={mergedObjectiveId}
+      taskMeta={taskMeta}
+      positiveBtn={'Submit'}
+      showDialog={true}
+      negativeBtn={'Cancel'}
+      onSubmit={async (displayOutput) => {
+        await DispatchStateContainer.getInstance().navigateToNextTask(
+          navigation,
+          route,
+          displayOutput,
+          displayOutput.success,
+          EntityCode.DISPLAY,
+          ExecutionTaskID.DISPLAY,
+          baseETProps,
+          false
+        );
+      }}
+    />
+  );
+};
+
+export default withBaseDispatchScreen(DisplayScreen);

package/src/ui/screens/DoodleScreen.tsx

@@ -0,0 +1,107 @@
+import SignatureET from '../../components/executiontasks/doodle/SignatureET';
+import React, { useCallback, 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 { View } from 'react-native';
+import CancelOrderDialog from '../../components/widgets/CancelOrderDialog';
+import { onTaskStart } from '../../utils/ExecTaskUtils';
+import { GO_BACK_EVENT_CODE } from '../../constants/constants';
+import Helper from '../../utils/helper';
+
+const DoodleScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const helperInstance = Helper.getInstance();
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta, taskName } =
+    getDataFromNextState(nextState);
+  useEffect(() => {
+    onTaskStart(
+      nextState,
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+  }, []);
+  const [showAlert, setShowAlert] = useState(false);
+  const [sResponse, setResponse] = useState<any>();
+  const [isSelfLoopTrue, setSelfLoop] = useState(false);
+
+  useEffect(() => {
+    (async () => {
+      await getSelfLoopBool();
+    })();
+  }, [])
+
+  const getSelfLoopBool = async () => {
+    try {
+      const splitArr = mergedObjectiveId[0]?.split('#');
+      const isSelfLoopTrue: boolean = await helperInstance.isSelfLoopExistOnET(splitArr[1], taskName)
+      setSelfLoop(isSelfLoopTrue);
+      console.log('isSelfLoopTrue code execution successful!');
+    } catch (error) {
+      console.log('isSelfLoopTrue code execution error', error);
+    }
+  }
+
+  const submitOutput = useCallback(
+    async (base64Data: any) => {
+      await DispatchStateContainer.getInstance().navigateToNextTask(
+        navigation,
+        route,
+        base64Data,
+        base64Data.success,
+        EntityCode.DOODLE,
+        ExecutionTaskID.DOODLE,
+        baseETProps,
+        false
+      );
+    },
+    [baseETProps, navigation, route]
+  );
+
+  return (
+    <View style={{ flex: 1 }}>
+      <SignatureET
+        {...input}
+        // jobIDs={getJobIDs(route.params[RouteParams.NEXT_STATES])}
+        // objRefs={getObjectiveRefs(route.params[RouteParams.NEXT_STATES])}
+        navigation={navigation}
+        isSelfLoop={isSelfLoopTrue}
+        taskMeta={taskMeta}
+        mergedObjectiveId={mergedObjectiveId}
+        onSubmitET={async (base64Data) => {
+          if (base64Data.success || base64Data.eventCode == GO_BACK_EVENT_CODE) {
+            await submitOutput(base64Data);
+          } else {
+            setResponse((_prevState: any) => {
+              setShowAlert(true);
+              return base64Data;
+            });
+          }
+        }}
+      />
+      <CancelOrderDialog
+        label={'Cancel Signature'}
+        visible={showAlert}
+        onSubmit={async (value) => {
+          if (value) {
+            setShowAlert(false);
+            await submitOutput(sResponse);
+          } else {
+            setShowAlert(false);
+          }
+        }}
+      />
+    </View>
+  );
+};
+
+export default withBaseDispatchScreen(DoodleScreen);

package/src/ui/screens/DropCashScreen.tsx

@@ -0,0 +1,132 @@
+import React, { useCallback, useEffect, useState } from 'react';
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import type { BaseETProps } from '../../models/DispatchModels';
+import { SLDropCash } from '../../components/executiontasks/ExecutionTasksIndex';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import type { ETAmount } from '../../components/executiontasks/payments/init/InitPaymentSchema';
+import { View } from 'react-native';
+import CancelOrderDialog from '../../components/widgets/CancelOrderDialog';
+import { onTaskStart } from '../../utils/ExecTaskUtils';
+
+import { DispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
+import { GO_BACK_EVENT_CODE } from '../../constants/constants';
+import Helper from '../../utils/helper';
+
+// OLD CODE
+// function getTotalExpected(nextStates: any[]): ETAmount {
+//   let totalAmount = 0;
+//   for (const s of nextStates) {
+//     totalAmount += s.nextState.data.input.expectedAmount.value;
+//   }
+//   return {
+//     value: totalAmount,
+//     minorUnit: nextStates[0].nextState.data.input.expectedAmount.minorUnit,
+//     currencyCode:
+//       nextStates[0].nextState.data.input.expectedAmount.currencyCode,
+//   };
+// }
+
+const DropCashScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const helperInstance = Helper.getInstance();
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta, taskName } =
+    getDataFromNextState(nextState);
+
+  const [expectedAmount, setExpectedAmount] = useState<ETAmount>({
+    value: 0,
+    minorUnit: input.expectedAmount.minorUnit,
+    currencyCode: input.expectedAmount.currencyCode,
+  });
+  const [isSelfLoopTrue, setSelfLoop] = useState(false);
+
+  useEffect(() => {
+    (async () => {
+      onTaskStart(
+        nextState,
+        route.params[RouteParams.ROOT_META_DATA].customEventsData
+      );
+      getTotalExpected();
+      await getSelfLoopBool();
+    })();
+  }, [])
+
+  const getTotalExpected = async () => {
+    const totalAmount: number = await DispatchExecutor.getTotalAmountMWI(
+      mergedObjectiveId
+    );
+    setExpectedAmount({ ...expectedAmount, value: totalAmount });
+  };
+
+  const getSelfLoopBool = async () => {
+    try {
+      const splitArr = mergedObjectiveId[0]?.split('#');
+      const isSelfLoopTrue: boolean = await helperInstance.isSelfLoopExistOnET(splitArr[1], taskName)
+      setSelfLoop(isSelfLoopTrue);
+      console.log('isSelfLoopTrue code execution successful!');
+    } catch (error) {
+      console.log('isSelfLoopTrue code execution error', error);
+    }
+  }
+
+  const [showAlert, setShowAlert] = useState(false);
+  const [sResponse, setResponse] = useState<any>();
+  const submitOutput = useCallback(
+    async (etOutput: any) => {
+      await DispatchStateContainer.getInstance().navigateToNextTask(
+        navigation,
+        route,
+        etOutput,
+        etOutput.success,
+        EntityCode.DELIVER_CASH,
+        ExecutionTaskID.DELIVER_CASH,
+        baseETProps,
+        false
+      );
+    },
+    [baseETProps, navigation, route]
+  );
+  return (
+    <View style={{ flex: 1 }}>
+      <SLDropCash
+        {...input}
+        expectedAmount={expectedAmount}
+        isSelfLoop={isSelfLoopTrue}
+        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>
+  );
+};
+export default withBaseDispatchScreen(DropCashScreen);

package/src/ui/screens/ETScreensIndex.ts

@@ -0,0 +1,35 @@
+import CancellationScreen from './CancellationScreen';
+import DeliverScreen from './DeliverScreen';
+import DoodleScreen from './DoodleScreen';
+import ImageCaptureScreen from './ImageCaptureScreen';
+import FormsScreen from './FormsScreen';
+import PickupScreen from './PickupScreen';
+import StartWorkFlowScreen from './StartWorkFlowScreen';
+import CaptureInputScreen from './CaptureInputScreen';
+import GeofenceScreen from './GeofenceScreen';
+import PaymentScreen from './PaymentScreen';
+import DisplayScreen from './DisplayScreen';
+import CompleteObjectiveScreen from './CompleteObjectiveScreen';
+import DropCashScreen from './DropCashScreen';
+import ScanScreen from './ScanScreen';
+import HttpRequestScreen from './HttpRequestScreen';
+import ValidateOTPScreen from './ValidateOTPScreen';
+
+export {
+  CancellationScreen,
+  DeliverScreen,
+  DoodleScreen,
+  ImageCaptureScreen,
+  FormsScreen,
+  PickupScreen,
+  StartWorkFlowScreen,
+  CaptureInputScreen,
+  GeofenceScreen,
+  PaymentScreen,
+  DisplayScreen,
+  CompleteObjectiveScreen,
+  DropCashScreen,
+  ScanScreen,
+  HttpRequestScreen,
+  ValidateOTPScreen,
+};