@os1-platform/dispatch-mobile 3.0.4 → 3.1.1

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

@@ -1,180 +1,350 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 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 { createApiData, getAxiosApiResponse } from '../../../utils/ApiUtils';
 import { DEFAULT_RETRY_CONFIG } from './constants';
 import type {
-  API,
-  InputType,
-  Validation,
-  RetryConfig,
+  ResendOTPConfigType,
+  EmailAndPhoneResponse,
+  ContactType,
+  ValidateOTPInput,
+  ResendOTPPayloadType,
+  ResponseType,
+  ErrorResponseType,
+  GenerateOtpPayloadType,
 } from './ValidateOTPSchema';
+import Storage from '../../../utils/storage';
+import {
+  SHARED_PREFERENCE_RESEND_COUNT,
+  SHARED_PREFERENCE_RETRY_COUNT,
+} from '../../../manager/syncmanager/constants';
+import { ENDPOINTS } from '../../../constants/apiConstants';
+import getUuidByString from 'uuid-by-string';
 
-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 enum OTP_CONFIG {
+  OS1 = 'OTP_CONFIG',
+  CUSTOM = 'Custom',
 }
 
-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;
+type PropType = ValidateOTPInput & { domain: string };
+
+export enum countType {
+  RETRY,
+  RESEND,
 }
 
-export const generateOTP = async (api: API) => {
-  // TESTING
+export const VALIDATE_OTP_SCREENS = {
+  CONTACT_LIST: 'CONTACT_LIST',
+  OTP_VIEW: 'OTP_VIEW',
+  VERIFICATION_COMPLETE: 'VERIFICATION_COMPLETE',
+};
+
+export const generateOTP = async (
+  payload: GenerateOtpPayloadType,
+  props: PropType
+): Promise<any | ResponseType | ErrorResponseType> => {
   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 isCustomConfig = props.otpConfig === OTP_CONFIG.CUSTOM;
+    const apiData = createApiData(
+      payload,
+      props,
+      isCustomConfig
+        ? props?.otpGeneration?.uri
+        : `{baseURI}${ENDPOINTS.GENERATE_OTP_ENDPOINT}`,
+      'POST',
+      null,
+      isCustomConfig ? props.otpGeneration : undefined
+    );
 
-    const apiResponse = await getApiResponse(apiData);
+    const apiResponse = await getAxiosApiResponse(apiData);
 
-    return jsonLogic.apply(
-      <jsonLogic.RulesLogic>api.responseJsonLogic,
-      apiResponse.data
-    );
+    if (isCustomConfig && apiData.responseJsonLogic) {
+      return jsonLogic.apply(
+        <jsonLogic.RulesLogic>apiData.responseJsonLogic,
+        apiResponse.data
+      );
+    }
+
+    return apiResponse.data;
   } catch (error: any) {
     Logger.getInstance().logEvent(
       '~ generateOTP',
       error.message,
       LOG_TYPE.SDK_ERROR
     );
-    return false;
+    console.error('error: ', JSON.stringify(error));
+    return error?.response?.data ?? 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];
+export const verifyOTP = async (
+  payload: any,
+  props: PropType
+): Promise<any | ResponseType | ErrorResponseType> => {
+  try {
+    const isCustomConfig = props.otpConfig === OTP_CONFIG.CUSTOM;
+    const apiData = createApiData(
+      payload,
+      props,
+      isCustomConfig
+        ? props?.validationApi?.uri
+        : `{baseURI}${ENDPOINTS.VERIFY_OTP_ENDPOINT}`,
+      'POST',
+      null,
+      isCustomConfig ? props.validationApi : undefined
+    );
 
-    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);
+    const apiResponse = await getAxiosApiResponse(apiData);
+
+    if (isCustomConfig && apiData.responseJsonLogic) {
       return jsonLogic.apply(
-        <jsonLogic.RulesLogic>api.responseJsonLogic,
+        <jsonLogic.RulesLogic>apiData.responseJsonLogic,
         apiResponse.data
       );
-    } catch (error: any) {
-      Logger.getInstance().logEvent(
-        '~ checkForValidation',
-        error.message,
-        LOG_TYPE.SDK_ERROR
+    }
+
+    return apiResponse.data;
+  } catch (error: any) {
+    Logger.getInstance().logEvent(
+      '~ verifyOTP',
+      error.message,
+      LOG_TYPE.SDK_ERROR
+    );
+    console.error('error: ', JSON.stringify(error));
+    return error?.response?.data ?? false;
+  }
+};
+
+export const resendOTP = async (
+  payload: ResendOTPPayloadType,
+  props: PropType
+): Promise<any | ResponseType | ErrorResponseType> => {
+  try {
+    const isCustomConfig = props.otpConfig === OTP_CONFIG.CUSTOM;
+    const apiData = createApiData(
+      payload,
+      props,
+      isCustomConfig
+        ? props?.resendApi?.uri
+        : `{baseURI}${ENDPOINTS.RESEND_OTP_ENDPOINT}`,
+      'POST',
+      null,
+      isCustomConfig ? props.resendApi : undefined
+    );
+
+    const apiResponse = await getAxiosApiResponse(apiData);
+
+    if (isCustomConfig && apiData.responseJsonLogic) {
+      return jsonLogic.apply(
+        <jsonLogic.RulesLogic>apiData.responseJsonLogic,
+        apiResponse.data
       );
-      return false;
     }
+
+    return apiResponse.data;
+  } catch (error: any) {
+    Logger.getInstance().logEvent(
+      '~ resendOTP',
+      error.message,
+      LOG_TYPE.SDK_ERROR
+    );
+    console.error('error: ', JSON.stringify(error));
+    return error?.response?.data ?? false;
+  }
+};
+
+export const parseResendConfig = (
+  inputResendConfig: ResendOTPConfigType | undefined
+): ResendOTPConfigType => {
+  const resendConfig: ResendOTPConfigType = DEFAULT_RETRY_CONFIG;
+  if (inputResendConfig) {
+    if (inputResendConfig.buttonTitle) {
+      resendConfig.buttonTitle = inputResendConfig.buttonTitle;
+    }
+    if (inputResendConfig.enableDelay) {
+      resendConfig.enableDelay = inputResendConfig.enableDelay;
+    }
+    if (inputResendConfig.maxResends) {
+      resendConfig.maxResends = inputResendConfig.maxResends;
+    }
+  }
+  return resendConfig;
+};
+
+export function maskContactId(contactId: string) {
+  const idString = String(contactId);
+
+  // Check if it's an email based on the presence of '@'
+  if (idString.includes('@')) {
+    // Split email into username and domain parts
+    const [username, domain] = idString.split('@');
+
+    // Show first 3 characters and replace the rest with asterisks
+    const visibleUsername =
+      username.slice(0, 3) + '*'.repeat(username.length - 3);
+
+    return `${visibleUsername}@${domain}`;
+  } else {
+    // For non-email contact ID, show first 5 characters as asterisks and last 4 digits
+    const lastFourDigits = idString.slice(-4);
+    return `***** *${lastFourDigits}`;
   }
-  // Exact Value
-  else if (validation.selectedIndex === 1) {
-    // @ts-ignore
-    const value: InputType = validation.logic.value;
-    return value == otp;
+}
+
+export const truncateOrderId = (shipmentId: string) => {
+  let displayShipmentId = '';
+  if (shipmentId?.length >= 16) {
+    const startingTen = shipmentId.slice(0, 5);
+    const lastTen = shipmentId.slice(-5);
+    displayShipmentId = `${startingTen}...${lastTen}`;
+  } else {
+    displayShipmentId = shipmentId;
   }
-  // Invalid input received
-  else {
+  return displayShipmentId;
+};
+
+export const isNotNullOrEmpty = (value: any): boolean => {
+  if (value === null || value === undefined) {
+    return false;
+  }
+  if (typeof value === 'string' && value.trim() === '') {
     return false;
   }
+  if (Array.isArray(value) && value.length === 0) {
+    return false;
+  }
+  return true;
 };
 
-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;
+export function generateContactList(
+  response: EmailAndPhoneResponse,
+  orderId?: string
+): ContactType[] {
+  // Initialize an array to store the transformed contact list
+  const contactList: ContactType[] = [];
+
+  // Handle the primary phone number
+  if (response.phone?.number) {
+    contactList.push({
+      id: response.id, // Unique identifier
+      mode: 'PHONE',
+      type: 'PRIMARY',
+      index: 0,
+      value: response.phone.number, // Actual phone number
+      orderId,
+    });
+  }
+
+  // Handle additional phone numbers
+  if (response.additionalPhone?.length) {
+    response.additionalPhone.forEach((phone, idx) => {
+      if (phone?.number) {
+        contactList.push({
+          id: response.id, // Unique identifier
+          mode: 'PHONE',
+          type: 'SECONDARY',
+          index: idx,
+          value: phone.number, // Actual phone number
+          orderId,
+        });
+      }
+    });
+  }
+
+  // Handle the primary email
+  if (response.email) {
+    contactList.push({
+      id: response.id, // Unique identifier
+      mode: 'EMAIL',
+      type: 'PRIMARY',
+      index: 0,
+      value: response.email, // Actual email address
+      orderId,
+    });
+  }
+
+  // Handle additional emails
+  if (response.additionalEmail?.length) {
+    response.additionalEmail.forEach((email, idx) => {
+      if (email?.id) {
+        contactList.push({
+          id: response.id, // Unique identifier
+          mode: 'EMAIL',
+          type: 'SECONDARY',
+          index: idx,
+          value: email.id, // Actual email address
+          orderId,
+        });
+      }
+    });
+  }
+
+  return contactList;
+}
+
+export const getUniqueRefId = (
+  moId: string,
+  progressGroupId?: string | null,
+  attemptCount?: number | null
+) => {
+  const refId = `${moId}${progressGroupId ? '::' + progressGroupId : ''}${
+    attemptCount ? '::' + attemptCount : ''
+  }`;
+  const _hashedRefId = getUuidByString(refId?.toString()?.trim());
+  return _hashedRefId;
+};
+
+export const updateRetryCount = async (retryCount: number) => {
+  let storage = Storage.getInstance();
+
+  await storage.setSharedItem(
+    SHARED_PREFERENCE_RETRY_COUNT,
+    JSON.stringify(retryCount)
+  );
+};
+
+export const updateResendCount = async (retryCount: number) => {
+  let storage = Storage.getInstance();
+
+  await storage.setSharedItem(
+    SHARED_PREFERENCE_RESEND_COUNT,
+    JSON.stringify(retryCount)
+  );
+};
+
+export const getCount = async (type: countType): Promise<number> => {
+  const storage = Storage.getInstance();
+  let count: any = 0;
+
+  if (type === countType.RESEND) {
+    count = await storage.getSharedItem(SHARED_PREFERENCE_RESEND_COUNT);
+  } else if (type === countType.RETRY) {
+    count = await storage.getSharedItem(SHARED_PREFERENCE_RETRY_COUNT);
+  }
+
+  // Parse and validate the count
+  if (count) {
+    try {
+      const parsedCount = JSON.parse(count);
+      if (typeof parsedCount === 'number') {
+        return parsedCount;
+      }
+    } catch (error) {
+      console.warn('Invalid count value:', count);
     }
   }
-  return retryConfig;
+
+  // Default to 0 if count is invalid
+  return 0;
+};
+
+export const resetCount = async () => {
+  let storage = Storage.getInstance();
+
+  await storage.setSharedItem(
+    SHARED_PREFERENCE_RESEND_COUNT,
+    JSON.stringify(0)
+  );
+
+  await storage.setSharedItem(SHARED_PREFERENCE_RETRY_COUNT, JSON.stringify(0));
 };

package/src/components/utils/Scale.ts

@@ -0,0 +1,13 @@
+import { Dimensions } from 'react-native';
+const { width, height } = Dimensions.get('window');
+
+//Guideline sizes are based on standard ~5" screen mobile device
+const guidelineBaseWidth = 350;
+const guidelineBaseHeight = 680;
+
+const sWidth = (size: number) => (width / guidelineBaseWidth) * size;
+const sHeight = (size: number) => (height / guidelineBaseHeight) * size;
+const sCorner = (size: number, factor = 0.5) =>
+  size + (sWidth(size) - size) * factor;
+
+export { sWidth, sHeight, sCorner };

package/src/components/widgets/ConfirmCancelModal.tsx

@@ -0,0 +1,49 @@
+import React from 'react';
+import ModalWidget from './ModalWidget';
+import { StyleSheet } from 'react-native';
+
+interface ConfirmCancelProps {
+  showModal: boolean;
+  setShowModal: React.Dispatch<React.SetStateAction<boolean>>;
+  onSuccess: () => any;
+  onFailure: () => any;
+}
+
+const ConfirmCancelModal = (props: ConfirmCancelProps) => {
+  return (
+    <ModalWidget
+      dismissable={true}
+      showModal={props.showModal}
+      title={{ label: 'Are you sure you want to cancel orders?' }}
+      primaryButton={{
+        label: 'Yes',
+        onPress: props.onSuccess,
+        styles: modalStyles.primaryButtonStyles,
+      }}
+      secondaryButton={{
+        label: 'No',
+        onPress: props.onFailure,
+        styles: modalStyles.secondaryButtonStyles,
+      }}
+    />
+  );
+};
+
+export default ConfirmCancelModal;
+
+const modalStyles = StyleSheet.create({
+  primaryButtonStyles: {
+    marginTop: 16,
+    height: 40,
+    borderRadius: 6,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  secondaryButtonStyles: {
+    marginVertical: 16,
+    height: 40,
+    borderRadius: 6,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+});

package/src/components/widgets/SnackBarCustom.tsx

@@ -1,3 +1,4 @@
+/* eslint-disable react-native/no-inline-styles */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import React from 'react';
 import {
@@ -23,26 +24,22 @@ import { fireEventWithScreenName } from '../../analytics/sentry/SentryAnalyticsU
 export interface SnackbarProps {
   visible: boolean;
   duration?: number;
-  /**
-   * Callback called when Snackbar is dismissed. The `visible` prop needs to be updated when this is called.
-   */
   onDismiss: () => void;
-  /**
-   * Text content of the Snackbar.
-   */
   message: string;
   type?: SnackBarType;
   theme: ReactNativePaper.Theme;
   customBottom?: number;
   customTop?: number;
 }
-const DURATION_MEDIUM = 3000;
+const DURATION_MEDIUM = 4500;
 
 export enum SnackBarType {
   SUCCESS,
   FAILURE,
   WARNING,
   PAYMENT_WARNING,
+  OTP_SUCCESS,
+  OTP_FAILED,
 }
 
 const SnackbarCustom = ({
@@ -63,6 +60,11 @@ const SnackbarCustom = ({
   const hideTimeout = React.useRef<NodeJS.Timeout | undefined>(undefined);
   const { scale } = theme.animation;
 
+  const isDarkColorType =
+    type === SnackBarType.PAYMENT_WARNING ||
+    type === SnackBarType.OTP_FAILED ||
+    type === SnackBarType.OTP_SUCCESS;
+
   React.useEffect(() => {
     return () => {
       if (hideTimeout.current) clearTimeout(hideTimeout.current);
@@ -128,7 +130,7 @@ const SnackbarCustom = ({
           [
             styles.container,
             {
-              borderRadius: roundness,
+              borderRadius: roundness ? roundness : 8,
               opacity: opacity,
               transform: [
                 {
@@ -153,6 +155,10 @@ const SnackbarCustom = ({
               ? styles.warn
               : type && type === SnackBarType.PAYMENT_WARNING
               ? styles.paymentWarn
+              : type && type === SnackBarType.OTP_SUCCESS
+              ? styles.otpSuccess
+              : type && type === SnackBarType.OTP_FAILED
+              ? styles.otpFailed
               : styles.main
           }
         >
@@ -160,6 +166,10 @@ const SnackbarCustom = ({
             <AntDesign name="exclamationcircleo" size={20} color="white" />
           ) : type && type === SnackBarType.PAYMENT_WARNING ? (
             <AntDesign name="infocirlceo" size={20} color="#D97706" />
+          ) : type && type === SnackBarType.OTP_SUCCESS ? (
+            <AntDesign name="checkcircleo" size={20} color="#059669" />
+          ) : type && type === SnackBarType.OTP_FAILED ? (
+            <AntDesign name="closecircleo" size={20} color="#DC2626" />
           ) : (
             <AntDesign name="checkcircleo" size={20} color="white" />
           )}
@@ -167,6 +177,8 @@ const SnackbarCustom = ({
             style={[
               styles.messageStyle,
               type === SnackBarType.PAYMENT_WARNING && { color: '#B45309' },
+              type === SnackBarType.OTP_SUCCESS && { color: '#059669' },
+              type === SnackBarType.OTP_FAILED && { color: '#DC2626' },
             ]}
           >
             {message}
@@ -174,11 +186,7 @@ const SnackbarCustom = ({
           <AntDesign
             name="close"
             size={20}
-            color={
-              type && type === SnackBarType.PAYMENT_WARNING
-                ? '#3D445C'
-                : 'white'
-            }
+            color={isDarkColorType ? '#3D445C' : 'white'}
             onPress={() => {
               setHidden(true);
               onDismiss();
@@ -244,6 +252,22 @@ const styles = StyleSheet.create({
     flex: 1,
     borderRadius: 8,
   },
+  otpSuccess: {
+    padding: 12,
+    flexDirection: 'row',
+    alignItems: 'center',
+    backgroundColor: '#ECFDF5',
+    flex: 1,
+    borderRadius: 8,
+  },
+  otpFailed: {
+    padding: 12,
+    flexDirection: 'row',
+    alignItems: 'center',
+    backgroundColor: '#FEF2F2',
+    flex: 1,
+    borderRadius: 8,
+  },
   messageStyle: {
     fontSize: 14,
     marginStart: 8,