@os1-platform/dispatch-mobile 2.0.7 → 2.1.0

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,114 @@
+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';
+
+const DeliverScreen = ({
+  navigation,
+  route,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+
+  const [returnPackageCount, setReturnPackageCount] = useState(0);
+  const [items, setItems] = useState([]);
+
+  const getMergedReturnPackageCount = async () => {
+    const count = await DispatchExecutor.getScannedShipmentsCount(
+      mergedObjectiveId
+    );
+    setReturnPackageCount(count.totalCount);
+  };
+  useEffect(() => {
+    onTaskStart(
+      nextState,
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+    getMergedReturnPackageCount();
+  }, []);
+
+  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}
+        taskMeta={taskMeta}
+        mergedObjectiveId={mergedObjectiveId}
+        returnPackageCount={returnPackageCount}
+        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,84 @@
+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';	
+const DoodleScreen = ({
+  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
+    );
+  }, []);
+  const [showAlert, setShowAlert] = useState(false);
+  const [sResponse, setResponse] = useState<any>();
+  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}
+        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,113 @@
+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';
+// 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 nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+
+  const [expectedAmount, setExpectedAmount] = useState<ETAmount>({
+    value: 0,
+    minorUnit: input.expectedAmount.minorUnit,
+    currencyCode: input.expectedAmount.currencyCode,
+  });
+
+  const getTotalExpected = async () => {
+    const totalAmount: number = await DispatchExecutor.getTotalAmountMWI(
+      mergedObjectiveId
+    );
+    setExpectedAmount({ ...expectedAmount, value: totalAmount });
+  };
+
+  useEffect(() => {
+    onTaskStart(
+      nextState,
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+    getTotalExpected();
+  }, []);
+
+  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}
+        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,
+};

package/src/ui/screens/FormsScreen.tsx

@@ -0,0 +1,164 @@
+import React, { useEffect, useState } from 'react';
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import { FormGenerator } from '../../components/executiontasks/ExecutionTasksIndex';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import type { BaseETProps } from '../../models/DispatchModels';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import { handleDynamicValues, onTaskStart } from '../../utils/ExecTaskUtils';
+import { View } from 'react-native';
+import SnackBarCustom, {
+  SnackBarType,
+} from '../../components/widgets/SnackBarCustom';
+import callbackHandler from '../../manager/sdk/callbacksHandler';
+import { DispatchExecutor as dispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
+import { AjvError } from '@rjsf/core';
+
+const FormsScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const [snackBar, setSnackBar] = useState({
+    show: false,
+    type: SnackBarType.SUCCESS,
+    message: '',
+  });
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+  const [_input, setInputs] = useState(input);
+  useEffect(() => {
+    (async () => {
+      onTaskStart(
+        route.params[RouteParams.NEXT_STATES],
+        route.params[RouteParams.ROOT_META_DATA].customEventsData
+      );
+
+      if (route.params[RouteParams.ROOT_META_DATA]) {
+        //Call objectiveDetails fn and fetch sds ids
+        const { contact } = await dispatchExecutor.getObjectiveTaskDetails(
+          mergedObjectiveId[0],
+          route.params[RouteParams.ROOT_META_DATA].statusFilter
+        );
+
+        // run callback to get corresponding phone numbers
+        const phoneNumbers = await callbackHandler.getPhoneNumbers(contact);
+
+        if (phoneNumbers && phoneNumbers.value?.length) {
+          route.params[RouteParams.ROOT_META_DATA].meta[phoneNumbers.key] =
+            phoneNumbers.value;
+        }
+
+        let jsonSchemaProperties = JSON.parse(
+          JSON.stringify(_input.jsonSchema.properties)
+        );
+
+        jsonSchemaProperties = handleDynamicValues(
+          jsonSchemaProperties,
+          route.params[RouteParams.ROOT_META_DATA]
+        );
+
+        setInputs((prev: any) => {
+          const dynamicInput = {
+            ...prev,
+            jsonSchema: {
+              ...prev.jsonSchema,
+              properties: jsonSchemaProperties,
+            },
+          };
+          return dynamicInput;
+        });
+      }
+    })();
+  }, []);
+
+  return (
+    <>
+      <FormGenerator
+        {..._input}
+        navigation={navigation}
+        mergedObjectiveId={mergedObjectiveId}
+        taskMeta={taskMeta}
+        onError={(error: AjvError[] | AjvError) => {
+          const errorMessage = transformErrorMessage(error);
+
+          setSnackBar({
+            show: true,
+            type: SnackBarType.FAILURE,
+            message: errorMessage,
+          });
+        }}
+        onSubmitET={async (result) => {
+          await DispatchStateContainer.getInstance().navigateToNextTask(
+            navigation,
+            route,
+            result,
+            result.success,
+            EntityCode.FORMS,
+            ExecutionTaskID.FORMS,
+            baseETProps,
+            false
+          );
+        }}
+      />
+      <View style={{ justifyContent: 'flex-end' }}>
+        <SnackBarCustom
+          type={snackBar.type}
+          message={`${snackBar.message}`}
+          visible={snackBar.show}
+          onDismiss={() => {
+            setSnackBar({
+              show: false,
+              message: '',
+              type: SnackBarType.SUCCESS,
+            });
+          }}
+          customBottom={20}
+        />
+      </View>
+    </>
+  );
+};
+export default withBaseDispatchScreen(FormsScreen);
+
+const transformErrorMessage = (error: AjvError[] | AjvError): string => {
+  let errorMessage = '';
+  if (Array.isArray(error)) {
+    if (error.length === 1) {
+      const e = error[0];
+      if (e.name === 'required') {
+        errorMessage = `${convertToPascalCaseWithSpace(
+          e.property
+        )} is required`;
+      } else errorMessage = `${e.property} ${e.message}`;
+    } else {
+      errorMessage = 'Form Validation Failed';
+    }
+  } else {
+    errorMessage = `${error.property} ${error.message}`;
+  }
+
+  return errorMessage;
+};
+
+function convertToPascalCaseWithSpace(inputString: string): string {
+  // Capitalize the first letter of each word while preserving spaces
+  return inputString
+    .split(/[^a-zA-Z0-9]+/)
+    .filter((word) => word.length > 0)
+    .map((word, index) => capitalizeWord(word, index === 0))
+    .join(' ');
+}
+
+function capitalizeWord(word: string, isFirstWord: boolean): string {
+  if (isFirstWord) {
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  } else {
+    return word;
+  }
+}

package/src/ui/screens/GeofenceScreen.tsx

@@ -0,0 +1,54 @@
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import React, { useEffect } from 'react';
+import { VerifyLocationET } from '../../components/executiontasks/ExecutionTasksIndex';
+import { showToast } from '../../components/widgets/Toaster';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import type { BaseETProps } from '../../models/DispatchModels';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import { onTaskStart } from '../../utils/ExecTaskUtils';
+
+const GeofenceScreen = ({
+  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 (
+    <VerifyLocationET
+      {...input}
+      mergedObjectiveId={mergedObjectiveId}
+      onSubmitET={async (resp) => {
+        try {
+          await DispatchStateContainer.getInstance().navigateToNextTask(
+            navigation,
+            route,
+            resp,
+            resp.success,
+            EntityCode.VERIFY_LOCATION,
+            ExecutionTaskID.VERIFY_LOCATION,
+            baseETProps,
+            false
+          );
+        } catch (error: any) {
+          baseETProps.showProgress(false);
+          showToast('Error ' + error.message);
+        }
+      }}
+    />
+  );
+};
+
+export default withBaseDispatchScreen(GeofenceScreen);