@os1-platform/dispatch-mobile 2.1.2 → 2.1.4

package/src/ui/screens/FormsScreen.tsx

@@ -0,0 +1,186 @@
+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';
+import Helper from '../../utils/helper';
+
+const FormsScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const helperInstance = Helper.getInstance();
+  const [snackBar, setSnackBar] = useState({
+    show: false,
+    type: SnackBarType.SUCCESS,
+    message: '',
+  });
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta, taskName } =
+    getDataFromNextState(nextState);
+  const [_input, setInputs] = useState(input);
+  const [isSelfLoopTrue, setSelfLoop] = useState(false);
+
+  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;
+        });
+      }
+    })();
+  }, []);
+
+  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);
+    }
+  }
+
+  return (
+    <>
+      <FormGenerator
+        {..._input}
+        navigation={navigation}
+        isSelfLoop={isSelfLoopTrue}
+        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);

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,95 @@
+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';
+import Helper from '../../utils/helper';
+
+
+const ImageCaptureScreen = ({
+  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 firstInput = input;
+  const [inputs, setInputs] = useState(firstInput);
+  const [captureCount, setCaptureCount] = useState(0);
+  const [isSelfLoopTrue, setSelfLoop] = useState(false);
+
+  useEffect(() => {
+    (async () => {
+      onTaskStart(
+        route.params[RouteParams.NEXT_STATES],
+        route.params[RouteParams.ROOT_META_DATA].customEventsData
+      );
+      getMergedCaptureCount();
+      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 getMergedCaptureCount = async () => {
+    const count = await DispatchExecutor.getScannedShipmentsCount(
+      mergedObjectiveId
+    );
+    setCaptureCount(count.totalCount);
+  };
+
+  useEffect(() => {
+    let _captureCountLimit = captureCount * input.captureCountLimit;
+
+    setInputs((prev: any) => ({
+      ...prev,
+      captureCountLimit: _captureCountLimit,
+    }));
+  }, [captureCount]);
+
+  return (
+    <ImageCapture
+      {...inputs}
+      captureCount={captureCount}
+      isSelfLoop={isSelfLoopTrue}
+      navigation={navigation}
+      taskMeta={taskMeta}
+      mergedObjectiveId={mergedObjectiveId}
+      // jobIds={getJobIDs(route.params[RouteParams.NEXT_STATES])}
+      // objRefs={getObjectiveRefs(route.params[RouteParams.NEXT_STATES])}
+      onSubmitET={async (imageDataList: { success: boolean; }) => {
+        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,213 @@
+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';
+import Helper from '../../utils/helper';
+
+const PaymentScreen = ({
+  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);
+
+  let currentState = route.params[
+    RouteParams.NEXT_STATES
+  ] as IDispatch.IExecutionTaskQueryResponse;
+  const [showAlert, setShowAlert] = useState(false);
+  const [sResponse, setResponse] = useState<any>();
+  const [isSelfLoopTrue, setSelfLoop] = useState(false);
+
+  useEffect(() => {
+    (async () => {
+      onTaskStart(
+        route.params[RouteParams.NEXT_STATES],
+        route.params[RouteParams.ROOT_META_DATA].customEventsData
+      );
+      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 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}
+          isSelfLoop={isSelfLoopTrue}
+          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}
+            isSelfLoop={isSelfLoopTrue}
+            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}
+        isSelfLoop={isSelfLoopTrue}
+        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,112 @@
+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';
+import Helper from '../../utils/helper';
+
+const PickupScreen = ({
+  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 [pickupCount, setPickupCount] = 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
+      );
+      getMergedPickCount();
+      await getSelfLoopBool();
+    })();
+  }, []);
+
+  const getMergedPickCount = async () => {
+    const count = await DispatchExecutor.getScannedShipmentsCount(
+      mergedObjectiveId
+    );
+    setPickupCount(count.totalCount);
+    setShipCount(count.shipCount);
+  };
+
+  const getSelfLoopBool = async () => {
+    try {
+      const splitArr = mergedObjectiveId[0]?.split('#');
+      console.log("aks::workflowId", JSON.stringify(splitArr))
+      //
+      const workflowId = splitArr[1];
+      console.log("aks::workflowId", workflowId)
+      //
+      const isSelfLoopTrue: boolean = await helperInstance.isSelfLoopExistOnET(workflowId, taskName)
+      console.log("aks::isSelfLoopTrue", isSelfLoopTrue)
+      //
+      setSelfLoop(isSelfLoopTrue);
+      console.log('isSelfLoopTrue code execution successful!');
+    } catch (error) {
+      console.log('isSelfLoopTrue code execution error', error);
+    }
+  }
+
+  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}
+      shipCount={shipCount}
+      navigation={navigation}
+      taskMeta={taskMeta}
+      isSelfLoop={isSelfLoopTrue}
+      onSubmitET={async (pickupOutput) => {
+        await DispatchStateContainer.getInstance().navigateToNextTask(
+          navigation,
+          route,
+          pickupOutput,
+          pickupOutput.success,
+          EntityCode.PICKUP,
+          ExecutionTaskID.PICKUP,
+          baseETProps,
+          false
+        );
+      }}
+    />
+  );
+};
+export default withBaseDispatchScreen(PickupScreen);