@applicaster/zapp-react-native-utils/zappFrameworkUtils/presentPluginOneTime.ts

Applicaster Zapp React Native utilities package

// import * as R from "ramda";
import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
import { createLogger } from "../logger";
import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";

export const { log_debug, log_error, log_info, log_verbose, log_warning } =
  createLogger({
    subsystem: "HookPresentPolicy/PresentOneTime",
  });

// To enable this logic please add in the manifest of the plugin this code:
/*
general: {
    fields: [
      {
        group: true,
        label: "Presentation of the screen",
        tooltip: "These fields affect if hook will be presented one time",
        folded: true,
        fields: [
          {
            type: "switch",
            key: "show_hook_once",
            label_tooltip:
              "Define if hook should be presented on time or each time screen will open",
            initial_value: false,
          },
        ],
      },
    ],
  },
*/

const screenWasPresentedKey = "present_hook_one_time_finished_version_name";
const versionNameKey = "version_name";

export async function saveLatestWatchedVersionNumberToStorage(
  storageKey,
  namespace
) {
  const versionName = await sessionStorage.getItem(versionNameKey);

  log_verbose(
    `PresentHookPluginOneTime: Save presented version name to local storage: ${versionName} for namespace: ${namespace}, key: ${storageKey}`
  );

  return await localStorage.setItem(storageKey, versionName, namespace);
}

export async function removeLatestWatchedVersionNumberFromStorage(
  storageKey,
  namespace
) {
  log_verbose(
    `PresentHookPluginOneTime: remove presented version name to local storage for namespace: ${namespace}, key: ${storageKey}`
  );

  return await localStorage.removeItem(storageKey, namespace);
}

export async function getLatestWatchedVersionNumberFromStorage(
  storageKey,
  namespace
) {
  log_verbose(
    `PresentHookPluginOneTime: get presented version name from local storage for namespace: ${namespace}, key: ${storageKey}`
  );

  return await localStorage.getItem(storageKey, namespace);
}

export const PresentHookPluginOneTime = (
  namespace,
  screenId: string,
  general
) => {
  const storageKey = `${screenWasPresentedKey}_${screenId}`;

  return {
    isEnabled: () => general?.show_hook_once || false,
    shouldPresentScreen: async () => {
      const show_hook_once = general?.show_hook_once || false;

      if (!show_hook_once) {
        log_info(
          "PresentHookPluginOneTime: Hook plugin will be presented: true, presentOneTimeEnabled logic is false"
        );

        return true;
      }

      const presentOneTimeVersionName =
        await getLatestWatchedVersionNumberFromStorage(storageKey, namespace);

      const applicationVersionName =
        await sessionStorage.getItem(versionNameKey);

      if (!presentOneTimeVersionName || !applicationVersionName) {
        log_info(
          "PresentHookPluginOneTime: Hook plugin will be presented: true, presentOneTimeVersionName or applicationVersionName is empty",
          {
            presentOneTimeVersionName,
            applicationVersionName,
          }
        );

        return true;
      }

      if (presentOneTimeVersionName === applicationVersionName) {
        log_info(
          `PresentHookPluginOneTime: Hook plugin will be presented: false, this plugin was already presented before for version name ${applicationVersionName}`,
          {
            presentOneTimeVersionName,
            applicationVersionName,
          }
        );

        return false;
      } else {
        await removeLatestWatchedVersionNumberFromStorage(
          storageKey,
          namespace
        );

        log_info(
          `PresentHookPluginOneTime: Hook plugin will be presented: true, this plugin version name ${applicationVersionName} was not presented yet`,
          {
            presentOneTimeVersionName,
            applicationVersionName,
          }
        );

        return true;
      }
    },
    onFinishHookSuccessfully: async () => {
      const show_hook_once = general?.show_hook_once || false;

      if (!show_hook_once) {
        log_info(
          "PresentHookPluginOneTime:  Plugin state will not be saved, presentOneTimeEnabled logic is false"
        );

        return true;
      }

      log_info("PresentHookPluginOneTime: Plugin hook state will be saved");

      return saveLatestWatchedVersionNumberToStorage(storageKey, namespace);
    },
  };
};