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

import { Dispatch, SetStateAction } from "react";
import {
  getAcceptHeaderInfo,
  getXTargetHeaderInfo,
} from "../../../network/ApiClient";
import { GZIP } from "../../../network/NetworkConstant";
import { get, post } from "../../../network/NetworkService";
import { mergeHeaders } from "../../../network/NetworkUtils";
import { ActionMetaData, BaseActionTypes } from "../actions/GenericAction";
import { BASE_SCREEN, GI } from "../constants";
import {
  AnalyticsFlowNameConstant,
  AnalyticsGlobalErrorTypeConstant,
  AnalyticsMethodNameConstant,
  AnalyticsModuleNameConstant,
} from "../constants/AnalyticsEventsConstant";
import {
  sendAsAnalyticsEvent,
  sendAsGlobalErrorEvent,
} from "../hooks/useAnalyticsEvent";
import { logToSentry } from "../hooks/useSentryLogging";
import { CtaData } from "../interface";
import { ScreenData } from "../interface/widgets/screenData/ScreenData";
import { ScreenState } from "./BaseScreen";
import { ScreenActionTypes } from "./ScreenActionTypes";
import { getErrorTypeFromStatusCode } from "../utilities/ErrorUtils";

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;
        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,
            );
          });
      }
      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;
            }
            if (response.data) {
              const cta = response.data as CtaData;
              // 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.FETCH_QUOTE_V4: {
        const acceptHeader = getAcceptHeaderInfo(GZIP);
        const xTargetHeader = getXTargetHeaderInfo(GI.toLocaleUpperCase());
        return post<ApiResponse<CtaData>>(
          "v4/quotes",
          screenMetaData.data,
          mergeHeaders({ configs: [acceptHeader, xTargetHeader] }),
        )
          .then(response => {
            if (screenData?.screenState) {
              setScreenData({
                ...screenData,
                screenState: ScreenState.LOADING,
              });
            }
            if (response) {
              const updatedScreenData: ScreenData = {
                ...(response.data as ScreenData),
                screenState: ScreenState.LOADED,
              };
              // If redirectionCta is present and screenWidgets is not present then navigate to Base screen to get routed to specific screenName based on Cta
              if (
                !!updatedScreenData.screenMetaData?.redirectionCta &&
                !updatedScreenData.screenWidgets
              ) {
                const cta = updatedScreenData.screenMetaData?.redirectionCta;
                // 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 });
              } else {
                if (updatedScreenData?.screenMetaData?.analyticsEvent) {
                  sendAsAnalyticsEvent(
                    updatedScreenData.screenMetaData.analyticsEvent,
                  );
                }
                setScreenData(updatedScreenData);
              }
            }
          })
          .catch(error => {
            handleErrorData(
              error,
              setScreenData,
              screenMetaData,
              AnalyticsMethodNameConstant.FETCH_QUOTE_V4,
              ScreenActionTypes.FETCH_QUOTE_V4,
            );
          });
      }
      case ScreenActionTypes.FETCH_BENEFIT_COMPARE_LIST: {
        return get<ApiResponse<CtaData>>(
          "market-benefit-compare",
          getXTargetHeaderInfo(GI.toLocaleUpperCase()),
        )
          .then(response => {
            handleResponseData(setScreenData, response);
            return;
          })
          .catch(error => {
            handleErrorData(
              error,
              setScreenData,
              screenMetaData,
              AnalyticsMethodNameConstant.MARKET_BENEFIT_COMPARE_LIST,
              ScreenActionTypes.FETCH_BENEFIT_COMPARE_LIST,
            );
          });
      }
      case ScreenActionTypes.SHOW_LOADER: {
        const updatedScreenData: ScreenData = {
          ...screenData,
          screenState: ScreenState.LOADING,
        };
        setScreenData(updatedScreenData);
        return;
      }
      default:
        return;
    }
  },
};

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}`,
    source: screenMetaData.screenName || "",
    statusCode: error.statusCode,
    moduleName: AnalyticsModuleNameConstant.GI,
    flowName: AnalyticsFlowNameConstant.GI_RN_QUOTE,
    methodName: methodName,
    globalErrorType: getErrorTypeFromStatusCode(error.statusCode || -1),
    isAppDowntimeEvent: false,
  };
  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;
};