super-app/App/common/screen/ScreenActionHandler.tsx

import { ActionMetaData, BaseActionTypes } from "../actions/GenericAction";
import { ScreenData } from "../interface/widgets/screenData/ScreenData";
import { ScreenActionTypes } from "./ScreenActionTypes";
import { Dispatch, SetStateAction } from "react";
import { post, get } from "../../../network/NetworkService";
import { CtaData } from "../interface";
import { getXTargetHeaderInfo } from "../../../network/ApiClient";
import { GI } from "../constants/NavigationHandlerConstants";
import { ScreenState } from "./BaseScreen";
import { BASE_SCREEN } from "../constants/ScreenNameConstants";
import { logToSentry } from "../hooks/useSentryLogging";
import {
  sendAsAnalyticsEvent,
  sendAsGlobalErrorEvent,
} from "../hooks/useAnalyticsEvent";
import {
  AnalyticsFlowNameConstant,
  AnalyticsGlobalErrorTypeConstant,
  AnalyticsMethodNameConstant,
  AnalyticsModuleNameConstant,
} from "../constants/AnalyticsEventsConstant";
import {
  getStringPreference,
  setStringPreference,
} from "../utilities/SharedPreferenceUtils";

export const ScreenActionHandler = {
  handleScreenAction: (
    screenMetaData: ActionMetaData,
    setScreenData: Dispatch<SetStateAction<ScreenData | null>>,
    screenData?: ScreenData | null,
    navigation?: any,
  ) => {
    switch (screenMetaData.actionType) {
      case ScreenActionTypes.FETCH_INSURANCE_QUOTE_PAGE_FROM_BACKEND: {
        let quoteId = screenMetaData.data.quoteId;
        if (!quoteId) {
          getQuoteIdFromCache().then(value => {
            if (!!value) {
              quoteId = value;
              return get<ApiResponse<CtaData>>(
                `v3/quotes/${quoteId}`,
                getXTargetHeaderInfo(GI.toLocaleUpperCase()),
              )
                .then(response => {
                  handleResponseData(setScreenData, response);
                })
                .catch(error => {
                  handleErrorData(
                    error,
                    setScreenData,
                    screenMetaData,
                    AnalyticsMethodNameConstant.FETCH_INSURANCE_QUOTE_PAGE_FROM_BACKEND,
                    ScreenActionTypes.FETCH_INSURANCE_QUOTE_PAGE_FROM_BACKEND,
                  );
                });
            }
            return;
          });
        } else {
          return get<ApiResponse<CtaData>>(
            `v3/quotes/${quoteId}`,
            getXTargetHeaderInfo(GI.toLocaleUpperCase()),
          )
            .then(response => {
              handleResponseData(setScreenData, response);
            })
            .catch(error => {
              handleErrorData(
                error,
                setScreenData,
                screenMetaData,
                AnalyticsMethodNameConstant.FETCH_INSURANCE_QUOTE_PAGE_FROM_BACKEND,
                ScreenActionTypes.FETCH_INSURANCE_QUOTE_PAGE_FROM_BACKEND,
              );
            });
        }
        return;
      }
      case ScreenActionTypes.FETCH_QUOTE_V3: {
        return post<ApiResponse<CtaData>>(
          "v3/quotes",
          screenMetaData.data,
          getXTargetHeaderInfo(GI.toLocaleUpperCase()),
        )
          .then(response => {
            if (screenData?.screenState) {
              screenData.screenState = ScreenState.LOADING;
            }
            setPostApiData();
            if (response.data) {
              const cta = response.data as CtaData;
              let quoteId;
              cta?.parameters?.forEach(item => {
                if (item.key === "quoteId") {
                  quoteId = item.value;
                }
              });
              if (!!quoteId) {
                storeQuoteId(quoteId);
              }
              // By default routing is happening via Base screen hence below navigate sends the cta there to get routed to specific screenName based on Cta
              if (!!cta.analyticsEventProperties) {
                sendAsAnalyticsEvent(cta.analyticsEventProperties);
              }
              navigation.navigate(BASE_SCREEN, { ctaData: cta });
            }
          })
          .catch(error => {
            handleErrorData(
              error,
              setScreenData,
              screenMetaData,
              AnalyticsMethodNameConstant.FETCH_QUOTE_V3,
              ScreenActionTypes.FETCH_QUOTE_V3,
            );
          });
      }
      case ScreenActionTypes.FETCH_COMPARE_PLAN_LIST: {
        return post<ApiResponse<CtaData>>(
          "quotes/compare-plans",
          screenMetaData.data,
          getXTargetHeaderInfo(GI.toLocaleUpperCase()),
        )
          .then(response => {
            const updatedScreenData: ScreenData = {
              ...(response.data as ScreenData),
              screenState: ScreenState.LOADED,
            };
            setScreenData(updatedScreenData);
            return;
          })
          .catch(error => {
            handleErrorData(
              error,
              setScreenData,
              screenMetaData,
              AnalyticsMethodNameConstant.COMPARE_PLAN_LIST,
              ScreenActionTypes.FETCH_COMPARE_PLAN_LIST,
            );
          });
      }
      case ScreenActionTypes.SHOW_LOADER: {
        const updatedScreenData: ScreenData = {
          ...screenData,
          screenState: ScreenState.LOADING,
        };
        setScreenData(updatedScreenData);
        return;
      }
      default:
        return;
    }
  },
};

const setPostApiData = () => {
  return setStringPreference("POST_API_CALLED", "true");
};

const storeQuoteId = (quoteId: string) => {
  return setStringPreference("QUOTE_ID", quoteId);
};

const getQuoteIdFromCache = async () => {
  return await getStringPreference("QUOTE_ID", "string");
};

const handleResponseData = (
  setScreenData: Dispatch<SetStateAction<ScreenData | null>>,
  response: any,
) => {
  const updatedScreenData: ScreenData = {
    ...(response.data as ScreenData),
    screenState: ScreenState.LOADED,
  };
  setScreenData(updatedScreenData);
  return;
};

const handleErrorData = (
  error: any,
  setScreenData: Dispatch<SetStateAction<ScreenData | null>>,
  screenMetaData: ActionMetaData,
  methodName: string,
  actionType: string,
) => {
  logToSentry(
    `No response from api call: ${screenMetaData.actionType} | Error: ${error} | MethodName: handleScreenAction`,
  );
  const errorEvent: GlobalErrorData = {
    reason: `${error.message}, axiosError: ${error.axiosCode}`,
    statusCode: error.statusCode,
    moduleName: AnalyticsModuleNameConstant.GI,
    flowName: AnalyticsFlowNameConstant.GI_RN_QUOTE,
    methodName: methodName,
    globalErrorType: AnalyticsGlobalErrorTypeConstant.GLOBAL_INTERNAL_ERRORS,
    isAppDowntimeEvent: true,
  };
  sendAsGlobalErrorEvent(errorEvent);
  const updatedScreenData: ScreenData = {
    screenState: ScreenState.ERROR,
    errorMetaData: {
      baseActionType: BaseActionTypes.SCREEN_ACTION,
      metaData: [
        {
          actionType: ScreenActionTypes.SHOW_LOADER,
        },
        {
          data: screenMetaData.data,
          actionType: actionType,
        },
      ],
    },
  };
  setScreenData(updatedScreenData);
  return;
};