@os1-platform/dispatch-mobile 2.0.8 → 2.1.0

package/src/components/executiontasks/payments/completePayment/CompletePaymentSchema.ts

@@ -0,0 +1,23 @@
+/**
+ * Amount
+ */
+import type {
+  BaseETRequest,
+  BaseETResponse,
+} from '../../../../models/execTasks/ETBaseModels';
+import type { ETAmount } from '../init/InitPaymentSchema';
+
+export type CompletePaymentInput = BaseETRequest & {
+  paymentMode: string;
+  expectedAmount: ETAmount;
+  collectedAmount: ETAmount;
+  transactionId: string;
+  tenantTransactionId: string; //todo Hardcode this value for SL ReleaseD
+  onSubmitET: (etOut: CompletePaymentOutput) => void;
+};
+
+export type CompletePaymentOutput = BaseETResponse & {
+  tenantTransactionId: string; // must be equal to transaction ID for SL release
+  paymentMode: string;
+  collectedAmount: ETAmount;
+};

package/src/components/executiontasks/payments/init/InitPaymentET.tsx

@@ -0,0 +1,247 @@
+import type { InitPaymentInput } from './InitPaymentSchema';
+import React, { useEffect, useState, useLayoutEffect } from 'react';
+import { FlatList, Text, View } from 'react-native';
+import { isEmptyOrBlank } from '../../../../utils/utils';
+import { getPaymentValue, getUniqueTransactionID } from '../PaymentUtils';
+import { getBaseETResponse } from '../../../../utils/ExecTaskUtils';
+import {
+  EntityCode,
+  ExecutionTaskID,
+} from '../../../../models/execTasks/ETConfig';
+import { getEventCodeByET } from '../../../../manager/dispatchCodes/EventCodeContainer';
+import { PaymentStyles } from '../PaymentStyles';
+import { CommonStyles } from '../../../../styles/executionTasks/CommonStyles';
+import { showToast } from '../../../widgets/Toaster';
+import {
+  Button,
+  Modal,
+  Portal,
+  Provider,
+  RadioButton,
+} from 'react-native-paper';
+import Icon from 'react-native-vector-icons/MaterialIcons';
+import { GO_BACK_EVENT_CODE } from '../../../../constants/constants';
+import { hasGoBackConnector } from '../../../../components/utils';
+import GoBackModal from '../../../../components/widgets/GoBackModal';
+import { useFocusEffect } from '@react-navigation/native';
+import { BackHandler } from 'react-native';
+
+const styles = PaymentStyles;
+
+const footerMessage = (message?: string) => {
+  if (message)
+    return (
+      <View>
+        <Text style={styles.textStyle1}>MESSAGE</Text>
+        <Text style={styles.messageStyle}>{message}</Text>
+      </View>
+    );
+  else return null;
+};
+const InitPaymentET = (props: InitPaymentInput) => {
+  const [paymentMode, setPaymentMode] = useState('');
+  const [disableNext, setDisableNext] = useState(false);
+  const [showBackModal, setShowBackModal] = useState(false);
+
+  // Handle back-button click
+  useFocusEffect(
+    React.useCallback(() => {
+      const onBackPress = () => {
+        if (
+          props.taskMeta?.enableGoBack &&
+          hasGoBackConnector(props.applicableReasons)
+        ) {
+          setShowBackModal(true);
+          return true;
+        } else {
+          props.navigation.goBack();
+          return true;
+        }
+      };
+      BackHandler.addEventListener('hardwareBackPress', onBackPress);
+      return () =>
+        BackHandler.removeEventListener('hardwareBackPress', onBackPress);
+    }, [])
+  );
+
+  useLayoutEffect(() => {
+    props.navigation.setOptions({
+      title: props.title,
+      headerLeft: () => {
+        return (
+          <Icon
+            onPress={() => {
+              if (
+                props.taskMeta?.enableGoBack &&
+                hasGoBackConnector(props.applicableReasons)
+              )
+                setShowBackModal(true);
+              else props.navigation.goBack();
+            }}
+            name="arrow-back"
+            color={'black'}
+            size={25}
+            style={{
+              paddingRight: 15,
+              paddingTop: 5,
+            }}
+          />
+        );
+      },
+    });
+  }, [props.navigation, props.title]);
+
+  const renderModal = () => {
+    return (
+      <GoBackModal
+        showModal={showBackModal}
+        setShowModal={setShowBackModal}
+        onSuccess={async () => {
+          props.onSubmitET({
+            ...(await getBaseETResponse(
+              EntityCode.INIT_PAYMENT,
+              false,
+              GO_BACK_EVENT_CODE,
+              '',
+              props.mergedObjectiveId,
+              ExecutionTaskID.INIT_PAYMENT
+            )),
+          });
+          setShowBackModal(false);
+        }}
+        onFailure={() => setShowBackModal(false)}
+      />
+    );
+  };
+
+  useEffect(() => {
+    if (props.allowedModes && props.allowedModes.length === 1) {
+      setPaymentMode(props.allowedModes[0]);
+    }
+  }, [props.allowedModes]);
+  const renderItem = ({ item }: { item: string }) => {
+    return (
+      <View style={styles.reasonItemStyle}>
+        <RadioButton
+          color={'#5B80F7'}
+          value={item}
+          status={paymentMode === item ? 'checked' : 'unchecked'}
+          onPress={() => {
+            setPaymentMode(item);
+          }}
+        />
+        <Text
+          style={styles.reasonTextStyle}
+          onPress={() => {
+            setPaymentMode(item);
+          }}
+        >
+          {item}
+        </Text>
+      </View>
+    );
+  };
+
+  return (
+    <Provider>
+      {renderModal()}
+      <View style={CommonStyles.mainContainer}>
+        <Text style={styles.textStyle1}>AMOUNT</Text>
+        <Text style={styles.amountStyle}>
+          {props.amount.currencyCode +
+            ' ' +
+            getPaymentValue(
+              props.amount.value,
+              props.amount.minorUnit
+            ).toLocaleString()}
+        </Text>
+        <Text style={styles.textStyle1}>OPTIONS TO COLLECT PAYMENT</Text>
+        <View style={{ flex: 1 }}>
+          <FlatList
+            data={props.allowedModes}
+            renderItem={renderItem}
+            keyExtractor={(item) => item}
+            ListFooterComponent={footerMessage(props.message)}
+          />
+        </View>
+        <View style={{ justifyContent: 'flex-end', marginBottom: 10 }}>
+          <View
+            style={{
+              flexDirection: 'row',
+              marginStart: 10,
+              marginEnd: 10,
+            }}
+          >
+            <Button
+              style={[
+                CommonStyles.cancelButton,
+                {
+                  marginEnd: 5,
+                  flex: 1,
+                },
+              ]}
+              labelStyle={CommonStyles.cancelButtonLabel}
+              mode={'outlined'}
+              onPress={async () => {
+                props.onSubmitET({
+                  paymentMode: paymentMode,
+                  transactionId: getUniqueTransactionID(props.amount.value),
+                  ...(await getBaseETResponse(
+                    EntityCode.INIT_PAYMENT,
+                    false,
+                    getEventCodeByET(
+                      ExecutionTaskID.INIT_PAYMENT,
+                      false,
+                      props.applicableReasons?.failure
+                    ),
+                    '',
+                    props.mergedObjectiveId,
+                    ExecutionTaskID.INIT_PAYMENT
+                  )),
+                });
+              }}
+            >
+              Cancel
+            </Button>
+            <Button
+              disabled={disableNext}
+              style={[
+                CommonStyles.nextButton,
+                {
+                  flex: 1,
+                  marginStart: 5,
+                },
+              ]}
+              labelStyle={CommonStyles.nextButtonLabel}
+              mode={'contained'}
+              onPress={async () => {
+                if (!isEmptyOrBlank(paymentMode)) {
+                  setDisableNext(true);
+                  props.onSubmitET({
+                    paymentMode: paymentMode,
+                    transactionId: getUniqueTransactionID(props.amount.value),
+                    ...(await getBaseETResponse(
+                      EntityCode.INIT_PAYMENT,
+                      true,
+                      getEventCodeByET(
+                        ExecutionTaskID.INIT_PAYMENT,
+                        true,
+                        props.applicableReasons?.success
+                      ),
+                      '',
+                      props.mergedObjectiveId,
+                      ExecutionTaskID.INIT_PAYMENT
+                    )),
+                  });
+                } else showToast('No payment mode selected');
+              }}
+            >
+              Collect
+            </Button>
+          </View>
+        </View>
+      </View>
+    </Provider>
+  );
+};
+export default InitPaymentET;

package/src/components/executiontasks/payments/init/InitPaymentSchema.ts

@@ -0,0 +1,37 @@
+/**
+ * Amount to be collected
+ */
+import type {
+  BaseETRequest,
+  BaseETResponse,
+} from '../../../../models/execTasks/ETBaseModels';
+/**
+ * List of allowed Modes
+ */
+
+export type AllowedModes = 'CASH' | 'UPI' | 'PAYMENT_LINK';
+
+export type InitPaymentInput = BaseETRequest & {
+  amount: ETAmount;
+  allowedModes: string[];
+  onSubmitET: (output: InitPaymentOutput) => void;
+};
+/**
+ * Amount to be collected (ISO 4217)
+ */
+export interface ETAmount {
+  value: number;
+  currencyCode: string;
+  minorUnit?: number;
+}
+
+export type InitPaymentOutput = BaseETResponse & {
+  /**
+   * Unique transaction id
+   */
+  transactionId?: string;
+  /**
+   * Payment mode selected by user
+   */
+  paymentMode?: string;
+};

package/src/components/executiontasks/payments/processPayment/ProcessPaymentET.tsx

@@ -0,0 +1,272 @@
+import type { ProcessPaymentInput } from './ProcessPaymentSchema';
+import {
+  BackHandler,
+  KeyboardAvoidingView,
+  ScrollView,
+  Text,
+  View,
+} from 'react-native';
+import React, { useState, useLayoutEffect } from 'react';
+import { getBaseETResponse } from '../../../../utils/ExecTaskUtils';
+import { getEventCodeByET } from '../../../../manager/dispatchCodes/EventCodeContainer';
+import {
+  EntityCode,
+  ExecutionTaskID,
+} from '../../../../models/execTasks/ETConfig';
+import { PaymentStyles } from '../PaymentStyles';
+import { isEmptyOrBlank } from '../../../../utils/utils';
+import { CommonStyles } from '../../../../styles/executionTasks/CommonStyles';
+import { getPaymentValue } from '../PaymentUtils';
+import { Button, Modal, Portal, Provider, TextInput } from 'react-native-paper';
+import Icon from 'react-native-vector-icons/MaterialIcons';
+import { GO_BACK_EVENT_CODE } from '../../../../constants/constants';
+import GoBackModal from '../../../../components/widgets/GoBackModal';
+import { hasGoBackConnector } from '../../../../components/utils';
+import { useFocusEffect } from '@react-navigation/native';
+
+const styles = PaymentStyles;
+
+const ProcessPaymentET = (props: ProcessPaymentInput) => {
+  const [amountCollected, setAmountCollected] = useState('');
+  const [inputError, setInputError] = useState('');
+  const [disableNext, setDisableNext] = useState(false);
+  const [showBackModal, setShowBackModal] = useState(false);
+
+  // Handle back-button click
+  useFocusEffect(
+    React.useCallback(() => {
+      const onBackPress = () => {
+        if (
+          props.taskMeta?.enableGoBack &&
+          hasGoBackConnector(props.applicableReasons)
+        ) {
+          setShowBackModal(true);
+          return true;
+        } else {
+          props.navigation.goBack();
+          return true;
+        }
+      };
+      BackHandler.addEventListener('hardwareBackPress', onBackPress);
+      return () =>
+        BackHandler.removeEventListener('hardwareBackPress', onBackPress);
+    }, [])
+  );
+
+  useLayoutEffect(() => {
+    props.navigation.setOptions({
+      title: props.title,
+      headerLeft: () => {
+        return (
+          <Icon
+            onPress={() => {
+              if (
+                props.taskMeta?.enableGoBack &&
+                hasGoBackConnector(props.applicableReasons)
+              )
+                setShowBackModal(true);
+              else props.navigation.goBack();
+            }}
+            name="arrow-back"
+            color={'black'}
+            size={25}
+            style={{
+              paddingRight: 15,
+              paddingTop: 5,
+            }}
+          />
+        );
+      },
+    });
+  }, [props.navigation, props.title]);
+
+  const renderModal = () => {
+    return (
+      <GoBackModal
+        showModal={showBackModal}
+        setShowModal={setShowBackModal}
+        onSuccess={async () => {
+          props.onSubmitET({
+            paymentMode: props.paymentMode,
+            collectedAmount: {
+              value: +amountCollected,
+              currencyCode: props.amount.currencyCode,
+              minorUnit: props.amount.minorUnit,
+            },
+            transactionId: props.transactionId,
+            tenantTransactionId: props.transactionId,
+            ...(await getBaseETResponse(
+              EntityCode.PROCESS_PAYMENT,
+              false,
+              GO_BACK_EVENT_CODE,
+              '',
+              props.mergedObjectiveId,
+              ExecutionTaskID.PROCESS_PAYMENT
+            )),
+          });
+          setShowBackModal(false);
+        }}
+        onFailure={() => setShowBackModal(false)}
+      />
+    );
+  };
+
+  return (
+    <Provider>
+      {renderModal()}
+      <KeyboardAvoidingView style={CommonStyles.mainContainer}>
+        <ScrollView style={CommonStyles.mainContainer}>
+          <View style={CommonStyles.mainContainer}>
+            <Text style={styles.textStyle1}>AMOUNT TO BE COLLECTED</Text>
+            <Text style={styles.amountStyle}>
+              {props.amount.currencyCode +
+                ' ' +
+                getPaymentValue(
+                  props.amount.value,
+                  props.amount.minorUnit
+                ).toLocaleString()}
+            </Text>
+            <View
+              style={{
+                marginTop: 20,
+                paddingTop: 10,
+                paddingStart: 20,
+                paddingEnd: 20,
+                backgroundColor: 'white',
+                paddingBottom: 40,
+              }}
+            >
+              <TextInput
+                multiline={false}
+                autoComplete={'off'}
+                label="Total Amount Collected"
+                value={amountCollected}
+                mode={'outlined'}
+                error={!isEmptyOrBlank(inputError)}
+                selectionColor={'#6200EE'}
+                keyboardType={'numeric'}
+                onChangeText={(text) => {
+                  setInputError('');
+                  setAmountCollected(text);
+                }}
+              />
+              {!isEmptyOrBlank(inputError) && (
+                <Text style={{ color: '#B00020' }}>{inputError}</Text>
+              )}
+            </View>
+            {props.message && (
+              <View>
+                <Text style={styles.textStyle1}>MESSAGE</Text>
+                <Text style={styles.messageStyle}>{props.message}</Text>
+              </View>
+            )}
+          </View>
+        </ScrollView>
+        <View style={{ margin: 10 }}>
+          <View
+            style={{
+              flexDirection: 'row',
+              marginStart: 10,
+              marginEnd: 10,
+            }}
+          >
+            <Button
+              style={[
+                CommonStyles.cancelButton,
+                {
+                  marginEnd: 5,
+                  flex: 1,
+                },
+              ]}
+              labelStyle={CommonStyles.cancelButtonLabel}
+              mode={'outlined'}
+              onPress={async () => {
+                props.onSubmitET({
+                  paymentMode: props.paymentMode,
+                  collectedAmount: {
+                    value: +amountCollected,
+                    currencyCode: props.amount.currencyCode,
+                    minorUnit: props.amount.minorUnit,
+                  },
+                  transactionId: props.transactionId,
+                  tenantTransactionId: props.transactionId,
+                  ...(await getBaseETResponse(
+                    EntityCode.PROCESS_PAYMENT,
+                    false,
+                    getEventCodeByET(
+                      ExecutionTaskID.PROCESS_PAYMENT,
+                      false,
+                      props.applicableReasons?.failure
+                    ),
+                    '',
+                    props.mergedObjectiveId,
+                    ExecutionTaskID.PROCESS_PAYMENT
+                  )),
+                });
+              }}
+            >
+              Cancel
+            </Button>
+            <Button
+              disabled={disableNext}
+              style={[
+                CommonStyles.nextButton,
+                {
+                  marginStart: 5,
+                  flex: 1,
+                },
+              ]}
+              labelStyle={CommonStyles.nextButtonLabel}
+              mode={'contained'}
+              onPress={async () => {
+                if (
+                  !isEmptyOrBlank(amountCollected) &&
+                  !Number.isNaN(+amountCollected)
+                ) {
+                  const calculatedValue = getPaymentValue(
+                    props.amount.value,
+                    props.amount.minorUnit
+                  );
+                  if (+amountCollected !== calculatedValue) {
+                    setInputError(
+                      `Amount should be equal to ${calculatedValue}`
+                    );
+                    return;
+                  }
+                  setDisableNext(true);
+                  props.onSubmitET({
+                    paymentMode: props.paymentMode,
+                    collectedAmount: {
+                      value: props.amount.value,
+                      currencyCode: props.amount.currencyCode,
+                      minorUnit: props.amount.minorUnit,
+                    },
+                    transactionId: props.transactionId,
+                    tenantTransactionId: props.transactionId,
+                    ...(await getBaseETResponse(
+                      EntityCode.PROCESS_PAYMENT,
+                      true,
+                      getEventCodeByET(
+                        ExecutionTaskID.PROCESS_PAYMENT,
+                        true,
+                        props.applicableReasons?.success
+                      ),
+                      '',
+                      props.mergedObjectiveId,
+                      ExecutionTaskID.PROCESS_PAYMENT
+                    )),
+                  });
+                } else {
+                  setInputError('Please enter valid amount.');
+                }
+              }}
+            >
+              Next
+            </Button>
+          </View>
+        </View>
+      </KeyboardAvoidingView>
+    </Provider>
+  );
+};
+export default ProcessPaymentET;

package/src/components/executiontasks/payments/processPayment/ProcessPaymentSchema.ts

@@ -0,0 +1,38 @@
+/**
+ * Amount to be collected
+ */
+import type {
+  BaseETRequest,
+  BaseETResponse,
+} from '../../../../models/execTasks/ETBaseModels';
+import type { ETAmount } from '../init/InitPaymentSchema';
+/**
+ * Payment mode
+ */
+
+export type ProcessPaymentInput = BaseETRequest & {
+  amount: ETAmount;
+  paymentMode: string;
+  transactionId: string;
+  onSubmitET: (output: ProcessPaymentOutput) => void;
+};
+/**
+ * Amount to be collected (ISO 4217)
+ */
+
+export type ProcessPaymentOutput = BaseETResponse & {
+  /**
+   * Unique transaction id
+   */
+  transactionId: string;
+  tenantTransactionId: string;
+  /**
+   * Amount collected (ISO 4217)
+   */
+  collectedAmount: ETAmount;
+  /**
+   * Payment meta data
+   */
+  paymentMeta?: {};
+  paymentMode: string;
+};

package/src/components/executiontasks/pickup/PickpSchema.ts

@@ -0,0 +1,28 @@
+/**
+ * Unique identifier for the item
+ */
+import type { BaseETResponse, LineItem } from '../ExecutionTasksIndex';
+import type { BaseETRequest } from '../../../models/execTasks/ETBaseModels';
+
+/**
+ * Any manual instruction to display for the Operator to work on
+ */
+export type Instruction = string;
+export interface PickupRemarks {
+  pickupRemark: string;
+  success: boolean;
+}
+
+export type PickupETInput = BaseETRequest & {
+  items: LineItem[];
+  pickupCount?: number;
+  confirmCustodyExchange?: boolean;
+  onSubmitET(pickupRemark: PickupETOutput): void;
+};
+
+export type PickupETOutput = BaseETResponse & {
+  /**
+   * Remark captured at time of delivery
+   */
+  remark?: string;
+};