@jolibox/implement 1.1.38 → 1.1.39

package/src/native/rewards/check-frequency.ts

@@ -12,97 +12,59 @@ const parseFrequency = (data: string) => {
   return fequeycies;
 };
 
-/**
- * check can show useModal
- * @param config
- * @returns
- */
-export const checkUseModalFrequency = async (config: { dailyMaxPopUps: number; minInterval: number }) => {
-  const { dailyMaxPopUps, minInterval } = config;
-  const res = (await getGlobalStorage('joli_coin_use_modal_frequency')) as StandardResponse<string>;
-  console.log('checkUseModalFrequency', res.data);
-  if (!res.data) {
-    return {
-      canShow: true,
-      isFirst: true
-    };
-  }
-
-  const fequeycies = parseFrequency(res.data);
-  const todayFequencies = filterTodayTimestamps(fequeycies);
-  if (todayFequencies.length >= dailyMaxPopUps) {
-    return {
-      canShow: false,
-      isFirst: false
-    };
-  }
-  const now = Date.now();
-  if (now - todayFequencies[todayFequencies.length - 1] < minInterval) {
-    return {
-      canShow: false,
-      isFirst: false
-    };
-  }
-  return {
-    canShow: true,
-    isFirst: false
-  };
-};
+// common get frequency
+function createFrequencyChecker(storageKey: string) {
+  return async (config: { dailyMaxPopUps?: number; minInterval?: number }) => {
+    const { dailyMaxPopUps, minInterval } = config;
+    const res = (await getGlobalStorage(storageKey)) as StandardResponse<string>;
 
-export const updateUseModalFrequency = async () => {
-  const now = Date.now();
-  const res = (await getGlobalStorage('joli_coin_use_modal_frequency')) as StandardResponse<string>;
+    if (!res.data) {
+      return {
+        canShow: true,
+        isFirst: true
+      };
+    }
+    const frequencies = parseFrequency(res.data);
+    const todayFrequencies = filterTodayTimestamps(frequencies);
+    if (dailyMaxPopUps && todayFrequencies.length >= dailyMaxPopUps) {
+      return {
+        canShow: false,
+        isFirst: false
+      };
+    }
 
-  const frequencies = parseFrequency(res.data ?? '[]') as number[];
-  frequencies.push(now);
-  frequencies.sort((a, b) => b - a).splice(8);
+    const now = Date.now();
+    console.log('todayFrequencies', todayFrequencies, minInterval, now - todayFrequencies[0]);
 
-  await setGlobalStorage('joli_coin_use_modal_frequency', JSON.stringify(frequencies));
-};
-
-/**
- * check can show paymentModal
- */
-export const checkPaymentFrequency = async (config: { dailyMaxPopUps: number; minInterval: number }) => {
-  const { dailyMaxPopUps, minInterval } = config;
-  const res = (await getGlobalStorage('joli_coin_payment_frequency')) as StandardResponse<string>;
-  console.log('checkPaymentFrequency', res.data);
-  if (!res.data) {
+    if (minInterval && now - (todayFrequencies?.[0] ?? 0) < minInterval) {
+      return {
+        canShow: false,
+        isFirst: false
+      };
+    }
     return {
       canShow: true,
-      isFirst: true
-    };
-  }
-  const frequencies = parseFrequency(res.data);
-  const todayFequencies = filterTodayTimestamps(frequencies);
-  if (todayFequencies.length >= dailyMaxPopUps) {
-    return {
-      canShow: false,
-      isFirst: false
-    };
-  }
-  const now = Date.now();
-  if (now - todayFequencies[todayFequencies.length - 1] < minInterval) {
-    return {
-      canShow: false,
       isFirst: false
     };
-  }
-  return {
-    canShow: true,
-    isFirst: false
   };
-};
+}
 
-/**
- * update paymentFrequency
- */
-export const updatePaymentFrequency = async () => {
-  const now = Date.now();
-  const res = (await getGlobalStorage('joli_coin_payment_frequency')) as StandardResponse<string>;
-  const fequeycies: number[] = parseFrequency(res.data ?? '[]');
+export const checkUseModalFrequency = createFrequencyChecker('joli_coin_use_modal_frequency');
+export const checkPaymentFrequency = createFrequencyChecker('joli_coin_payment_frequency');
+export const checkUnloginModalFrequency = createFrequencyChecker('joli_coin_unlogin_modal_frequency');
 
-  fequeycies.push(now);
-  fequeycies.sort((a, b) => b - a).splice(8);
-  await setGlobalStorage('joli_coin_payment_frequency', JSON.stringify(fequeycies));
-};
+// common update frequency
+function createFrequencyUpdater(storageKey: string) {
+  return async () => {
+    const now = Date.now();
+    const res = (await getGlobalStorage(storageKey)) as StandardResponse<string>;
+    const frequencies: number[] = parseFrequency(res.data ?? '[]');
+    frequencies.push(now);
+    frequencies.sort((a, b) => b - a).splice(8);
+    await setGlobalStorage(storageKey, JSON.stringify(frequencies));
+  };
+}
+
+export const updateUseModalFrequency = createFrequencyUpdater('joli_coin_use_modal_frequency');
+export const updatePaymentFrequency = createFrequencyUpdater('joli_coin_payment_frequency');
+export const updateUnloginModalFrequency = createFrequencyUpdater('joli_coin_unlogin_modal_frequency');

package/src/native/rewards/index.ts

@@ -2,373 +2,6 @@
  * rewards event handlers
  */
 
-import {
-  rewardsEmitter,
-  UseModalEventName,
-  IUseModalEvent,
-  PaymentResultEventName,
-  UseModalResultEventName,
-  InvokePaymentEventName,
-  IInvokePaymentEvent,
-  IPaymentChoice,
-  UseModalFrequencyEventName,
-  IUseModalFrequencyConfig
-} from '@/common/rewards/reward-emitter';
-import { createConfirmJolicoinModal, createPaymentJolicoinModal, createToast } from '@jolibox/ui';
-import { innerFetch as fetch } from '../network';
-import { StandardResponse } from '@jolibox/types';
-import { context } from '@/common/context';
-import { login } from '../api/login';
-import { EventType } from '@jolibox/common';
-
-import { createEventPromiseHandler } from '@/common/rewards/registers/utils/event-listener';
-import {
-  checkUseModalFrequency,
-  updateUseModalFrequency,
-  checkPaymentFrequency,
-  updatePaymentFrequency
-} from './check-frequency';
-import { paymentHelper } from '../payment';
-import { createLoading } from '@jolibox/ui';
-import { canIUseNative } from '../api/base';
-import { applyNative } from '@jolibox/native-bridge';
-import { isUndefinedOrNull } from '@jolibox/common';
-import { track } from '../report';
-
-const modalUseFrequencyConfig = createEventPromiseHandler<
-  IUseModalFrequencyConfig,
-  typeof UseModalFrequencyEventName
->(rewardsEmitter, UseModalFrequencyEventName);
-
-modalUseFrequencyConfig.getData();
-
-const loading = createLoading();
-
-/**
- * update config
- */
-
-let updateEnableConfigPromise = Promise.resolve();
-
-/**
- * 更新自动扣费配置的函数
- * @param enabled 是否启用自动扣费
- * @returns Promise 更新操作的Promise
- */
-const updateAutoDeductConfig = async (enabled: boolean): Promise<void> => {
-  updateEnableConfigPromise = updateEnableConfigPromise.then(async () => {
-    await fetch('/api/joli-coin/user-config', {
-      method: 'POST',
-      appendHostCookie: true,
-      data: {
-        enableAutoDeduct: enabled
-      }
-    });
-  });
-
-  await updateEnableConfigPromise;
-};
-
-/**
- * confirm jolicoin modal
- */
-rewardsEmitter.on(UseModalEventName, async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params: IUseModalEvent) => {
-  if (type === 'ADS-JOLI_COIN') {
-    //TODO
-    await loading.show({
-      duration: 3000
-    });
-    const config = await modalUseFrequencyConfig.getData();
-    const { canShow: canShowUseModal, isFirst: isFirstUseModal } = await checkUseModalFrequency(
-      config.joliCoinUseAndCharge.useJolicoin
-    );
-    console.log('use modal show by frequency', canShowUseModal, isFirstUseModal);
-    loading.hide();
-
-    // First, check for direct use: sufficient balance, auto-deduct enabled, and not the first modal.
-    const { balance } = params.userJoliCoin;
-    const useDirectly = balance >= params.joliCoinQuantity && params.enableAutoDeduct;
-    if (useDirectly && !isFirstUseModal) {
-      rewardsEmitter.emit(UseModalResultEventName, { useModalResult: 'CONFIRM' });
-      return;
-    }
-
-    // If not used directly, then check frequency control.
-    if (!canShowUseModal) {
-      // confirm by frequency control
-      rewardsEmitter.emit(UseModalResultEventName, { useModalResult: 'CONFIRM' });
-      return;
-    }
-  }
-
-  track('unlock_popup_show', {
-    eventType: EventType.View,
-    targetType: 'game'
-  });
-
-  const modal = createConfirmJolicoinModal({
-    data: {
-      enableAutoDeduct: params.enableAutoDeduct,
-      userJolicoin: params.userJoliCoin,
-      joliCoinQuantity: params.joliCoinQuantity
-    },
-    buttons: {
-      confirm: {
-        text: params.confirmButtonText,
-        onPress: () => {
-          track('coin_unlock_click', {
-            targetType: 'game',
-            eventType: EventType.Click,
-            coinConsume: params.joliCoinQuantity,
-            ifAutoUnlock: params.enableAutoDeduct
-          });
-          rewardsEmitter.emit(UseModalResultEventName, { useModalResult: 'CONFIRM' });
-          modal.destroy();
-        }
-      },
-      cancel: {
-        text: params.cancelButtonText,
-        onPress: ({ type }) => {
-          if (type === 'FAILED') {
-            track('ad_unlock_click', {
-              targetType: 'game',
-              eventType: EventType.Click
-            });
-          }
-          rewardsEmitter.emit(UseModalResultEventName, {
-            useModalResult: (type ?? '') === 'CANCEL' ? 'CANCEL' : 'FAILED'
-          });
-          modal.destroy();
-        }
-      },
-      onEnableDeductChanged: async (enabled: boolean) => {
-        await updateAutoDeductConfig(enabled);
-      }
-    }
-  });
-
-  await updateUseModalFrequency();
-});
-
-/**
- * payment jolicoin modal
- */
-rewardsEmitter.on(
-  InvokePaymentEventName,
-  async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params: IInvokePaymentEvent) => {
-    try {
-      // TODO： temp remove it for dev
-      if (!canIUseNative('requestPaymentSync:paymentBody:appStoreProductId')) {
-        //TODO: show Toast
-        console.info('requestPaymentSync:paymentBody:appStoreProductId not supported');
-        setTimeout(() => {
-          rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
-        }, 0);
-        return;
-      }
-      // handle showup frequecy
-      if (type === 'ADS-JOLI_COIN') {
-        await loading.show({
-          duration: 3000
-        });
-        const config = await modalUseFrequencyConfig.getData();
-        const { canShow: canShowPaymentModal } = await checkPaymentFrequency(
-          config.joliCoinUseAndCharge.charge
-        );
-        console.log('use payment show by frequency', canShowPaymentModal);
-        loading.hide();
-        if (!canShowPaymentModal) {
-          // return by frequency control
-          rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
-          return;
-        }
-        console.log('show by frequency');
-      }
-
-      /**
-       * TODO: need merge totalAmountStr from native
-       */
-      await loading.show({
-        duration: 3000
-      });
-      const balenceDetails = await getBalenceDetails();
-      loading.hide();
-
-      if (!balenceDetails) {
-        rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
-        return;
-      }
-
-      track('coinorder_show', {
-        targetType: 'game',
-        eventType: EventType.View
-      });
-
-      const modal = createPaymentJolicoinModal({
-        data: {
-          userJolicoin: params.userJoliCoin,
-          joliCoinQuantity: params.joliCoinQuantity,
-          paymentChoices:
-            balenceDetails.paymentChoices?.map((choice) => ({
-              ...choice,
-              totalAmountStr: choice.totalAmountStr ?? ''
-            })) ?? [],
-          enableAutoDeduct: balenceDetails.enableAutoDeduct
-        },
-        buttons: {
-          confirm: {
-            text: params.confirmButtonText,
-            onPress: async (productId: string) => {
-              track('order_pay_ensure', {
-                targetType: 'game',
-                eventType: EventType.Click,
-                payWay: 'app_iap',
-                coinAmount: params.joliCoinQuantity,
-                orderPrice:
-                  balenceDetails.paymentChoices.find((choice) => choice.productId === productId)
-                    ?.totalAmountStr ?? ''
-              });
-              if (!context.hostUserInfo?.isLogin) {
-                const { data } = await login({
-                  skipLogin: true
-                });
-                if (!data?.isLogin) {
-                  console.log('login failed');
-                  return;
-                }
-
-                const balenceDetails = await getBalenceDetails();
-                if ((balenceDetails?.balance ?? 0) >= params.joliCoinQuantity) {
-                  rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
-                  modal.destroy();
-                  return;
-                }
-              }
-              console.log('invokeNativePayment', productId);
-              const appStoreProductId = balenceDetails?.paymentChoices?.find(
-                (choice) => choice.productId === productId
-              )?.appStoreProductId;
-
-              if (!appStoreProductId) {
-                rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
-                modal.destroy();
-                return;
-              }
-              await loading.show({
-                duration: 3000
-              });
-              const { code } = await paymentHelper.invokePayment('JOLI_COIN_IAP', {
-                productId,
-                appStoreProductId
-              });
-              loading.hide();
-              track('order_pay_result', {
-                eventType: EventType.Other,
-                targetType: 'game',
-                payWay: 'app_iap',
-                coinAmount: params.joliCoinQuantity,
-                orderPrice:
-                  balenceDetails.paymentChoices.find((choice) => choice.productId === productId)
-                    ?.totalAmountStr ?? '',
-                payResult: code
-              });
-              if (code !== 'SUCCESS') {
-                /** add timeout for google panel closed */
-                console.info('[JoliboxSDK] payment failed in payment.invokePaymet');
-                return;
-              }
-              rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
-              modal.destroy();
-            }
-          },
-          cancel: {
-            text: params.cancelButtonText,
-            onPress: ({ type }) => {
-              rewardsEmitter.emit(PaymentResultEventName, {
-                paymentResult: (type ?? '') === 'CANCEL' ? 'CANCEL' : 'FAILED'
-              });
-              track('ad_unlock_click', {
-                targetType: 'game',
-                eventType: EventType.Click
-              });
-              modal.destroy();
-            }
-          },
-          onEnableDeductChanged: async (enabled: boolean) => {
-            await updateAutoDeductConfig(enabled);
-          }
-        },
-        onSelect: (productId: string) => {
-          track('coinorder_click', {
-            targetType: 'game',
-            eventType: EventType.Click,
-            coinAmount: params.joliCoinQuantity,
-            orderPrice:
-              balenceDetails.paymentChoices.find((choice) => choice.productId === productId)
-                ?.totalAmountStr ?? ''
-          });
-        }
-      });
-
-      await updatePaymentFrequency();
-    } catch (error) {
-      console.info('payment failed', error);
-      rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
-    }
-  }
-);
-
-const mergeResponseData = (
-  responseData: { paymentChoices: IPaymentChoice[] },
-  data: { [appStoreProductId: string]: { price: string } }
-) => {
-  Object.keys(data).forEach((key) => {
-    const choice = responseData.paymentChoices.find((choice) => choice.appStoreProductId === key);
-    if (choice) {
-      choice.totalAmountStr = data[key].price;
-    }
-  });
-
-  responseData.paymentChoices = responseData.paymentChoices.filter(
-    (choice) => !isUndefinedOrNull(choice.totalAmountStr)
-  ) as IPaymentChoice[];
-  console.info('----mergeResponseData-----', responseData.paymentChoices);
-};
-
-const getBalenceDetails = async (): Promise<
-  | {
-      balance: number;
-      enableAutoDeduct: boolean;
-      paymentChoices: IPaymentChoice[];
-    }
-  | undefined
-> => {
-  const { response } = await fetch<
-    StandardResponse<{
-      balance: number;
-      enableAutoDeduct: boolean;
-      paymentChoices: IPaymentChoice[];
-    }>
-  >('/api/joli-coin/balance-detail', {
-    method: 'GET',
-    appendHostCookie: true,
-    responseType: 'json'
-  });
-
-  console.info('getBalenceDetails', response);
-  const { data } = await applyNative('requestProductDetailsAsync', {
-    appStoreProductIds:
-      response.data?.data?.paymentChoices
-        ?.filter((choice) => typeof choice.appStoreProductId === 'string')
-        .map((choice) => choice.appStoreProductId as string) ?? []
-  });
-
-  if (response.data?.data && data) {
-    mergeResponseData(response.data?.data, data);
-  }
-  console.info('productDetails', response.data?.data);
-  if (response.data?.data?.paymentChoices.length === 0) {
-    throw new Error('paymentChoices is empty');
-  }
-  return response.data?.data;
-};
+import './ui/use-modal';
+import './ui/payment-modal';
+import './ui/unlogin-modal';