super-app/App/common/widgets/widget-actions/WidgetActionHandler.ts

import { Dispatch, SetStateAction } from "react";
import {
  SumInsuredRequestData,
  handlePatchRenewalQuote,
  updateSumInsuredData,
} from "../../../Container/Navi-Insurance/network";

import {
  ActionMetaData,
  GenericActionPayload,
  TargetWidgetPayload,
} from "../../actions/GenericAction";
import { ApiMethod } from "../../constants";
import {
  AnalyticsEventNameConstants,
  AnalyticsFlowNameConstant,
  AnalyticsMethodNameConstant,
  AnalyticsModuleNameConstant,
  EVENT_NAMES,
} from "../../constants/AnalyticsEventsConstant";
import {
  sendAsAnalyticsEvent,
  sendAsGlobalErrorEvent,
} from "../../hooks/useAnalyticsEvent";
import { AnalyticsEvent, CtaData } from "../../interface";
import { ScreenData } from "../../interface/widgets/screenData/ScreenData";
import { FinalPatchCallRequestBody } from "../../interface/widgets/widgetData/FooterWithCardWidgetData";
import { ScreenState } from "../../screen/BaseScreen";
import {
  getApplicationFromScreenMetaData,
  getApplicationIdFromCta,
  getQuoteIdFromCta,
  getQuoteIdFromScreenMetaData,
} from "../../utilities/CtaParamsUtils";
import { getErrorTypeFromStatusCode } from "../../utilities/ErrorUtils";
import { updateValueByKeyPath } from "../../utilities/MiscUtils";
import { globalHandleClick } from "../../utilities/NavigationUtil";
import { parseValue } from "../../utilities/SerializerUtil";
import { WidgetActionTypes } from "./WidgetActionTypes";

const WidgetActionHandler = {
  handleWidgetAction: (
    widgetMetaData: ActionMetaData,
    setScreenData: Dispatch<SetStateAction<ScreenData | null>>,
    setErrorMetaData:
      | Dispatch<SetStateAction<ActionMetaData[] | null>>
      | undefined,
    screenData?: ScreenData | null,
    ctaData?: CtaData,
    navigation?: any,
  ) => {
    switch (widgetMetaData.actionType) {
      case WidgetActionTypes.UPDATE_WIDGET_DATA: {
        if (!!screenData) {
          const updatedScreenData = { ...screenData } as ScreenData;
          widgetMetaData?.data?.forEach(
            (targetWidgetPayload: any, _: number) => {
              if (
                (targetWidgetPayload as TargetWidgetPayload).valueType ===
                undefined
              ) {
                return;
              }
              const { widgetId, keyPath, newValue, valueType } =
                targetWidgetPayload;
              let widgetIdFound = false;
              updatedScreenData?.screenWidgets?.contentWidgets?.forEach(
                widget => {
                  if (widget.widgetId === widgetId && keyPath === "") {
                    if (newValue === "false") {
                      widget.widgetVisibility = false;
                      return;
                    }
                    widget.widgetVisibility = true;
                  }
                  if (widget?.widgetId === widgetId && !!keyPath) {
                    updateValueByKeyPath(
                      widget.widgetData,
                      keyPath,
                      parseValue(newValue, valueType),
                    );
                    setScreenData(updatedScreenData);
                    widgetIdFound = true;
                    return;
                  }
                },
              );
              !widgetIdFound
                ? updatedScreenData?.screenWidgets?.footerWidgets?.forEach(
                    widget => {
                      if (widget.widgetId === widgetId && keyPath === "") {
                        if (newValue === "false") {
                          widget.widgetVisibility = false;
                          return;
                        }
                        widget.widgetVisibility = true;
                      }
                      if (widget?.widgetId === widgetId && !!keyPath) {
                        updateValueByKeyPath(
                          widget.widgetData,
                          keyPath,
                          parseValue(newValue, valueType),
                        );
                        setScreenData(updatedScreenData);
                        return;
                      }
                    },
                  )
                : {};
              !widgetIdFound
                ? updatedScreenData?.screenWidgets?.headerWidgets?.forEach(
                    widget => {
                      if (widget.widgetId === widgetId && keyPath === "") {
                        if (newValue === "false") {
                          widget.widgetVisibility = false;
                          return;
                        }
                        widget.widgetVisibility = true;
                      }
                      if (widget?.widgetId === widgetId && !!keyPath) {
                        updateValueByKeyPath(
                          widget.widgetData,
                          keyPath,
                          parseValue(newValue, valueType),
                        );
                        setScreenData(updatedScreenData);
                        return;
                      }
                    },
                  )
                : {};
            },
          );
          setScreenData(updatedScreenData);
          return;
        }
        return;
      }

      case WidgetActionTypes.PATCH_QUOTE_V2: {
        let quoteId =
          getQuoteIdFromCta(ctaData) ??
          getQuoteIdFromScreenMetaData(screenData?.screenMetaData);
        let applicationId =
          getApplicationIdFromCta(ctaData) ??
          getApplicationFromScreenMetaData(screenData?.screenMetaData);
        const requestData: SumInsuredRequestData = widgetMetaData.data;
        requestData.applicationId = applicationId;
        return updateSumInsuredData(requestData, quoteId!!)
          .then(response => {})
          .catch(error => {
            const errorEvent: AnalyticsEvent = {
              name: AnalyticsEventNameConstants.PATCH_QUOTE_V2,
            };
            sendAsAnalyticsEvent(errorEvent);
          });
      }

      case WidgetActionTypes.FINAL_PATCH_CALL: {
        setScreenData({
          ...screenData,
          screenState: ScreenState.OVERLAY,
        });
        let quoteId =
          getQuoteIdFromCta(ctaData) ??
          getQuoteIdFromScreenMetaData(screenData?.screenMetaData);
        let applicationId =
          getApplicationIdFromCta(ctaData) ??
          getApplicationFromScreenMetaData(screenData?.screenMetaData);
        const requestData: SumInsuredRequestData = (
          widgetMetaData?.data as FinalPatchCallRequestBody
        ).requestData;
        const nextPageCta: CtaData = (
          widgetMetaData?.data as FinalPatchCallRequestBody
        ).nextPageCta;
        requestData.applicationId = applicationId;
        const url = `v3/quotes/${quoteId}`;
        return updateSumInsuredData(requestData, quoteId!!)
          .then(response => {
            handleResponseData(nextPageCta, setScreenData, screenData);
          })
          .catch(error => {
            handleErrorData(
              error,
              setScreenData,
              widgetMetaData,
              AnalyticsMethodNameConstant.FINAL_PATCH_CALL,
              AnalyticsFlowNameConstant.GI_RN_QUOTE,
              screenData,
              url,
              ApiMethod.PATCH,
            );
          });
      }

      case WidgetActionTypes.PATCH_RENEWAL_QUOTE: {
        handlePatchRenewalQuote({
          widgetMetaData,
          ctaData,
          setScreenData,
          setErrorMetaData,
          navigation,
          screenData,
        });
        return;
      }

      case WidgetActionTypes.SHOW_LOADER: {
        const updatedScreenData: ScreenData = {
          ...screenData,
          screenState: ScreenState.LOADING,
        };
        setScreenData(updatedScreenData);
        return;
      }
      case WidgetActionTypes.ANALYTIC_ACTION: {
        widgetMetaData?.analyticsEventProperties &&
          sendAsAnalyticsEvent(widgetMetaData?.analyticsEventProperties);
        return;
      }

      default: {
        return;
      }
    }
  },

  getTargetWidgetActionPayload: (
    value: any | undefined | null,
    actionPayloadList: GenericActionPayload | undefined,
  ): GenericActionPayload | undefined => {
    if (!actionPayloadList) {
      return undefined;
    }
    let updatedActionPayload: GenericActionPayload = {
      ...actionPayloadList,
      metaData: actionPayloadList.metaData?.map(actionPayload => {
        let updatedList = actionPayload?.data?.map(
          (targetWidgetPayload: any) => {
            if (
              (targetWidgetPayload as TargetWidgetPayload).valueType ===
              undefined
            ) {
              return targetWidgetPayload;
            }
            let newValue = value;
            if (
              typeof value === "object" &&
              value !== null &&
              !Array.isArray(value) &&
              targetWidgetPayload?.actionId &&
              value[targetWidgetPayload.actionId]
            ) {
              newValue = value[targetWidgetPayload.actionId];
            }
            return {
              ...targetWidgetPayload,
              newValue: newValue,
            };
          },
        );
        const widgetActionMeta: ActionMetaData = {
          actionType: actionPayload.actionType,
          data: updatedList,
        };
        return widgetActionMeta;
      }),
    };
    return updatedActionPayload;
  },
};

export const handleResponseData = (
  nextPageCta: CtaData,
  setScreenData: Dispatch<SetStateAction<ScreenData | null>>,
  screenData?: ScreenData | null,
  navigation?: any,
) => {
  const updatedNextPageCta: CtaData = {
    ...nextPageCta,
    finish: nextPageCta.finish ? nextPageCta.finish : false,
  };
  globalHandleClick(navigation, updatedNextPageCta);
  setScreenData({
    ...screenData,
    screenState: ScreenState.LOADED,
  });
  return;
};

export const handleErrorData = (
  error: any,
  setScreenData: Dispatch<SetStateAction<ScreenData | null>>,
  widgetMetaData: ActionMetaData,
  methodName: string,
  flowName: string,
  screenData?: ScreenData | null,
  apiUrl?: string,
  apiMethod?: string,
) => {
  sendAsAnalyticsEvent({
    name: AnalyticsEventNameConstants.HI_RN_INVALID_DATA_ERROR,
    properties: {
      errorType: EVENT_NAMES.API_NO_RESPONSE_ERROR,
      error: `${widgetMetaData.actionType}`,
      methodName: "handleWidgetAction",
    },
  });
  const errorEvent: GlobalErrorData = {
    reason: `${error.message}, axiosError: ${error.axiosCode}`,
    source: widgetMetaData.screenName || "",
    statusCode: error.statusCode,
    moduleName: AnalyticsModuleNameConstant.GI,
    flowName: flowName,
    methodName: methodName,
    globalErrorType: getErrorTypeFromStatusCode(error.statusCode),
    isAppDowntimeEvent: false,
    isNae: false,
    apiUrl: apiUrl,
    apiMethod: apiMethod,
  };
  sendAsGlobalErrorEvent(errorEvent);
  setScreenData({
    ...screenData,
    screenState: ScreenState.LOADED,
  });
  return;
};

export default WidgetActionHandler;