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

import { Dispatch, SetStateAction } from "react";
import {
  SumInsuredRequestData,
  updateSumInsuredData,
} from "../../../Container/Navi-Insurance/network/QuotePageApi";
import {
  ActionMetaData,
  GenericActionPayload,
  TargetWidgetPayload,
} from "../../actions/GenericAction";
import { CtaData } from "../../interface";
import { ScreenData } from "../../interface/widgets/screenData/ScreenData";
import { ScreenState } from "../../screen/BaseScreen";
import { updateValueByKeyPath } from "../../utilities/MiscUtils";
import { parseValue } from "../../utilities/SerializerUtil";
import { WidgetActionTypes } from "./WidgetActionTypes";
import { NativeDeeplinkNavigatorModule } from "../../native-module/NativeModules";
import { FinalPatchCallRequestBody } from "../../interface/widgets/widgetData/FooterWithCardWidgetData";
import { getQuoteIdFromCta } from "../../utilities/CtaParamsUtils";
import { logToSentry } from "../../hooks/useSentryLogging";
import {
  AnalyticsFlowNameConstant,
  AnalyticsGlobalErrorTypeConstant,
  AnalyticsMethodNameConstant,
  AnalyticsModuleNameConstant,
} from "../../constants/AnalyticsEventsConstant";
import { sendAsGlobalErrorEvent } from "../../hooks/useAnalyticsEvent";

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: {
        const quoteId = getQuoteIdFromCta(ctaData);
        const requestData: SumInsuredRequestData = widgetMetaData.data;
        return updateSumInsuredData(requestData, quoteId!!);
      }

      case WidgetActionTypes.FINAL_PATCH_CALL: {
        setScreenData({
          ...screenData,
          screenState: ScreenState.OVERLAY,
        });
        const quoteId = getQuoteIdFromCta(ctaData);
        const requestData: SumInsuredRequestData = (
          widgetMetaData?.data as FinalPatchCallRequestBody
        ).requestData;
        const nextPageCta: CtaData = (
          widgetMetaData?.data as FinalPatchCallRequestBody
        ).nextPageCta;
        return updateSumInsuredData(requestData, quoteId!!)
          .then((response) => {
            NativeDeeplinkNavigatorModule.navigateToNaviDeeplinkNavigator(
              JSON.stringify(nextPageCta)
            );
            setScreenData({
              ...screenData,
              screenState: ScreenState.LOADED,
            });
            return;
          })
          .catch((error) => {
            logToSentry(
              `No response from api call: ${widgetMetaData.actionType} | Error: ${error} | MethodName: handleWidgetAction}`
            );
            const errorEvent: GlobalErrorData = {
              reason: error.toString(),
              moduleName: AnalyticsModuleNameConstant.GI,
              flowName: AnalyticsFlowNameConstant.GI_RN_QUOTE,
              methodName: AnalyticsMethodNameConstant.FINAL_PATCH_CALL,
              globalErrorType:
                AnalyticsGlobalErrorTypeConstant.GLOBAL_INTERNAL_ERRORS,
              isAppDowntimeEvent: true,
            };
            sendAsGlobalErrorEvent(errorEvent);
            setScreenData({
              ...screenData,
              screenState: ScreenState.LOADED,
            });
            return;
          });
      }

      case WidgetActionTypes.SHOW_LOADER: {
        const updatedScreenData: ScreenData = {
          ...screenData,
          screenState: ScreenState.LOADING,
        };
        setScreenData(updatedScreenData);
        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 default WidgetActionHandler;