@os1-platform/dispatch-mobile 2.0.8 → 2.1.0

package/src/components/executiontasks/validateOTP/utils.ts

@@ -0,0 +1,180 @@
+import * as jsonLogic from 'json-logic-js';
+import { JSONPath } from 'jsonpath-plus';
+import Logger, { LOG_TYPE } from '../../../utils/Logger';
+import {
+  APIData,
+  getApiResponse,
+  KeyValueArray,
+} from '../../../utils/ApiUtils';
+import { DEFAULT_RETRY_CONFIG } from './constants';
+import type {
+  API,
+  InputType,
+  Validation,
+  RetryConfig,
+} from './ValidateOTPSchema';
+
+const isDyanmicValue = function (input: string) {
+  if (
+    input.charAt(0) === '{' &&
+    input.charAt(1) === '{' &&
+    input.charAt(input.length - 1) === '}' &&
+    input.charAt(input.length - 2) === '}'
+  )
+    return true;
+  else return false;
+};
+
+export function parseBody(body: any, userInput: any) {
+  const requestBody = JSON.parse(JSON.stringify(body));
+  for (const key in requestBody) {
+    if (Object.prototype.hasOwnProperty.call(requestBody, key)) {
+      const value = requestBody[key];
+      if (typeof value === 'object') {
+        requestBody[key] = parseBody(value, userInput);
+      } else if (Array.isArray(value)) {
+        value.forEach((val) => {
+          requestBody[key] = parseBody(val, userInput);
+        });
+      } else {
+        if (
+          typeof value === 'string' &&
+          isDyanmicValue(value) &&
+          value.includes('userInput')
+        ) {
+          if (value.includes('captureInput'))
+            requestBody[key] = userInput.captureInput;
+        }
+      }
+    }
+  }
+  return requestBody;
+}
+
+export function parseKeyValue(array: KeyValueArray[], userInput: any) {
+  array.forEach((item) => {
+    if (isDyanmicValue(item.value) && item.value.includes('userInput')) {
+      if (item.value.includes('captureInput'))
+        item.value = userInput.captureInput;
+    }
+  });
+  return array;
+}
+
+export const generateOTP = async (api: API) => {
+  // TESTING
+  try {
+    const apiData: APIData = {
+      errorJsonPath: '',
+      responseJsonPath: '',
+      uri: api.uri,
+      httpMethod: api.httpMethod,
+      timeout: api.timeout,
+      headers: api.headers,
+    };
+    if (api.requestBody) {
+      apiData.requestBody = api.requestBody;
+    }
+    if (api.pathParams) {
+      apiData.pathParams = api.pathParams;
+    }
+    if (api.queryParams) {
+      apiData.queryParams = api.queryParams;
+    }
+
+    const apiResponse = await getApiResponse(apiData);
+
+    return jsonLogic.apply(
+      <jsonLogic.RulesLogic>api.responseJsonLogic,
+      apiResponse.data
+    );
+  } catch (error: any) {
+    Logger.getInstance().logEvent(
+      '~ generateOTP',
+      error.message,
+      LOG_TYPE.SDK_ERROR
+    );
+    return false;
+  }
+};
+
+export const checkForValidation = async (
+  otp: string,
+  validation: Validation,
+  userInput: any
+): Promise<boolean> => {
+  // API
+  if (validation.selectedIndex === 0) {
+    const otpValue = JSONPath({
+      path: '$.userInput.captureInput',
+      json: userInput,
+    })[0];
+
+    try {
+      //@ts-ignore
+      const api: API = validation.logic.api;
+      const apiData: APIData = {
+        errorJsonPath: '',
+        responseJsonPath: '',
+        uri: api.uri,
+        httpMethod: api.httpMethod,
+        timeout: api.timeout,
+        headers: api.headers,
+      };
+      if (api.requestBody) {
+        const parsedRequestBody = parseBody(api.requestBody, {
+          captureInput: otpValue,
+        });
+        apiData.requestBody = parsedRequestBody;
+      }
+      if (api.pathParams) {
+        parseKeyValue(api.pathParams, { captureInput: otpValue });
+        apiData.pathParams = api.pathParams;
+      }
+      if (api.queryParams) {
+        parseKeyValue(api.queryParams, { captureInput: otpValue });
+        apiData.queryParams = api.queryParams;
+      }
+      const apiResponse = await getApiResponse(apiData);
+      return jsonLogic.apply(
+        <jsonLogic.RulesLogic>api.responseJsonLogic,
+        apiResponse.data
+      );
+    } catch (error: any) {
+      Logger.getInstance().logEvent(
+        '~ checkForValidation',
+        error.message,
+        LOG_TYPE.SDK_ERROR
+      );
+      return false;
+    }
+  }
+  // Exact Value
+  else if (validation.selectedIndex === 1) {
+    // @ts-ignore
+    const value: InputType = validation.logic.value;
+    return value == otp;
+  }
+  // Invalid input received
+  else {
+    return false;
+  }
+};
+
+export const parseRetryConfig = (
+  inputRetryConfig: RetryConfig | undefined
+): RetryConfig => {
+  const retryConfig: RetryConfig = DEFAULT_RETRY_CONFIG;
+  if (inputRetryConfig) {
+    if (inputRetryConfig.buttonTitle) {
+      retryConfig.buttonTitle = inputRetryConfig.buttonTitle;
+    }
+    if (inputRetryConfig.delay) {
+      retryConfig.delay = inputRetryConfig.delay;
+    }
+    if (inputRetryConfig.maxAttempt) {
+      retryConfig.maxAttempt = inputRetryConfig.maxAttempt;
+    }
+  }
+  return retryConfig;
+};

package/src/components/executiontasks/verifyInput/VerifyInputSchema.ts

@@ -0,0 +1,49 @@
+import type {
+  BaseETRequest,
+  BaseETResponse,
+} from '../../../models/execTasks/ETBaseModels';
+
+export type VerifyInput =
+  | (BaseETRequest & {
+      input: Input;
+      value: Value;
+    })
+  | (BaseETRequest & {
+      input: Input1;
+      api: API;
+    });
+/**
+ * Input entered by user
+ */
+export type Input = string | number;
+/**
+ * Value
+ */
+export type Value = string | number;
+/**
+ * Input entered by user
+ */
+export type Input1 = string | number;
+/**
+ * Verification api URI
+ */
+export type HeaderKey = string;
+export type HeaderValue = string;
+/**
+ * Verification api headers
+ */
+export type Headers = {
+  key?: HeaderKey;
+  value?: HeaderValue;
+};
+
+/**
+ * Api
+ */
+export interface API {
+  uri: string;
+  headers?: Headers[];
+  valueJsonPath: string;
+}
+
+export type VerifyInputResponse = BaseETResponse;

package/src/components/executiontasks/verifyLocation/GeofenceUtils.ts

@@ -0,0 +1,55 @@
+import type { VerifyLocationInput } from './VerifyLocSchema';
+import * as Location from 'expo-location';
+import { BaseError } from '../../../errors/BaseError';
+import ErrorCodes from '../../../errors/ErrorCodes';
+
+export async function verifyLocation(
+  params: VerifyLocationInput
+): Promise<boolean> {
+  const { status } = await Location.getForegroundPermissionsAsync();
+  let response: boolean;
+  if (status === 'granted') {
+    response = await geofenceLogic(params);
+  } else {
+    const { status } = await Location.requestForegroundPermissionsAsync();
+    if (status === 'granted') {
+      response = await geofenceLogic(params);
+    } else {
+      throw new BaseError(
+        ErrorCodes.LOCATION_PERMISSION_DENIED,
+        'Location Permission denied'
+      );
+    }
+  }
+  return response;
+}
+
+async function geofenceLogic(params: VerifyLocationInput): Promise<boolean> {
+  const options = {
+    accuracy: Location.Accuracy.Highest,
+  };
+  const location = await Location.getCurrentPositionAsync(options);
+  if (
+    params.geolocation.accuracy &&
+    location.coords.accuracy &&
+    params.geolocation.accuracy < location.coords.accuracy
+  )
+    return false;
+  else {
+    const latitude: number = +params.geolocation.latitude;
+    const longitude: number = +params.geolocation.longitude;
+    const radlat1 = (Math.PI * latitude) / 180;
+    const radlat2 = (Math.PI * location.coords.latitude) / 180;
+    const theta = longitude - location.coords.longitude;
+    const radtheta = (Math.PI * theta) / 180;
+    let dist =
+      Math.sin(radlat1) * Math.sin(radlat2) +
+      Math.cos(radlat1) * Math.cos(radlat2) * Math.cos(radtheta);
+    if (dist > 1) {
+      dist = 1;
+    }
+    const multiplier = (180 * 60 * 1.1515 * 1.609344 * 1000) / Math.PI;
+    dist = Math.acos(dist) * multiplier;
+    return params.geolocation.geofencing.radius >= dist;
+  }
+}

package/src/components/executiontasks/verifyLocation/VerifyLocSchema.ts

@@ -0,0 +1,56 @@
+/**
+ * Longitude
+ */
+import type {
+  BaseETRequest,
+  BaseETResponse,
+} from '../../../models/execTasks/ETBaseModels';
+
+export type Longitude = string;
+/**
+ * Latitude
+ */
+export type Latitude = string;
+/**
+ * Accuracy in meters of the geolocation
+ */
+export type Accuracy = number | null;
+/**
+ * Boolean key to enable/disable geofencing feature
+ */
+export type GeofencingEnabled = boolean;
+/**
+ * Radius in meters around the verifyLocation for geo-fencing
+ */
+export type Radius = number;
+/**
+ * Boolean key to enable manual override the geo-fencing feature
+ */
+export type Override = boolean;
+/**
+ * Any manual instruction to display for the Operator to work on
+ */
+export type Instruction = string;
+
+export type VerifyLocationInput = BaseETRequest & {
+  geolocation: GeoLocation;
+  address?: string;
+  onSubmitET: (value: VerifyLocationOutput) => void;
+};
+/**
+ * Details of geo-verifyLocation
+ */
+export interface GeoLocation {
+  longitude: Longitude;
+  latitude: Latitude;
+  accuracy?: Accuracy;
+  geofencing: Geofencing;
+}
+/**
+ * Details of geo-fencing around the verifyLocation
+ */
+export interface Geofencing {
+  radius: Radius;
+}
+
+export type VerifyLocationOutput = BaseETResponse;

package/src/components/executiontasks/verifyLocation/VerifyLocationET.tsx

@@ -0,0 +1,69 @@
+import { View } from 'react-native';
+import React, { useCallback, useEffect, useState } from 'react';
+import type { VerifyLocationInput } from './VerifyLocSchema';
+import { verifyLocation } from './GeofenceUtils';
+import { getBaseETResponse } from '../../../utils/ExecTaskUtils';
+import { getEventCodeByET } from '../../../manager/dispatchCodes/EventCodeContainer';
+import {
+  EntityCode,
+  ExecutionTaskID,
+} from '../../../models/execTasks/ETConfig';
+import { CommonStyles } from '../../../styles/executionTasks/CommonStyles';
+import ProgressDialog from '../../widgets/ProgressDialog';
+import { BaseError } from '../../../errors/BaseError';
+import { showAlert } from '../../widgets/AlertDisplay';
+import SdkUtils from '../../../utils/SdkUtils';
+
+const VerifyLocationET = (props: VerifyLocationInput) => {
+  const [geofencing, setGeofencing] = useState(true);
+  const submitLocationResponse = useCallback(
+    async (response: boolean) => {
+      const _appRC = response
+        ? props.applicableReasons?.success
+        : props.applicableReasons?.failure;
+      props.onSubmitET({
+        ...(await getBaseETResponse(
+          EntityCode.VERIFY_LOCATION,
+          response,
+          getEventCodeByET(ExecutionTaskID.VERIFY_LOCATION, response, _appRC),
+          '',
+          props.mergedObjectiveId,
+          ExecutionTaskID.VERIFY_LOCATION
+        )),
+      });
+    },
+    [props]
+  );
+  useEffect(() => {
+    (async () => {
+      try {
+        let response = await verifyLocation(props);
+        await submitLocationResponse(response);
+        setGeofencing(false);
+      } catch (error: any) {
+        if (error instanceof BaseError) {
+          showAlert(
+            'Permission Denied',
+            'Please enable Location permissions from settings and Try again',
+            false,
+            'Open Settings',
+            () => {
+              SdkUtils.openAppSettings();
+            }
+          );
+        } else {
+          await submitLocationResponse(false);
+        }
+      }
+    })();
+  }, []);
+  return (
+    <View style={CommonStyles.mainContainer}>
+      <ProgressDialog
+        visible={geofencing}
+        label={props.message ?? 'Verifying Location...'}
+      />
+    </View>
+  );
+};
+export default VerifyLocationET;

package/src/components/executiontasks/verifyOtp/VerifyOtpET.tsx

@@ -0,0 +1,96 @@
+import { BackHandler, Pressable, StyleSheet, Text, View } from 'react-native';
+import React, { useEffect, useRef } from 'react';
+// @ts-ignore
+import OTPTextView from 'react-native-otp-textinput';
+import { Colors } from 'react-native-paper';
+import { showToast } from '../../widgets/Toaster';
+import type { OtpInputSchema } from './VerifyOtpSchema';
+import { getBaseETResponse } from '../../../utils/ExecTaskUtils';
+import {
+  EntityCode,
+  ExecutionTaskID,
+} from '../../../models/execTasks/ETConfig';
+
+const VerifyOtpET = (props: OtpInputSchema) => {
+  const otpInput = useRef();
+
+  function backButtonHandler() {
+    return true;
+  }
+  useEffect(() => {
+    BackHandler.addEventListener('hardwareBackPress', backButtonHandler);
+    return () => {
+      BackHandler.removeEventListener('hardwareBackPress', backButtonHandler);
+    };
+  }, []);
+
+  return (
+    <View>
+      <View style={styles.otpInputTextView}>
+        <Text style={styles.veriOtpText}>Verify OTP</Text>
+        <OTPTextView
+          textInputStyle={styles.otpInputStyle}
+          ref={otpInput}
+          inputCount={props.inputCount}
+          tintColor={Colors.blue300}
+          handleTextChange={async (value: string) => {
+            if (value.length === props.inputCount) {
+              props.onSubmit({
+                ...(await getBaseETResponse(
+                  EntityCode.VERIFY_INPUT,
+                  true,
+                  '',
+                  '',
+                  props.mergedObjectiveId,
+                  ExecutionTaskID.VERIFY_INPUT
+                )),
+              });
+            }
+          }}
+        />
+        <View style={styles.otpNotReceivedView}>
+          <Text>Haven't received the sms?</Text>
+
+          <Pressable
+            onPress={() => {
+              showToast('Resending OTP');
+            }}
+            style={styles.sendAgainText}
+          >
+            <Text>Send again</Text>
+          </Pressable>
+        </View>
+      </View>
+    </View>
+  );
+};
+export default VerifyOtpET;
+
+const styles = StyleSheet.create({
+  backIconView: {
+    marginTop: 22,
+    marginStart: 22,
+  },
+  veriOtpText: {
+    fontSize: 24,
+    color: Colors.black,
+    marginTop: 40,
+  },
+  otpInputStyle: {
+    borderRadius: 4,
+    borderWidth: 1,
+    paddingHorizontal: 16,
+    paddingVertical: 12,
+    marginTop: 32,
+  },
+  otpInputTextView: {
+    marginHorizontal: 17,
+  },
+  otpNotReceivedView: {
+    flexDirection: 'row',
+    marginTop: 10,
+  },
+  sendAgainText: {
+    marginHorizontal: 8,
+  },
+});

package/src/components/executiontasks/verifyOtp/VerifyOtpSchema.ts

@@ -0,0 +1,27 @@
+/**
+ * Otp entered by user
+ */
+import type {
+  BaseETRequest,
+  BaseETResponse,
+} from '../../../models/execTasks/ETBaseModels';
+
+export type InputOtp = string;
+/**
+ * Otp Value
+ */
+export type Otp = string;
+
+export type OtpInputSchema = BaseETRequest & {
+  inputCount: number;
+  inputOtp: InputOtp;
+  otp: Otp;
+  onSubmit: (output: OtpOutputSchema) => void;
+};
+
+export type OtpOutputSchema = BaseETResponse & {
+  /**
+   * Boolean to represent result of verification
+   */
+  success: boolean;
+};

package/src/components/utils/index.ts

@@ -0,0 +1,18 @@
+import { GO_BACK_EVENT_CODE } from '../../constants/constants';
+import {
+  ApplicableReasons,
+  NewApplicableReasons,
+} from '../../models/execTasks/ETBaseModels';
+
+export function hasGoBackConnector(
+  applicableReasons: ApplicableReasons | NewApplicableReasons | undefined
+): boolean {
+  if (
+    applicableReasons &&
+    applicableReasons.goBack &&
+    typeof applicableReasons.goBack === 'object' &&
+    applicableReasons.goBack?.hasOwnProperty(GO_BACK_EVENT_CODE)
+  ) {
+    return true;
+  } else return false;
+}

package/src/components/widgets/AlertDisplay.tsx

@@ -0,0 +1,38 @@
+import { DispatchUtilsInterface } from '../../utils/SdkUtils';
+import Logger, { LOG_TYPE } from '../../utils/Logger';
+import { Alert, Platform } from 'react-native';
+
+export function showAlert(
+  title: string,
+  message: string,
+  cancelable: boolean,
+  btnPositive: string,
+  positiveCall: () => void,
+  btnNegative?: string,
+  negCall?: () => void
+) {
+  if (Platform.OS === 'android') {
+    DispatchUtilsInterface.showAndroidDialog(
+      title,
+      message,
+      btnPositive,
+      btnNegative ?? null,
+      cancelable
+    )
+      .then((success: boolean) => {
+        if (success) positiveCall();
+        else if (negCall) {
+          negCall();
+        }
+      })
+      .catch((error: { message: string }) => {
+        Logger.getInstance().logEvent(
+          'error',
+          error.message,
+          LOG_TYPE.SDK_ERROR
+        );
+      });
+  } else {
+    Alert.alert(title, message);
+  }
+}

package/src/components/widgets/CancelOrderDialog.tsx

@@ -0,0 +1,112 @@
+import React from 'react';
+import { Modal, Platform, StyleSheet, View } from 'react-native';
+import { CommonStyles, Fonts } from '../../styles/executionTasks/CommonStyles';
+import { Button, Paragraph, Title } from 'react-native-paper';
+import Icon from 'react-native-vector-icons/MaterialCommunityIcons';
+import SdkColors, { ColorTheme } from '../../styles/SdkColors';
+
+const CancelOrderDialog = (props: CancelDialogProps) => {
+  return (
+    <Modal
+      animationType="none"
+      transparent={true}
+      visible={props.visible}
+      onRequestClose={() => {}}
+    >
+      <View style={styles.wrapper}>
+        <View style={styles.content}>
+          {props.showIcon && props.iconName && (
+            <Icon
+              style={{ alignSelf: 'center' }}
+              size={34}
+              name={props.iconName}
+              color={SdkColors[ColorTheme.LIGHT].primaryButton}
+            />
+          )}
+          <Title
+            style={{
+              fontFamily:
+                Platform.OS === 'android'
+                  ? Fonts.IBMPlexSans_600SemiBold
+                  : 'IBMPlexSans-SemiBold',
+              marginTop: 0,
+              marginBottom: 15,
+              textAlign: 'center',
+              color: '#000000',
+            }}
+          >
+            {props.label ?? 'Cancel Order'}
+          </Title>
+          {props.message && (
+            <Paragraph
+              style={{
+                textAlign: 'center',
+                fontSize: 14,
+                fontFamily:
+                  Platform.OS === 'android'
+                    ? Fonts.IBMPlexSans_400Regular
+                    : 'IBMPlexSans-Regular',
+              }}
+            >
+              {props.message}
+            </Paragraph>
+          )}
+          <View style={{ marginTop: 20 }}>
+            <Button
+              mode={'outlined'}
+              uppercase={false}
+              labelStyle={CommonStyles.nextButtonLabel}
+              style={CommonStyles.nextButton}
+              onPress={() => {
+                props.onSubmit(true);
+              }}
+              testID="primary"
+            >
+              {props.positiveButtonTitle ?? 'Yes'}
+            </Button>
+            <Button
+              uppercase={false}
+              mode={'outlined'}
+              labelStyle={CommonStyles.cancelButtonLabel}
+              style={[CommonStyles.cancelButton, { marginTop: 10 }]}
+              onPress={async () => {
+                props.onSubmit(false);
+              }}
+              testID="secondary"
+            >
+              {props.negativeButtonTitle ?? 'No'}
+            </Button>
+          </View>
+        </View>
+      </View>
+    </Modal>
+  );
+};
+
+const styles = StyleSheet.create({
+  content: {
+    backgroundColor: 'white',
+    padding: 20,
+    borderRadius: 5,
+    width: '80%',
+  },
+  wrapper: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+    backgroundColor: 'rgba(0,0,0,0.7)',
+  },
+});
+
+export default CancelOrderDialog;
+
+export interface CancelDialogProps {
+  visible: boolean;
+  onSubmit: (success: boolean) => void;
+  label?: string;
+  message?: string;
+  positiveButtonTitle?: string;
+  negativeButtonTitle?: string;
+  showIcon?: boolean;
+  iconName?: string;
+}